From 22bd431d83a6a743814ae40b39c93b4bacadaed6 Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Fri, 17 Jul 2026 21:01:09 -0500 Subject: [PATCH 1/8] [#17341] - correcting use statements Assisted-by: Claude Code --- .../ADR/Middleware/RequestIdMiddleware.zep | 1 + phalcon/ADR/Payload/Payload.zep | 40 +++++++++---------- 2 files changed, 21 insertions(+), 20 deletions(-) diff --git a/phalcon/ADR/Middleware/RequestIdMiddleware.zep b/phalcon/ADR/Middleware/RequestIdMiddleware.zep index 4a915825de..1e46018040 100644 --- a/phalcon/ADR/Middleware/RequestIdMiddleware.zep +++ b/phalcon/ADR/Middleware/RequestIdMiddleware.zep @@ -16,6 +16,7 @@ namespace Phalcon\ADR\Middleware; use Phalcon\Contracts\ADR\Handler; use Phalcon\Contracts\ADR\Middleware; use Phalcon\Contracts\Http\AttributeRequestInterface; +use Phalcon\Http\Request\Bag\AttributeBag; use Phalcon\Http\ResponseInterface; /** diff --git a/phalcon/ADR/Payload/Payload.zep b/phalcon/ADR/Payload/Payload.zep index 12516eb584..dc43351888 100644 --- a/phalcon/ADR/Payload/Payload.zep +++ b/phalcon/ADR/Payload/Payload.zep @@ -21,7 +21,7 @@ namespace Phalcon\ADR\Payload; -use Phalcon\Contracts\ADR\Payload\Payload as PayloadInterface; +use Phalcon\Contracts\ADR\Payload\Payload as PayloadContract; use Throwable; /** @@ -31,7 +31,7 @@ use Throwable; * unchanged. Named factories provide a concise way to create a payload for the * commonly used statuses. */ -class Payload implements PayloadInterface +class Payload implements PayloadContract { /** * @var Throwable|null @@ -66,7 +66,7 @@ class Payload implements PayloadInterface /** * Creates a payload with the `ACCEPTED` status. */ - public static function accepted(var result = null) -> + public static function accepted(var result = null) -> { return (new static())->withStatus(Status::ACCEPTED)->withResult(result); } @@ -74,7 +74,7 @@ class Payload implements PayloadInterface /** * Creates a payload with the `CREATED` status. */ - public static function created(var result = null) -> + public static function created(var result = null) -> { return (new static())->withStatus(Status::CREATED)->withResult(result); } @@ -82,7 +82,7 @@ class Payload implements PayloadInterface /** * Creates a payload with the `DELETED` status. */ - public static function deleted(var result = null) -> + public static function deleted(var result = null) -> { return (new static())->withStatus(Status::DELETED)->withResult(result); } @@ -90,7 +90,7 @@ class Payload implements PayloadInterface /** * Creates a payload with the `ERROR` status. */ - public static function error(var messages = null) -> + public static function error(var messages = null) -> { return (new static())->withStatus(Status::ERROR)->withMessages(messages); } @@ -99,7 +99,7 @@ class Payload implements PayloadInterface * Creates a payload with the `NOT_AUTHORIZED` status (authenticated but * not allowed - HTTP 403). */ - public static function forbidden(var messages = null) -> + public static function forbidden(var messages = null) -> { return (new static())->withStatus(Status::NOT_AUTHORIZED)->withMessages(messages); } @@ -107,7 +107,7 @@ class Payload implements PayloadInterface /** * Creates a payload with the `FOUND` status. */ - public static function found(var result = null) -> + public static function found(var result = null) -> { return (new static())->withStatus(Status::FOUND)->withResult(result); } @@ -163,7 +163,7 @@ class Payload implements PayloadInterface /** * Creates a payload with the `NOT_VALID` status. */ - public static function invalid(var messages = null) -> + public static function invalid(var messages = null) -> { return (new static())->withStatus(Status::NOT_VALID)->withMessages(messages); } @@ -171,7 +171,7 @@ class Payload implements PayloadInterface /** * Creates a payload with the `NOT_FOUND` status. */ - public static function notFound(var messages = null) -> + public static function notFound(var messages = null) -> { return (new static())->withStatus(Status::NOT_FOUND)->withMessages(messages); } @@ -179,7 +179,7 @@ class Payload implements PayloadInterface /** * Creates a payload with the `PROCESSING` status. */ - public static function processing(var result = null) -> + public static function processing(var result = null) -> { return (new static())->withStatus(Status::PROCESSING)->withResult(result); } @@ -187,7 +187,7 @@ class Payload implements PayloadInterface /** * Creates a payload with the `SUCCESS` status. */ - public static function success(var result = null) -> + public static function success(var result = null) -> { return (new static())->withStatus(Status::SUCCESS)->withResult(result); } @@ -196,7 +196,7 @@ class Payload implements PayloadInterface * Creates a payload with the `NOT_AUTHENTICATED` status (identity not * established - HTTP 401). */ - public static function unauthenticated(var messages = null) -> + public static function unauthenticated(var messages = null) -> { return (new static())->withStatus(Status::NOT_AUTHENTICATED)->withMessages(messages); } @@ -204,7 +204,7 @@ class Payload implements PayloadInterface /** * Creates a payload with the `UPDATED` status. */ - public static function updated(var result = null) -> + public static function updated(var result = null) -> { return (new static())->withStatus(Status::UPDATED)->withResult(result); } @@ -212,7 +212,7 @@ class Payload implements PayloadInterface /** * Returns a copy of the payload with the given exception. */ - public function withException( exception) -> + public function withException( exception) -> { var cloned; @@ -225,7 +225,7 @@ class Payload implements PayloadInterface /** * Returns a copy of the payload with the given extras. */ - public function withExtras(var extras) -> + public function withExtras(var extras) -> { var cloned; @@ -238,7 +238,7 @@ class Payload implements PayloadInterface /** * Returns a copy of the payload with the given input. */ - public function withInput(var input) -> + public function withInput(var input) -> { var cloned; @@ -251,7 +251,7 @@ class Payload implements PayloadInterface /** * Returns a copy of the payload with the given messages. */ - public function withMessages(var messages) -> + public function withMessages(var messages) -> { var cloned; @@ -264,7 +264,7 @@ class Payload implements PayloadInterface /** * Returns a copy of the payload with the given result. */ - public function withResult(var result) -> + public function withResult(var result) -> { var cloned; @@ -277,7 +277,7 @@ class Payload implements PayloadInterface /** * Returns a copy of the payload with the given status. */ - public function withStatus(var status) -> + public function withStatus(var status) -> { var cloned; From 717db9bd32441c8f80c052bafcb0b81f2efad7ff Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Fri, 17 Jul 2026 21:01:09 -0500 Subject: [PATCH 2/8] [#17341] - adding ADR ErrorResponder Assisted-by: Claude Code --- phalcon/ADR/ErrorResponder.zep | 156 +++++++++++++++++++ tests/unit/ADR/ErrorResponder/HandleTest.php | 94 +++++++++++ 2 files changed, 250 insertions(+) create mode 100644 phalcon/ADR/ErrorResponder.zep create mode 100644 tests/unit/ADR/ErrorResponder/HandleTest.php diff --git a/phalcon/ADR/ErrorResponder.zep b/phalcon/ADR/ErrorResponder.zep new file mode 100644 index 0000000000..77481a43fb --- /dev/null +++ b/phalcon/ADR/ErrorResponder.zep @@ -0,0 +1,156 @@ + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ + +namespace Phalcon\ADR; + +use Phalcon\ADR\Payload\Payload; +use Phalcon\ADR\Payload\Status; +use Phalcon\Contracts\ADR\Payload\Payload as PayloadContract; +use Phalcon\Contracts\ADR\Responder\Responder; +use Phalcon\Contracts\Logger\Logger; +use Phalcon\Http\RequestInterface; +use Phalcon\Http\ResponseInterface; +use Throwable; + +/** + * Turns a thrown exception into a response through the responder chain. + * + * The full diagnostic (class, message, file:line and the exception itself) goes + * to the log with a correlation reference; the client receives only a generic + * message plus that same reference, unless debug mode is on. Exceptions are + * mapped to statuses deterministically: an exact class match first, then the + * ancestor chain, so map ordering never matters. + */ +final class ErrorResponder +{ + /** + * @var Responder + */ + protected chain; + + /** + * @var bool + */ + protected debug; + + /** + * @var array + */ + protected exceptionMap; + + /** + * @var Logger + */ + protected logger; + + public function __construct( + chain, + logger, + bool debug = false, + array exceptionMap = [] + ) { + let this->chain = chain, + this->logger = logger, + this->debug = debug, + this->exceptionMap = exceptionMap + this->defaultMap(); + } + + public function handle( + request, + response, + exception + ) -> { + var status, ref, payload; + + let ref = this->correlationId(request); + + this->logger->error( + sprintf( + "%s: %s in %s:%d", + get_class(exception), + exception->getMessage(), + exception->getFile(), + exception->getLine() + ), + ["exception": exception, "ref": ref] + ); + + let status = this->resolveStatus(exception); + + let payload = (new Payload()) + ->withStatus(status) + ->withResult(this->details(exception, ref)); + + return this->chain->__invoke(request, response, payload); + } + + protected function correlationId( request) -> string + { + var id; + + let id = request->getHeader("X-Request-Id"); + if empty id { + let id = bin2hex(random_bytes(8)); + } + + return (string) id; + } + + protected function defaultMap() -> array + { + return [ + "Phalcon\\ADR\\Router\\Exceptions\\RouteNotFound" : Status::NOT_FOUND, + "Phalcon\\ADR\\Router\\Exceptions\\MethodNotAllowed" : Status::METHOD_NOT_ALLOWED + ]; + } + + protected function details( exception, string ref) -> array + { + if this->debug { + return [ + "message": exception->getMessage(), + "trace": exception->getTraceAsString(), + "ref": ref + ]; + } + + return [ + "message": "Internal Server Error", + "ref": ref + ]; + } + + private function resolveStatus( exception) -> string + { + var className, ancestor, ancestors; + + let className = get_class(exception); + + if isset this->exceptionMap[className] { + return this->exceptionMap[className]; + } + + let ancestors = array_merge( + array_values(class_parents(exception)), + array_values(class_implements(exception)) + ); + + for ancestor in ancestors { + if isset this->exceptionMap[ancestor] { + return this->exceptionMap[ancestor]; + } + } + + return Status::ERROR; + } +} diff --git a/tests/unit/ADR/ErrorResponder/HandleTest.php b/tests/unit/ADR/ErrorResponder/HandleTest.php new file mode 100644 index 0000000000..29e655a8c5 --- /dev/null +++ b/tests/unit/ADR/ErrorResponder/HandleTest.php @@ -0,0 +1,94 @@ + + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace Phalcon\Tests\Unit\ADR\ErrorResponder; + +use Phalcon\ADR\ErrorResponder; +use Phalcon\ADR\Responder\JsonResponder; +use Phalcon\ADR\Router\Exceptions\MethodNotAllowed; +use Phalcon\ADR\Router\Exceptions\RouteNotFound; +use Phalcon\Http\Request; +use Phalcon\Http\Response; +use Phalcon\Logger\Adapter\Noop; +use Phalcon\Logger\Logger; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; +use RuntimeException; + +final class HandleTest extends AbstractUnitTestCase +{ + /** + * Unit Tests Phalcon\ADR\ErrorResponder :: handle() hides the exception behind a generic message + */ + public function testAdrErrorResponderHandleGenericMessage(): void + { + $response = $this->responder()->handle( + new Request(), + new Response(), + new RouteNotFound('secret detail') + ); + + $this->assertSame(404, $response->getStatusCode()); + $this->assertStringContainsString('Internal Server Error', $response->getContent()); + $this->assertStringNotContainsString('secret detail', $response->getContent()); + } + + /** + * Unit Tests Phalcon\ADR\ErrorResponder :: handle() maps MethodNotAllowed to 405 + */ + public function testAdrErrorResponderHandleMapsMethodNotAllowed(): void + { + $response = $this->responder()->handle( + new Request(), + new Response(), + new MethodNotAllowed('nope') + ); + + $this->assertSame(405, $response->getStatusCode()); + } + + /** + * Unit Tests Phalcon\ADR\ErrorResponder :: handle() maps an unmapped exception to 500 + */ + public function testAdrErrorResponderHandleUnmappedIsServerError(): void + { + $response = $this->responder()->handle( + new Request(), + new Response(), + new RuntimeException('boom') + ); + + $this->assertSame(500, $response->getStatusCode()); + } + + /** + * Unit Tests Phalcon\ADR\ErrorResponder :: handle() exposes details in debug mode + */ + public function testAdrErrorResponderHandleExposesDetailsInDebug(): void + { + $responder = new ErrorResponder(new JsonResponder(), $this->logger(), true); + + $response = $responder->handle(new Request(), new Response(), new RouteNotFound('the detail')); + + $this->assertStringContainsString('the detail', $response->getContent()); + } + + private function logger(): Logger + { + return new Logger('adr', ['main' => new Noop()]); + } + + private function responder(): ErrorResponder + { + return new ErrorResponder(new JsonResponder(), $this->logger()); + } +} From 61eb8021b27a62d7c8aba1409a6cb1af3f2a426f Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Fri, 17 Jul 2026 21:01:10 -0500 Subject: [PATCH 3/8] [#17341] - adding ADR Application Assisted-by: Claude Code --- phalcon/ADR/Application.zep | 98 ++++++++++++++++++ phalcon/Contracts/ADR/Application.zep | 26 +++++ tests/unit/ADR/Application/HandleTest.php | 115 ++++++++++++++++++++++ 3 files changed, 239 insertions(+) create mode 100644 phalcon/ADR/Application.zep create mode 100644 phalcon/Contracts/ADR/Application.zep create mode 100644 tests/unit/ADR/Application/HandleTest.php diff --git a/phalcon/ADR/Application.zep b/phalcon/ADR/Application.zep new file mode 100644 index 0000000000..3d69956df8 --- /dev/null +++ b/phalcon/ADR/Application.zep @@ -0,0 +1,98 @@ + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ + +namespace Phalcon\ADR; + +use Phalcon\ADR\Events\Event; +use Phalcon\ADR\Router\Exceptions\RouteNotFound; +use Phalcon\Contracts\ADR\Application as ApplicationInterface; +use Phalcon\Contracts\ADR\Dispatcher as DispatcherInterface; +use Phalcon\Contracts\ADR\Router\Router as RouterInterface; +use Phalcon\Contracts\Events\Manager; +use Phalcon\Contracts\Http\AttributeRequestInterface; +use Phalcon\Http\Request\Bag\AttributeBag; +use Phalcon\Http\Response; +use Phalcon\Http\ResponseInterface; + +/** + * Routes the request, writes the matched attributes onto it, dispatches the + * Action and returns the response. A single try/catch routes any error through + * the error responder; if that itself fails, a bare 500 is returned so nothing + * escapes uncaught. + */ +final class Application implements ApplicationInterface +{ + /** + * @var DispatcherInterface + */ + protected dispatcher; + + /** + * @var ErrorResponder + */ + protected errorResponder; + + /** + * @var Manager + */ + protected events; + + /** + * @var RouterInterface + */ + protected router; + + public function __construct( + router, + dispatcher, + errorResponder, + events + ) { + let this->router = router, + this->dispatcher = dispatcher, + this->errorResponder = errorResponder, + this->events = events; + } + + public function handle( request) -> + { + var match, response, key, value, exception; + + this->events->fire(Event::APPLICATION_BEFORE_HANDLE, this, request); + + try { + let match = this->router->match(request); + if match === null { + throw new RouteNotFound("No route matched the request."); + } + + for key, value in match->getAttributes() { + request->getAttributes()->set(key, value); + } + + let response = this->dispatcher->dispatch(match->getAction(), request, match->getMiddleware()); + } catch \Throwable, exception { + try { + let response = this->errorResponder->handle(request, new Response(), exception); + } catch \Throwable { + let response = new Response(); + + response->setStatusCode(500)->setContent("Internal Server Error"); + } + } + + this->events->fire(Event::APPLICATION_AFTER_HANDLE, this, response); + + return response; + } +} diff --git a/phalcon/Contracts/ADR/Application.zep b/phalcon/Contracts/ADR/Application.zep new file mode 100644 index 0000000000..92b742b65b --- /dev/null +++ b/phalcon/Contracts/ADR/Application.zep @@ -0,0 +1,26 @@ + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ + +namespace Phalcon\Contracts\ADR; + +use Phalcon\Contracts\Http\AttributeRequestInterface; +use Phalcon\Http\ResponseInterface; + +/** + * Handles a request end to end: routes it, dispatches the Action and returns + * the response, routing any error through the error responder. + */ +interface Application +{ + public function handle( request) -> ; +} diff --git a/tests/unit/ADR/Application/HandleTest.php b/tests/unit/ADR/Application/HandleTest.php new file mode 100644 index 0000000000..a74bbf401b --- /dev/null +++ b/tests/unit/ADR/Application/HandleTest.php @@ -0,0 +1,115 @@ + + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace Phalcon\Tests\Unit\ADR\Application; + +use Phalcon\ADR\Application; +use Phalcon\ADR\Dispatcher; +use Phalcon\ADR\ErrorResponder; +use Phalcon\ADR\Responder\JsonResponder; +use Phalcon\ADR\Router\Router; +use Phalcon\Contracts\ADR\Action; +use Phalcon\Contracts\Container\Ioc\IocContainer; +use Phalcon\Contracts\Http\AttributeRequestInterface; +use Phalcon\Events\Manager; +use Phalcon\Http\Request; +use Phalcon\Http\Response; +use Phalcon\Http\ResponseInterface; +use Phalcon\Logger\Adapter\Noop; +use Phalcon\Logger\Logger; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; +use stdClass; + +final class HandleTest extends AbstractUnitTestCase +{ + protected function tearDown(): void + { + unset($_SERVER['REQUEST_URI'], $_SERVER['REQUEST_METHOD']); + + parent::tearDown(); + } + + /** + * Unit Tests Phalcon\ADR\Application :: handle() dispatches the matched action with its attributes + */ + public function testAdrApplicationHandleDispatchesMatchedAction(): void + { + $_SERVER['REQUEST_URI'] = '/hello/world'; + $_SERVER['REQUEST_METHOD'] = 'GET'; + + $action = new class implements Action { + public function __invoke(AttributeRequestInterface $request): ResponseInterface + { + return (new Response())->setContent('hello ' . $request->getAttributes()->get('name')); + } + }; + + $router = new Router(); + $router->get('/hello/{name}', 'HelloAction'); + + $app = new Application( + $router, + new Dispatcher($this->containerReturning($action), new Manager()), + $this->errorResponder(), + new Manager() + ); + + $response = $app->handle(new Request()); + + $this->assertSame('hello world', $response->getContent()); + } + + /** + * Unit Tests Phalcon\ADR\Application :: handle() routes a missing route through the error responder + */ + public function testAdrApplicationHandleRoutesRouteNotFound(): void + { + $_SERVER['REQUEST_URI'] = '/nope'; + $_SERVER['REQUEST_METHOD'] = 'GET'; + + $app = new Application( + new Router(), + new Dispatcher($this->containerReturning(new stdClass()), new Manager()), + $this->errorResponder(), + new Manager() + ); + + $response = $app->handle(new Request()); + + $this->assertSame(404, $response->getStatusCode()); + } + + private function containerReturning(object $service): IocContainer + { + return new class ($service) implements IocContainer { + public function __construct(private object $service) + { + } + + public function getService(string $serviceName): object + { + return $this->service; + } + + public function hasService(string $serviceName): bool + { + return true; + } + }; + } + + private function errorResponder(): ErrorResponder + { + return new ErrorResponder(new JsonResponder(), new Logger('adr', ['main' => new Noop()])); + } +} From 1d215acbf538cd5a2cb43694872c887a20385b95 Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Fri, 17 Jul 2026 21:01:10 -0500 Subject: [PATCH 4/8] [#17341] - adding ADR Emitter Assisted-by: Claude Code --- .../Emitter/Exceptions/HeadersAlreadySent.zep | 24 ++++++++++++ .../Emitter/Exceptions/OutputAlreadySent.zep | 24 ++++++++++++ phalcon/ADR/Emitter/SapiEmitter.zep | 34 +++++++++++++++++ phalcon/Contracts/ADR/Emitter/Emitter.zep | 24 ++++++++++++ .../ADR/Emitter/Exceptions/HierarchyTest.php | 31 +++++++++++++++ .../unit/ADR/Emitter/SapiEmitter/EmitTest.php | 38 +++++++++++++++++++ 6 files changed, 175 insertions(+) create mode 100644 phalcon/ADR/Emitter/Exceptions/HeadersAlreadySent.zep create mode 100644 phalcon/ADR/Emitter/Exceptions/OutputAlreadySent.zep create mode 100644 phalcon/ADR/Emitter/SapiEmitter.zep create mode 100644 phalcon/Contracts/ADR/Emitter/Emitter.zep create mode 100644 tests/unit/ADR/Emitter/Exceptions/HierarchyTest.php create mode 100644 tests/unit/ADR/Emitter/SapiEmitter/EmitTest.php diff --git a/phalcon/ADR/Emitter/Exceptions/HeadersAlreadySent.zep b/phalcon/ADR/Emitter/Exceptions/HeadersAlreadySent.zep new file mode 100644 index 0000000000..17c826788e --- /dev/null +++ b/phalcon/ADR/Emitter/Exceptions/HeadersAlreadySent.zep @@ -0,0 +1,24 @@ + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ + +namespace Phalcon\ADR\Emitter\Exceptions; + +use Phalcon\ADR\Exceptions\Exception; + +/** + * Thrown when the emitter is asked to send a response after headers have + * already been sent. + */ +class HeadersAlreadySent extends Exception +{ +} diff --git a/phalcon/ADR/Emitter/Exceptions/OutputAlreadySent.zep b/phalcon/ADR/Emitter/Exceptions/OutputAlreadySent.zep new file mode 100644 index 0000000000..df16d6fbab --- /dev/null +++ b/phalcon/ADR/Emitter/Exceptions/OutputAlreadySent.zep @@ -0,0 +1,24 @@ + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ + +namespace Phalcon\ADR\Emitter\Exceptions; + +use Phalcon\ADR\Exceptions\Exception; + +/** + * Thrown when the emitter is asked to send a response after output has already + * been sent. + */ +class OutputAlreadySent extends Exception +{ +} diff --git a/phalcon/ADR/Emitter/SapiEmitter.zep b/phalcon/ADR/Emitter/SapiEmitter.zep new file mode 100644 index 0000000000..83dabbfdc7 --- /dev/null +++ b/phalcon/ADR/Emitter/SapiEmitter.zep @@ -0,0 +1,34 @@ + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ + +namespace Phalcon\ADR\Emitter; + +use Phalcon\ADR\Emitter\Exceptions\HeadersAlreadySent; +use Phalcon\Contracts\ADR\Emitter\Emitter; +use Phalcon\Http\ResponseInterface; + +/** + * Emits a response through the SAPI (headers + body via `Response::send()`). + * Refuses to emit once headers have already been sent. + */ +class SapiEmitter implements Emitter +{ + public function emit( response) -> void + { + if headers_sent() { + throw new HeadersAlreadySent("Headers have already been sent; cannot emit the response."); + } + + response->send(); + } +} diff --git a/phalcon/Contracts/ADR/Emitter/Emitter.zep b/phalcon/Contracts/ADR/Emitter/Emitter.zep new file mode 100644 index 0000000000..806610ac40 --- /dev/null +++ b/phalcon/Contracts/ADR/Emitter/Emitter.zep @@ -0,0 +1,24 @@ + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ + +namespace Phalcon\Contracts\ADR\Emitter; + +use Phalcon\Http\ResponseInterface; + +/** + * Sends a response to the client. Called by the Kernel only. + */ +interface Emitter +{ + public function emit( response) -> void; +} diff --git a/tests/unit/ADR/Emitter/Exceptions/HierarchyTest.php b/tests/unit/ADR/Emitter/Exceptions/HierarchyTest.php new file mode 100644 index 0000000000..d650a8dd7e --- /dev/null +++ b/tests/unit/ADR/Emitter/Exceptions/HierarchyTest.php @@ -0,0 +1,31 @@ + + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace Phalcon\Tests\Unit\ADR\Emitter\Exceptions; + +use Phalcon\ADR\Emitter\Exceptions\HeadersAlreadySent; +use Phalcon\ADR\Emitter\Exceptions\OutputAlreadySent; +use Phalcon\ADR\Exceptions\ADRThrowable; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; + +final class HierarchyTest extends AbstractUnitTestCase +{ + /** + * Unit Tests Phalcon\ADR\Emitter\Exceptions :: implement ADRThrowable + */ + public function testAdrEmitterExceptionsAreAdrThrowable(): void + { + $this->assertInstanceOf(ADRThrowable::class, new HeadersAlreadySent()); + $this->assertInstanceOf(ADRThrowable::class, new OutputAlreadySent()); + } +} diff --git a/tests/unit/ADR/Emitter/SapiEmitter/EmitTest.php b/tests/unit/ADR/Emitter/SapiEmitter/EmitTest.php new file mode 100644 index 0000000000..33971ce4f3 --- /dev/null +++ b/tests/unit/ADR/Emitter/SapiEmitter/EmitTest.php @@ -0,0 +1,38 @@ + + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace Phalcon\Tests\Unit\ADR\Emitter\SapiEmitter; + +use Phalcon\ADR\Emitter\SapiEmitter; +use Phalcon\Contracts\ADR\Emitter\Emitter; +use Phalcon\Http\Response; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; + +final class EmitTest extends AbstractUnitTestCase +{ + /** + * Unit Tests Phalcon\ADR\Emitter\SapiEmitter :: emit() + */ + public function testAdrEmitterSapiEmitterEmit(): void + { + $emitter = new SapiEmitter(); + + $this->assertInstanceOf(Emitter::class, $emitter); + + ob_start(); + $emitter->emit((new Response())->setContent('emitted-body')); + $output = (string) ob_get_clean(); + + $this->assertStringContainsString('emitted-body', $output); + } +} From d243a449a2c3070a06bd0ddb5ad38e6a14bb4cd6 Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Fri, 17 Jul 2026 21:01:10 -0500 Subject: [PATCH 5/8] [#17341] - adding ADR service provider Assisted-by: Claude Code --- phalcon/ADR/Container/AdrProvider.zep | 101 ++++++++++++++++ .../ADR/Container/AdrProvider/ProvideTest.php | 112 ++++++++++++++++++ 2 files changed, 213 insertions(+) create mode 100644 phalcon/ADR/Container/AdrProvider.zep create mode 100644 tests/unit/ADR/Container/AdrProvider/ProvideTest.php diff --git a/phalcon/ADR/Container/AdrProvider.zep b/phalcon/ADR/Container/AdrProvider.zep new file mode 100644 index 0000000000..d7ef263d93 --- /dev/null +++ b/phalcon/ADR/Container/AdrProvider.zep @@ -0,0 +1,101 @@ + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ + +namespace Phalcon\ADR\Container; + +use Phalcon\ADR\Dispatcher; +use Phalcon\Contracts\Container\Service\Collection; +use Phalcon\Contracts\Container\Service\Provider; +use Phalcon\Logger\Adapter\Noop; +use Phalcon\Logger\Logger; + +/** + * Registers the ADR seams in the container; concretes autowire. + * + * Used instead of `Phalcon\Container\Provider\Web` for ADR applications. It + * shares the short aliases (`request`/`response`/`router`/`eventsManager`) but + * binds the ADR contracts behind them. + */ +class AdrProvider implements Provider +{ + /** + * @param Collection $services + * + * @return void + */ + public function provide( services) -> void + { + // Native events manager + services->bind( + "Phalcon\\Contracts\\Events\\Manager", + "Phalcon\\Events\\Manager" + ); + services->setAlias("Phalcon\\Contracts\\Events\\Manager", "eventsManager"); + + // Request (attribute-bearing) and response + services->bind( + "Phalcon\\Contracts\\Http\\AttributeRequestInterface", + "Phalcon\\Http\\Request" + ); + services->setAlias( + "Phalcon\\Contracts\\Http\\AttributeRequestInterface", + "request" + ); + + services->bind("Phalcon\\Http\\ResponseInterface", "Phalcon\\Http\\Response"); + services->setAlias("Phalcon\\Http\\ResponseInterface", "response"); + + // Logger default - null sink until the application binds its own + services->set( + "Phalcon\\Contracts\\Logger\\Logger", + function (container) { + var adapters, noop; + + let noop = new Noop(), + adapters = ["main" : noop]; + + return new Logger("adr", adapters); + } + ); + + // Default responder + services->bind( + "Phalcon\\Contracts\\ADR\\Responder\\Responder", + "Phalcon\\ADR\\Responder\\JsonResponder" + ); + services->setAlias("Phalcon\\Contracts\\ADR\\Responder\\Responder", "responder"); + + // Dispatcher - handed the container instance and the events manager + services->set( + "Phalcon\\Contracts\\ADR\\Dispatcher", + function (container) { + return new Dispatcher(container, container->get("eventsManager")); + } + ); + services->setAlias("Phalcon\\Contracts\\ADR\\Dispatcher", "dispatcher"); + + // Router + services->bind( + "Phalcon\\Contracts\\ADR\\Router\\Router", + "Phalcon\\ADR\\Router\\Router" + ); + services->setAlias("Phalcon\\Contracts\\ADR\\Router\\Router", "router"); + + // Emitter + services->bind( + "Phalcon\\Contracts\\ADR\\Emitter\\Emitter", + "Phalcon\\ADR\\Emitter\\SapiEmitter" + ); + services->setAlias("Phalcon\\Contracts\\ADR\\Emitter\\Emitter", "emitter"); + } +} diff --git a/tests/unit/ADR/Container/AdrProvider/ProvideTest.php b/tests/unit/ADR/Container/AdrProvider/ProvideTest.php new file mode 100644 index 0000000000..d5d1cc4179 --- /dev/null +++ b/tests/unit/ADR/Container/AdrProvider/ProvideTest.php @@ -0,0 +1,112 @@ + + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace Phalcon\Tests\Unit\ADR\Container\AdrProvider; + +use Phalcon\ADR\Container\AdrProvider; +use Phalcon\ADR\Responder\JsonResponder; +use Phalcon\Container\Container; +use Phalcon\Container\ContainerFactory; +use Phalcon\Contracts\ADR\Responder\Responder; +use Phalcon\Contracts\Container\Service\Provider; +use Phalcon\Logger\Logger; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; + +final class ProvideTest extends AbstractUnitTestCase +{ + private Container $container; + + protected function setUp(): void + { + $this->container = (new ContainerFactory()) + ->addProvider(new AdrProvider()) + ->newContainer(); + } + + /** + * Unit Tests Phalcon\ADR\Container\AdrProvider :: provide() - registers aliases + */ + public function testAdrContainerAdrProviderProvideRegistersAliases(): void + { + $names = [ + 'dispatcher', + 'emitter', + 'eventsManager', + 'request', + 'responder', + 'response', + 'router', + ]; + + foreach ($names as $name) { + $this->assertTrue( + $this->container->has($name), + "Service '{$name}' should be resolvable" + ); + } + } + + /** + * Unit Tests Phalcon\ADR\Container\AdrProvider :: provide() - registers contracts + */ + public function testAdrContainerAdrProviderProvideRegistersContracts(): void + { + $contracts = [ + 'Phalcon\\Contracts\\ADR\\Dispatcher', + 'Phalcon\\Contracts\\ADR\\Emitter\\Emitter', + 'Phalcon\\Contracts\\ADR\\Responder\\Responder', + 'Phalcon\\Contracts\\ADR\\Router\\Router', + 'Phalcon\\Contracts\\Events\\Manager', + 'Phalcon\\Contracts\\Http\\AttributeRequestInterface', + 'Phalcon\\Contracts\\Logger\\Logger', + 'Phalcon\\Http\\ResponseInterface', + ]; + + foreach ($contracts as $contract) { + $this->assertTrue( + $this->container->has($contract), + "Contract '{$contract}' should be resolvable" + ); + } + } + + /** + * Unit Tests Phalcon\ADR\Container\AdrProvider :: provide() - default logger + */ + public function testAdrContainerAdrProviderProvideResolvesDefaultLogger(): void + { + $this->assertInstanceOf( + Logger::class, + $this->container->get('Phalcon\\Contracts\\Logger\\Logger') + ); + } + + /** + * Unit Tests Phalcon\ADR\Container\AdrProvider :: provide() - default responder + */ + public function testAdrContainerAdrProviderProvideResolvesDefaultResponder(): void + { + $this->assertInstanceOf( + JsonResponder::class, + $this->container->get(Responder::class) + ); + } + + /** + * Unit Tests Phalcon\ADR\Container\AdrProvider :: implements Provider + */ + public function testAdrContainerAdrProviderProvideYieldsProvider(): void + { + $this->assertInstanceOf(Provider::class, new AdrProvider()); + } +} From a58886f7a1c69ceede28c29c3b6c499b633762b2 Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Fri, 17 Jul 2026 21:01:10 -0500 Subject: [PATCH 6/8] [#17341] - adding ADR Kernel Assisted-by: Claude Code --- phalcon/ADR/Kernel/AbstractHttpKernel.zep | 84 +++++++++++++++ phalcon/ADR/Kernel/HttpKernel.zep | 23 ++++ phalcon/Contracts/ADR/Kernel/Kernel.zep | 23 ++++ tests/unit/ADR/Kernel/HttpKernel/RunTest.php | 107 +++++++++++++++++++ 4 files changed, 237 insertions(+) create mode 100644 phalcon/ADR/Kernel/AbstractHttpKernel.zep create mode 100644 phalcon/ADR/Kernel/HttpKernel.zep create mode 100644 phalcon/Contracts/ADR/Kernel/Kernel.zep create mode 100644 tests/unit/ADR/Kernel/HttpKernel/RunTest.php diff --git a/phalcon/ADR/Kernel/AbstractHttpKernel.zep b/phalcon/ADR/Kernel/AbstractHttpKernel.zep new file mode 100644 index 0000000000..12581c56f6 --- /dev/null +++ b/phalcon/ADR/Kernel/AbstractHttpKernel.zep @@ -0,0 +1,84 @@ + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ + +namespace Phalcon\ADR\Kernel; + +use Phalcon\ADR\Container\AdrProvider; +use Phalcon\Container\Container; +use Phalcon\Contracts\ADR\Kernel\Kernel; + +/** + * Boots a container, resolves the Application, handles the request and emits the + * response. Userland kernels override `loadEnvironment()` / `registerProviders()`; + * bootstrap is `exit((new AppKernel(dirname(__DIR__)))->run());`. + */ +abstract class AbstractHttpKernel implements Kernel +{ + protected projectRoot; + + public function __construct(string projectRoot) + { + let this->projectRoot = projectRoot; + } + + final public function run() -> int + { + var container, request, application, response, exception; + + try { + let container = this->buildContainer(); + + this->loadEnvironment(container); + this->registerProviders(container); + + let request = container->get("request"), + application = container->get("Phalcon\\ADR\\Application"), + response = application->handle(request); + + container->get("Phalcon\\Contracts\\ADR\\Emitter\\Emitter")->emit(response); + + return 0; + } catch \Throwable, exception { + return this->handleBootError(exception); + } + + return 0; + } + + protected function buildContainer() -> + { + return new Container(); + } + + protected function handleBootError(<\Throwable> exception) -> int + { + error_log((string) exception); + + if !headers_sent() { + http_response_code(500); + header("Content-Type: text/plain; charset=utf-8"); + echo "Internal Server Error\n"; + } + + return 1; + } + + protected function loadEnvironment( container) -> void + { + } + + protected function registerProviders( container) -> void + { + (new AdrProvider())->provide(container); + } +} diff --git a/phalcon/ADR/Kernel/HttpKernel.zep b/phalcon/ADR/Kernel/HttpKernel.zep new file mode 100644 index 0000000000..e6f378dc1e --- /dev/null +++ b/phalcon/ADR/Kernel/HttpKernel.zep @@ -0,0 +1,23 @@ + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ + +namespace Phalcon\ADR\Kernel; + +/** + * Concrete default HTTP kernel. Boots the ADR provider and runs the application + * with the framework defaults; subclass to override `loadEnvironment()` or + * `registerProviders()`. + */ +class HttpKernel extends AbstractHttpKernel +{ +} diff --git a/phalcon/Contracts/ADR/Kernel/Kernel.zep b/phalcon/Contracts/ADR/Kernel/Kernel.zep new file mode 100644 index 0000000000..5802a5fdfe --- /dev/null +++ b/phalcon/Contracts/ADR/Kernel/Kernel.zep @@ -0,0 +1,23 @@ + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ + +namespace Phalcon\Contracts\ADR\Kernel; + +/** + * Boots the container, handles the incoming request and emits the response. + * Returns a process exit code. + */ +interface Kernel +{ + public function run() -> int; +} diff --git a/tests/unit/ADR/Kernel/HttpKernel/RunTest.php b/tests/unit/ADR/Kernel/HttpKernel/RunTest.php new file mode 100644 index 0000000000..6e2d507ded --- /dev/null +++ b/tests/unit/ADR/Kernel/HttpKernel/RunTest.php @@ -0,0 +1,107 @@ + + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ + +declare(strict_types=1); + +namespace Phalcon\Tests\Unit\ADR\Kernel\HttpKernel; + +use Phalcon\ADR\Kernel\AbstractHttpKernel; +use Phalcon\ADR\Kernel\HttpKernel; +use Phalcon\Container\Container; +use Phalcon\Contracts\ADR\Emitter\Emitter; +use Phalcon\Contracts\ADR\Kernel\Kernel; +use Phalcon\Http\Response; +use Phalcon\Http\ResponseInterface; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; +use stdClass; + +final class RunTest extends AbstractUnitTestCase +{ + /** + * Unit Tests Phalcon\ADR\Kernel\HttpKernel :: implements Kernel + */ + public function testAdrKernelHttpKernelIsKernel(): void + { + $kernel = new HttpKernel('/project/root'); + + $this->assertInstanceOf(Kernel::class, $kernel); + $this->assertInstanceOf(AbstractHttpKernel::class, $kernel); + } + + /** + * Unit Tests Phalcon\ADR\Kernel\HttpKernel :: run() - handles and emits + */ + public function testAdrKernelHttpKernelRunEmitsHandledResponse(): void + { + $kernel = new class ('/project/root') extends AbstractHttpKernel { + public ?ResponseInterface $emitted = null; + + protected function registerProviders(Container $container): void + { + $container->set('request', function ($c) { + return new stdClass(); + }); + + $container->set('Phalcon\\ADR\\Application', function ($c) { + return new class { + public function handle($request): ResponseInterface + { + return (new Response())->setContent('kernel-body'); + } + }; + }); + + $kernel = $this; + $container->set('Phalcon\\Contracts\\ADR\\Emitter\\Emitter', function ($c) use ($kernel) { + return new class ($kernel) implements Emitter { + private $kernel; + + public function __construct($kernel) + { + $this->kernel = $kernel; + } + + public function emit(ResponseInterface $response): void + { + $this->kernel->emitted = $response; + } + }; + }); + } + }; + + $code = $kernel->run(); + + $this->assertSame(0, $code); + $this->assertInstanceOf(Response::class, $kernel->emitted); + $this->assertSame('kernel-body', $kernel->emitted->getContent()); + } + + /** + * Unit Tests Phalcon\ADR\Kernel\HttpKernel :: run() - boot failure + */ + public function testAdrKernelHttpKernelRunReturnsErrorCodeOnBootFailure(): void + { + $kernel = new class ('/project/root') extends AbstractHttpKernel { + protected function buildContainer(): Container + { + throw new \RuntimeException('boot failed'); + } + }; + + ob_start(); + $code = $kernel->run(); + $output = (string) ob_get_clean(); + + $this->assertSame(1, $code); + $this->assertStringContainsString('Internal Server Error', $output); + } +} From 37097fbd9ae3edf264b7275111d94d4d2b8bc723 Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Fri, 17 Jul 2026 21:01:10 -0500 Subject: [PATCH 7/8] [#17341] - refreshing ext Assisted-by: Claude Code --- ext/config.m4 | 23 +- ext/config.w32 | 14 +- ext/phalcon.c | 38 +- ext/phalcon.h | 19 +- ext/phalcon/10__closure.zep.c | 24 +- ext/phalcon/10__closure.zep.h | 5 +- ext/phalcon/11__closure.zep.c | 25 +- ext/phalcon/11__closure.zep.h | 5 +- ext/phalcon/12__closure.zep.c | 2 +- ext/phalcon/13__closure.zep.c | 2 +- ext/phalcon/14__closure.zep.c | 29 +- ext/phalcon/14__closure.zep.h | 5 +- ext/phalcon/15__closure.zep.c | 28 +- ext/phalcon/15__closure.zep.h | 5 +- ext/phalcon/16__closure.zep.c | 39 +- ext/phalcon/16__closure.zep.h | 5 +- ext/phalcon/17__closure.zep.c | 39 +- ext/phalcon/17__closure.zep.h | 5 +- ext/phalcon/18__closure.zep.c | 41 +- ext/phalcon/18__closure.zep.h | 6 +- ext/phalcon/19__closure.zep.c | 41 +- ext/phalcon/19__closure.zep.h | 6 +- ext/phalcon/20__closure.zep.c | 2 +- ext/phalcon/21__closure.zep.c | 4 +- ext/phalcon/22__closure.zep.c | 2 +- ext/phalcon/23__closure.zep.c | 2 +- ext/phalcon/24__closure.zep.c | 2 +- ext/phalcon/25__closure.zep.c | 2 +- ext/phalcon/26__closure.zep.c | 2 +- ext/phalcon/27__closure.zep.c | 4 +- ext/phalcon/28__closure.zep.c | 4 +- ext/phalcon/29__closure.zep.c | 4 +- ext/phalcon/30__closure.zep.c | 4 +- ext/phalcon/31__closure.zep.c | 2 +- ext/phalcon/32__closure.zep.c | 38 +- ext/phalcon/32__closure.zep.h | 6 +- ext/phalcon/33__closure.zep.c | 34 +- ext/phalcon/33__closure.zep.h | 7 +- ext/phalcon/34__closure.zep.c | 32 +- ext/phalcon/34__closure.zep.h | 5 +- ext/phalcon/35__closure.zep.c | 2 +- ext/phalcon/36__closure.zep.c | 8 +- ext/phalcon/37__closure.zep.c | 18 +- ext/phalcon/38__closure.zep.c | 2 +- ext/phalcon/39__closure.zep.c | 20 +- ext/phalcon/40__closure.zep.c | 2 +- ext/phalcon/41__closure.zep.c | 27 +- ext/phalcon/42__closure.zep.c | 2 +- ext/phalcon/43__closure.zep.c | 27 +- ext/phalcon/44__closure.zep.c | 2 +- ext/phalcon/45__closure.zep.c | 17 +- ext/phalcon/46__closure.zep.c | 2 +- ext/phalcon/47__closure.zep.c | 15 +- ext/phalcon/48__closure.zep.c | 2 +- ext/phalcon/49__closure.zep.c | 6 +- ext/phalcon/4__closure.zep.c | 45 +- ext/phalcon/4__closure.zep.h | 7 +- ext/phalcon/50__closure.zep.c | 6 +- ext/phalcon/51__closure.zep.c | 2 +- ext/phalcon/52__closure.zep.c | 2 +- ext/phalcon/53__closure.zep.c | 2 +- ext/phalcon/54__closure.zep.c | 2 +- ext/phalcon/55__closure.zep.c | 2 +- ext/phalcon/56__closure.zep.c | 2 +- ext/phalcon/57__closure.zep.c | 4 +- ext/phalcon/58__closure.zep.c | 2 +- ext/phalcon/59__closure.zep.c | 4 +- ext/phalcon/5__closure.zep.c | 22 +- ext/phalcon/5__closure.zep.h | 2 +- ext/phalcon/60__closure.zep.c | 2 +- ext/phalcon/61__closure.zep.c | 6 +- ext/phalcon/62__closure.zep.c | 6 +- ext/phalcon/63__closure.zep.c | 6 +- ext/phalcon/64__closure.zep.c | 6 +- ext/phalcon/65__closure.zep.c | 6 +- ext/phalcon/66__closure.zep.c | 2 +- ext/phalcon/67__closure.zep.c | 6 +- ext/phalcon/68__closure.zep.c | 2 +- ext/phalcon/69__closure.zep.c | 6 +- ext/phalcon/6__closure.zep.c | 15 +- ext/phalcon/6__closure.zep.h | 5 +- ext/phalcon/70__closure.zep.c | 2 +- ext/phalcon/71__closure.zep.c | 6 +- ext/phalcon/72__closure.zep.c | 2 +- ext/phalcon/73__closure.zep.c | 6 +- ext/phalcon/74__closure.zep.c | 10 +- ext/phalcon/75__closure.zep.c | 2 +- ext/phalcon/76__closure.zep.c | 8 +- ext/phalcon/77__closure.zep.c | 2 +- ext/phalcon/78__closure.zep.c | 8 +- ext/phalcon/79__closure.zep.c | 18 +- ext/phalcon/7__closure.zep.c | 21 +- ext/phalcon/7__closure.zep.h | 5 +- ext/phalcon/80__closure.zep.c | 8 +- ext/phalcon/81__closure.zep.c | 18 +- ext/phalcon/82__closure.zep.c | 2 +- ext/phalcon/83__closure.zep.c | 2 +- ext/phalcon/84__closure.zep.c | 2 +- ext/phalcon/85__closure.zep.c | 8 +- ext/phalcon/86__closure.zep.c | 2 +- ext/phalcon/87__closure.zep.c | 35 +- ext/phalcon/87__closure.zep.h | 6 +- ext/phalcon/88__closure.zep.c | 33 +- ext/phalcon/88__closure.zep.h | 6 +- ext/phalcon/89__closure.zep.c | 21 +- ext/phalcon/89__closure.zep.h | 5 +- ext/phalcon/8__closure.zep.c | 25 +- ext/phalcon/8__closure.zep.h | 5 +- ext/phalcon/90__closure.zep.c | 24 +- ext/phalcon/90__closure.zep.h | 8 +- ext/phalcon/91__closure.zep.c | 23 +- ext/phalcon/91__closure.zep.h | 2 +- ext/phalcon/92__closure.zep.c | 26 +- ext/phalcon/92__closure.zep.h | 7 +- ext/phalcon/93__closure.zep.c | 26 +- ext/phalcon/93__closure.zep.h | 7 +- ext/phalcon/94__closure.zep.c | 42 ++ ext/phalcon/94__closure.zep.h | 15 + ext/phalcon/95__closure.zep.c | 44 ++ ext/phalcon/95__closure.zep.h | 18 + ext/phalcon/9__closure.zep.c | 24 +- ext/phalcon/acl/adapter/memory.zep.c | 244 +++++----- ext/phalcon/acl/adapter/storage.zep.c | 62 +-- ext/phalcon/acl/component.zep.c | 4 +- ext/phalcon/acl/role.zep.c | 4 +- ext/phalcon/adr/application.zep.c | 292 ++++++++++++ ext/phalcon/adr/application.zep.h | 24 + ext/phalcon/adr/container/adrprovider.zep.c | 162 +++++++ ext/phalcon/adr/container/adrprovider.zep.h | 16 + ext/phalcon/adr/dispatcher.zep.c | 36 +- .../exceptions/headersalreadysent.zep.c | 38 ++ .../exceptions/headersalreadysent.zep.h | 5 + .../exceptions/outputalreadysent.zep.c | 38 ++ .../exceptions/outputalreadysent.zep.h | 5 + ext/phalcon/adr/emitter/sapiemitter.zep.c | 69 +++ ext/phalcon/adr/emitter/sapiemitter.zep.h | 16 + ext/phalcon/adr/errorresponder.zep.c | 369 +++++++++++++++ ext/phalcon/adr/errorresponder.zep.h | 50 ++ ext/phalcon/adr/eventfulhandler.zep.c | 14 +- ext/phalcon/adr/input/input.zep.c | 12 +- .../adr/kernel/abstracthttpkernel.zep.c | 210 ++++++++ .../adr/kernel/abstracthttpkernel.zep.h | 45 ++ ext/phalcon/adr/kernel/httpkernel.zep.c | 39 ++ ext/phalcon/adr/kernel/httpkernel.zep.h | 5 + .../adr/middleware/corsmiddleware.zep.c | 30 +- .../middleware/methodoverridemiddleware.zep.c | 2 +- .../adr/middleware/requestidmiddleware.zep.c | 4 +- ext/phalcon/adr/payload/payload.zep.c | 24 +- ext/phalcon/adr/pipeline.zep.c | 24 +- .../adr/responder/formatresponder.zep.c | 8 +- ext/phalcon/adr/responder/redirect.zep.c | 10 +- ext/phalcon/adr/responder/statusmapper.zep.c | 6 +- .../adr/responder/statusresponder.zep.c | 8 +- ext/phalcon/adr/router/group.zep.c | 10 +- ext/phalcon/adr/router/route.zep.c | 14 +- ext/phalcon/adr/router/router.zep.c | 20 +- ext/phalcon/adr/router/routermatch.zep.c | 8 +- ext/phalcon/annotations/adapter/apcu.zep.c | 14 +- ext/phalcon/annotations/adapter/memory.zep.c | 2 +- ext/phalcon/annotations/adapter/stream.zep.c | 16 +- ext/phalcon/annotations/annotation.zep.c | 22 +- ext/phalcon/annotations/collection.zep.c | 26 +- ext/phalcon/annotations/reader.zep.c | 22 +- ext/phalcon/annotations/reflection.zep.c | 14 +- ext/phalcon/assets/collection.zep.c | 60 +-- ext/phalcon/assets/manager.zep.c | 122 ++--- .../assets/traits/attributestrait.zep.c | 2 +- .../assets/traits/sourcetargettrait.zep.c | 10 +- ext/phalcon/auth/access/accesslocator.zep.c | 2 +- ext/phalcon/auth/access/acl.zep.c | 20 +- .../adapter/config/memoryadapterconfig.zep.c | 2 +- .../adapter/config/modeladapterconfig.zep.c | 6 +- .../adapter/config/streamadapterconfig.zep.c | 4 +- ext/phalcon/auth/adapter/memory.zep.c | 10 +- ext/phalcon/auth/adapter/model.zep.c | 16 +- ext/phalcon/auth/adapter/stream.zep.c | 16 +- ext/phalcon/auth/authuser.zep.c | 8 +- .../configrequiresnonemptyvalue.zep.c | 2 +- .../auth/exceptions/doesnotimplement.zep.c | 2 +- .../guard/config/sessionguardconfig.zep.c | 24 +- .../auth/guard/config/tokenguardconfig.zep.c | 8 +- ext/phalcon/auth/guard/session.zep.c | 92 ++-- ext/phalcon/auth/guard/token.zep.c | 30 +- ext/phalcon/auth/guard/userremember.zep.c | 8 +- .../auth/internal/containerresolver.zep.c | 4 +- ext/phalcon/auth/internal/options.zep.c | 4 +- ext/phalcon/auth/manager.zep.c | 44 +- ext/phalcon/auth/managerfactory.zep.c | 42 +- .../auth/micro/authmicrolistener.zep.c | 4 +- .../auth/mvc/authdispatcherlistener.zep.c | 4 +- ext/phalcon/autoload/loader.zep.c | 128 ++--- ext/phalcon/cache/abstractcache.zep.c | 28 +- ext/phalcon/cache/adapterfactory.zep.c | 4 +- ext/phalcon/cache/cachefactory.zep.c | 6 +- ext/phalcon/cli/console.zep.c | 64 +-- ext/phalcon/cli/dispatcher.zep.c | 18 +- ext/phalcon/cli/router.zep.c | 92 ++-- ext/phalcon/cli/router/route.zep.c | 52 +- ext/phalcon/cli/task.zep.c | 2 +- ext/phalcon/config/adapter/grouped.zep.c | 18 +- ext/phalcon/config/adapter/ini.zep.c | 12 +- ext/phalcon/config/adapter/json.zep.c | 4 +- ext/phalcon/config/adapter/php.zep.c | 4 +- ext/phalcon/config/adapter/yaml.zep.c | 8 +- ext/phalcon/config/configfactory.zep.c | 6 +- .../exceptions/cannotloadconfigfile.zep.c | 2 +- .../exceptions/missingconfigoption.zep.c | 2 +- ext/phalcon/container/container.zep.c | 144 +++--- ext/phalcon/container/containerfactory.zep.c | 4 +- .../processor/closureprocessor.zep.c | 4 +- .../processor/objectprocessor.zep.c | 8 +- .../processor/parameterprocessor.zep.c | 4 +- .../processor/stringprocessor.zep.c | 6 +- .../definition/servicedefinition.zep.c | 120 ++--- ext/phalcon/container/provider/cli.zep.c | 4 +- ext/phalcon/container/provider/web.zep.c | 4 +- .../container/resolver/lazy/arrayvalues.zep.c | 14 +- .../container/resolver/lazy/call.zep.c | 4 +- .../container/resolver/lazy/callableget.zep.c | 6 +- .../container/resolver/lazy/callablenew.zep.c | 6 +- .../container/resolver/lazy/csenv.zep.c | 8 +- .../container/resolver/lazy/envdefault.zep.c | 2 +- .../resolver/lazy/functioncall.zep.c | 8 +- ext/phalcon/container/resolver/lazy/get.zep.c | 4 +- .../container/resolver/lazy/getcall.zep.c | 12 +- .../container/resolver/lazy/lazyfactory.zep.c | 26 +- .../container/resolver/lazy/newcall.zep.c | 12 +- .../container/resolver/lazy/newinstance.zep.c | 4 +- .../container/resolver/lazy/staticcall.zep.c | 12 +- ext/phalcon/container/resolver/resolver.zep.c | 26 +- ext/phalcon/contracts/adr/application.zep.c | 37 ++ ext/phalcon/contracts/adr/application.zep.h | 13 + .../contracts/adr/emitter/emitter.zep.c | 36 ++ .../contracts/adr/emitter/emitter.zep.h | 14 + ext/phalcon/contracts/adr/kernel/kernel.zep.c | 37 ++ ext/phalcon/contracts/adr/kernel/kernel.zep.h | 12 + ext/phalcon/datamapper/pdo/connection.zep.c | 36 +- .../datamapper/pdo/connection/decorated.zep.c | 4 +- .../datamapper/pdo/connectionlocator.zep.c | 8 +- .../datamapper/pdo/profiler/profiler.zep.c | 44 +- ext/phalcon/datamapper/query/bind.zep.c | 22 +- ext/phalcon/datamapper/query/delete.zep.c | 4 +- ext/phalcon/datamapper/query/insert.zep.c | 16 +- .../datamapper/query/queryfactory.zep.c | 10 +- ext/phalcon/datamapper/query/select.zep.c | 56 +-- ext/phalcon/datamapper/query/update.zep.c | 14 +- ext/phalcon/db/adapter/pdo/mysql.zep.c | 16 +- ext/phalcon/db/adapter/pdo/postgresql.zep.c | 14 +- ext/phalcon/db/adapter/pdo/sqlite.zep.c | 22 +- ext/phalcon/db/check.zep.c | 8 +- ext/phalcon/db/column.zep.c | 72 +-- ext/phalcon/db/dialect/mysql.zep.c | 38 +- ext/phalcon/db/dialect/postgresql.zep.c | 12 +- ext/phalcon/db/dialect/sqlite.zep.c | 30 +- .../db/geometry/geometrycollection.zep.c | 6 +- ext/phalcon/db/geometry/linestring.zep.c | 6 +- ext/phalcon/db/geometry/multilinestring.zep.c | 6 +- ext/phalcon/db/geometry/multipoint.zep.c | 6 +- ext/phalcon/db/geometry/multipolygon.zep.c | 6 +- ext/phalcon/db/geometry/point.zep.c | 10 +- ext/phalcon/db/geometry/polygon.zep.c | 6 +- ext/phalcon/db/geometry/wkbparser.zep.c | 68 +-- ext/phalcon/db/index.zep.c | 22 +- ext/phalcon/db/profiler.zep.c | 28 +- ext/phalcon/db/profiler/item.zep.c | 14 +- ext/phalcon/db/rawvalue.zep.c | 6 +- ext/phalcon/db/reference.zep.c | 16 +- ext/phalcon/db/result/pdoresult.zep.c | 58 +-- ext/phalcon/di/factorydefault.zep.c | 4 +- ext/phalcon/di/factorydefault/cli.zep.c | 4 +- ext/phalcon/di/service.zep.c | 36 +- ext/phalcon/domain/payload/payload.zep.c | 12 +- ext/phalcon/encryption/crypt.zep.c | 98 ++-- ext/phalcon/encryption/security.zep.c | 116 ++--- .../encryption/security/jwt/builder.zep.c | 54 +-- .../encryption/security/jwt/signer/hmac.zep.c | 4 +- .../encryption/security/jwt/token/item.zep.c | 6 +- .../security/jwt/token/parser.zep.c | 6 +- .../security/jwt/token/signature.zep.c | 2 +- .../encryption/security/jwt/token/token.zep.c | 14 +- .../encryption/security/jwt/validator.zep.c | 36 +- ext/phalcon/encryption/security/random.zep.c | 6 +- .../security/uuid/randomnodeprovider.zep.c | 4 +- .../security/uuid/sysnodeprovider.zep.c | 16 +- .../encryption/security/uuid/version1.zep.c | 8 +- .../encryption/security/uuid/version3.zep.c | 4 +- .../encryption/security/uuid/version4.zep.c | 6 +- .../encryption/security/uuid/version5.zep.c | 4 +- .../encryption/security/uuid/version6.zep.c | 8 +- .../encryption/security/uuid/version7.zep.c | 10 +- ext/phalcon/events/event.zep.c | 20 +- ext/phalcon/events/manager.zep.c | 192 ++++---- ext/phalcon/filter/filter.zep.c | 12 +- ext/phalcon/filter/validation.zep.c | 72 +-- .../traits/validatorcompositetrait.zep.c | 2 +- .../validation/validator/callback.zep.c | 12 +- .../validation/validator/confirmation.zep.c | 2 +- .../validation/validator/creditcard.zep.c | 2 +- .../validation/validator/file/mimetype.zep.c | 2 +- .../filter/validation/validator/files.zep.c | 2 +- .../validator/stringlength/max.zep.c | 2 +- .../validator/stringlength/min.zep.c | 2 +- .../validation/validator/uniqueness.zep.c | 10 +- .../filter/validation/validator/url.zep.c | 2 +- ext/phalcon/flash/direct.zep.c | 2 +- ext/phalcon/flash/session.zep.c | 22 +- ext/phalcon/forms/element/check.zep.c | 6 +- ext/phalcon/forms/element/checkgroup.zep.c | 10 +- ext/phalcon/forms/element/radiogroup.zep.c | 10 +- ext/phalcon/forms/element/select.zep.c | 10 +- ext/phalcon/forms/form.zep.c | 114 ++--- ext/phalcon/forms/formslocator.zep.c | 44 +- ext/phalcon/forms/loader/arrayloader.zep.c | 4 +- ext/phalcon/forms/loader/jsonloader.zep.c | 8 +- ext/phalcon/forms/loader/yamlloader.zep.c | 10 +- ext/phalcon/forms/manager.zep.c | 16 +- ext/phalcon/html/breadcrumbs.zep.c | 14 +- ext/phalcon/html/escaper.zep.c | 68 +-- .../html/escaper/attributeescaper.zep.c | 6 +- ext/phalcon/html/escaper/htmlescaper.zep.c | 6 +- .../html/escaper/traits/escapertrait.zep.c | 8 +- ext/phalcon/html/helper/anchor.zep.c | 6 +- ext/phalcon/html/helper/breadcrumbs.zep.c | 70 +-- ext/phalcon/html/helper/button.zep.c | 6 +- ext/phalcon/html/helper/doctype.zep.c | 46 +- ext/phalcon/html/helper/element.zep.c | 6 +- ext/phalcon/html/helper/friendlytitle.zep.c | 4 +- .../html/helper/input/checkboxgroup.zep.c | 8 +- ext/phalcon/html/helper/input/generic.zep.c | 4 +- .../html/helper/input/radiogroup.zep.c | 4 +- ext/phalcon/html/helper/input/select.zep.c | 36 +- .../html/helper/input/select/arraydata.zep.c | 4 +- .../helper/input/select/resultsetdata.zep.c | 28 +- ext/phalcon/html/helper/input/textarea.zep.c | 6 +- ext/phalcon/html/helper/label.zep.c | 6 +- ext/phalcon/html/helper/ol.zep.c | 8 +- ext/phalcon/html/helper/preload.zep.c | 6 +- ext/phalcon/html/helper/style.zep.c | 8 +- ext/phalcon/html/helper/title.zep.c | 38 +- ext/phalcon/html/helper/voidtag.zep.c | 4 +- ext/phalcon/html/tagfactory.zep.c | 168 +++---- ext/phalcon/http/cookie.zep.c | 144 +++--- ext/phalcon/http/request.zep.c | 68 +-- .../http/request/bag/abstractbag.zep.c | 24 +- ext/phalcon/http/request/file.zep.c | 24 +- ext/phalcon/http/response.zep.c | 70 +-- ext/phalcon/http/response/cookies.zep.c | 50 +- ext/phalcon/http/response/headers.zep.c | 34 +- ext/phalcon/image/adapter/gd.zep.c | 266 +++++------ ext/phalcon/image/adapter/imagick.zep.c | 250 +++++----- ext/phalcon/logger/abstractlogger.zep.c | 66 +-- ext/phalcon/logger/adapter/stream.zep.c | 26 +- ext/phalcon/logger/adapter/syslog.zep.c | 22 +- ext/phalcon/logger/formatter/json.zep.c | 6 +- ext/phalcon/logger/formatter/line.zep.c | 24 +- ext/phalcon/logger/item.zep.c | 10 +- ext/phalcon/logger/loggerfactory.zep.c | 6 +- ext/phalcon/messages/message.zep.c | 30 +- ext/phalcon/messages/messages.zep.c | 30 +- ext/phalcon/mvc/application.zep.c | 24 +- ext/phalcon/mvc/controller.zep.c | 6 +- ext/phalcon/mvc/dispatcher.zep.c | 12 +- ext/phalcon/mvc/micro.zep.c | 136 +++--- ext/phalcon/mvc/micro/collection.zep.c | 12 +- ext/phalcon/mvc/micro/lazyloader.zep.c | 8 +- ext/phalcon/mvc/model.zep.c | 328 ++++++------- ext/phalcon/mvc/model/binder.zep.c | 18 +- ext/phalcon/mvc/model/criteria.zep.c | 54 +-- ext/phalcon/mvc/model/manager.zep.c | 162 +++---- ext/phalcon/mvc/model/metadata/apcu.zep.c | 2 +- .../mvc/model/metadata/libmemcached.zep.c | 4 +- ext/phalcon/mvc/model/metadata/redis.zep.c | 4 +- ext/phalcon/mvc/model/metadata/stream.zep.c | 6 +- ext/phalcon/mvc/model/query.zep.c | 324 ++++++------- ext/phalcon/mvc/model/query/builder.zep.c | 182 +++---- ext/phalcon/mvc/model/query/status.zep.c | 8 +- ext/phalcon/mvc/model/relation.zep.c | 28 +- ext/phalcon/mvc/model/resultset/complex.zep.c | 66 +-- ext/phalcon/mvc/model/resultset/simple.zep.c | 96 ++-- ext/phalcon/mvc/model/row.zep.c | 2 +- ext/phalcon/mvc/model/transaction.zep.c | 40 +- .../mvc/model/transaction/failed.zep.c | 4 +- .../mvc/model/transaction/manager.zep.c | 40 +- ext/phalcon/mvc/model/validationfailed.zep.c | 4 +- ext/phalcon/mvc/router.zep.c | 448 +++++++++--------- ext/phalcon/mvc/router/annotations.zep.c | 34 +- ext/phalcon/mvc/router/group.zep.c | 18 +- ext/phalcon/mvc/router/route.zep.c | 40 +- ext/phalcon/mvc/url.zep.c | 26 +- ext/phalcon/mvc/view.zep.c | 168 +++---- ext/phalcon/mvc/view/engine/php.zep.c | 2 +- ext/phalcon/mvc/view/engine/volt.zep.c | 30 +- .../mvc/view/engine/volt/compiler.zep.c | 156 +++--- ext/phalcon/mvc/view/simple.zep.c | 50 +- .../mvc/view/traits/viewparamstrait.zep.c | 8 +- ext/phalcon/paginator/adapter/model.zep.c | 8 +- .../paginator/adapter/nativearray.zep.c | 10 +- .../paginator/adapter/querybuilder.zep.c | 14 +- .../adapter/querybuildercursor.zep.c | 26 +- .../exceptions/missingrequiredparameter.zep.c | 2 +- ext/phalcon/paginator/repository.zep.c | 8 +- .../beanstalk/beanstalkconnection.zep.c | 44 +- .../beanstalkconnectionfactory.zep.c | 4 +- .../adapter/beanstalk/beanstalkconsumer.zep.c | 16 +- .../adapter/beanstalk/beanstalkcontext.zep.c | 30 +- .../adapter/beanstalk/beanstalkmessage.zep.c | 2 +- .../adapter/beanstalk/beanstalkproducer.zep.c | 18 +- .../beanstalksubscriptionconsumer.zep.c | 4 +- ext/phalcon/queue/adapter/genericqueue.zep.c | 2 +- ext/phalcon/queue/adapter/generictopic.zep.c | 2 +- .../memory/memoryconnectionfactory.zep.c | 2 +- .../queue/adapter/memory/memoryconsumer.zep.c | 12 +- .../queue/adapter/memory/memorycontext.zep.c | 6 +- .../queue/adapter/memory/memoryproducer.zep.c | 4 +- .../memory/memorysubscriptionconsumer.zep.c | 2 +- .../redis/redisconnectionfactory.zep.c | 4 +- .../queue/adapter/redis/redisconsumer.zep.c | 16 +- .../queue/adapter/redis/rediscontext.zep.c | 34 +- .../queue/adapter/redis/redisproducer.zep.c | 10 +- .../redis/redissubscriptionconsumer.zep.c | 4 +- .../stream/streamconnectionfactory.zep.c | 10 +- .../queue/adapter/stream/streamconsumer.zep.c | 14 +- .../queue/adapter/stream/streamcontext.zep.c | 24 +- .../queue/adapter/stream/streamproducer.zep.c | 4 +- .../stream/streamsubscriptionconsumer.zep.c | 4 +- .../queue/adapter/traits/messagetrait.zep.c | 28 +- .../traits/subscriptionconsumertrait.zep.c | 10 +- .../queue/consumer/boundprocessor.zep.c | 6 +- .../queue/consumer/queueconsumer.zep.c | 30 +- ext/phalcon/queue/consumer/worker.zep.c | 18 +- .../queue/consumer/workeroptions.zep.c | 8 +- ext/phalcon/queue/queuefactory.zep.c | 4 +- .../session/adapter/libmemcached.zep.c | 2 +- ext/phalcon/session/adapter/redis.zep.c | 60 +-- ext/phalcon/session/adapter/stream.zep.c | 38 +- ext/phalcon/session/bag.zep.c | 30 +- ext/phalcon/session/manager.zep.c | 22 +- ext/phalcon/storage/adapter/apcu.zep.c | 16 +- .../storage/adapter/libmemcached.zep.c | 22 +- ext/phalcon/storage/adapter/memory.zep.c | 34 +- .../storage/adapter/rediscluster.zep.c | 14 +- ext/phalcon/storage/adapter/stream.zep.c | 60 +-- ext/phalcon/storage/adapter/weak.zep.c | 32 +- ext/phalcon/storage/adapterfactory.zep.c | 4 +- ext/phalcon/storage/serializer/base64.zep.c | 14 +- ext/phalcon/storage/serializer/igbinary.zep.c | 32 +- ext/phalcon/storage/serializer/json.zep.c | 16 +- ext/phalcon/storage/serializer/php.zep.c | 22 +- .../collection/readonlycollection.zep.c | 18 +- ext/phalcon/support/debug.zep.c | 52 +- ext/phalcon/support/debug/dump.zep.c | 28 +- .../support/debug/renderer/htmlrenderer.zep.c | 2 +- .../support/debug/report/backtraceitem.zep.c | 22 +- .../debug/report/exceptionreport.zep.c | 30 +- ext/phalcon/support/debug/reportbuilder.zep.c | 6 +- .../support/helper/arr/blacklist.zep.c | 6 +- ext/phalcon/support/helper/arr/group.zep.c | 2 +- ext/phalcon/support/helper/arr/isunique.zep.c | 2 +- .../support/helper/arr/sliceleft.zep.c | 2 +- .../support/helper/arr/sliceright.zep.c | 2 +- .../support/helper/arr/whitelist.zep.c | 4 +- .../support/helper/str/decapitalize.zep.c | 4 +- .../support/helper/str/dirfromfile.zep.c | 6 +- ext/phalcon/support/helper/str/dynamic.zep.c | 2 +- ext/phalcon/support/helperfactory.zep.c | 4 +- ext/phalcon/tag.zep.c | 2 +- ext/phalcon/time/clock/frozenclock.zep.c | 18 +- ext/phalcon/time/clock/systemclock.zep.c | 10 +- ext/phalcon/traits/php/apcutrait.zep.c | 12 +- ext/phalcon/traits/php/headertrait.zep.c | 2 +- ext/phalcon/traits/php/igbinarytrait.zep.c | 4 +- ext/phalcon/traits/php/infotrait.zep.c | 2 +- ext/phalcon/traits/php/initrait.zep.c | 8 +- ext/phalcon/traits/php/yamltrait.zep.c | 2 +- .../support/helper/str/dirfromfiletrait.zep.c | 6 +- ext/phalcon/translate/adapter/csv.zep.c | 4 +- ext/phalcon/translate/adapter/gettext.zep.c | 20 +- .../translate/adapter/nativearray.zep.c | 6 +- .../exceptions/missingrequiredparameter.zep.c | 2 +- ext/phalcon/translate/translatefactory.zep.c | 4 +- 480 files changed, 6969 insertions(+), 5237 deletions(-) create mode 100644 ext/phalcon/94__closure.zep.c create mode 100644 ext/phalcon/94__closure.zep.h create mode 100644 ext/phalcon/95__closure.zep.c create mode 100644 ext/phalcon/95__closure.zep.h create mode 100644 ext/phalcon/adr/application.zep.c create mode 100644 ext/phalcon/adr/application.zep.h create mode 100644 ext/phalcon/adr/container/adrprovider.zep.c create mode 100644 ext/phalcon/adr/container/adrprovider.zep.h create mode 100644 ext/phalcon/adr/emitter/exceptions/headersalreadysent.zep.c create mode 100644 ext/phalcon/adr/emitter/exceptions/headersalreadysent.zep.h create mode 100644 ext/phalcon/adr/emitter/exceptions/outputalreadysent.zep.c create mode 100644 ext/phalcon/adr/emitter/exceptions/outputalreadysent.zep.h create mode 100644 ext/phalcon/adr/emitter/sapiemitter.zep.c create mode 100644 ext/phalcon/adr/emitter/sapiemitter.zep.h create mode 100644 ext/phalcon/adr/errorresponder.zep.c create mode 100644 ext/phalcon/adr/errorresponder.zep.h create mode 100644 ext/phalcon/adr/kernel/abstracthttpkernel.zep.c create mode 100644 ext/phalcon/adr/kernel/abstracthttpkernel.zep.h create mode 100644 ext/phalcon/adr/kernel/httpkernel.zep.c create mode 100644 ext/phalcon/adr/kernel/httpkernel.zep.h create mode 100644 ext/phalcon/contracts/adr/application.zep.c create mode 100644 ext/phalcon/contracts/adr/application.zep.h create mode 100644 ext/phalcon/contracts/adr/emitter/emitter.zep.c create mode 100644 ext/phalcon/contracts/adr/emitter/emitter.zep.h create mode 100644 ext/phalcon/contracts/adr/kernel/kernel.zep.c create mode 100644 ext/phalcon/contracts/adr/kernel/kernel.zep.h diff --git a/ext/config.m4 b/ext/config.m4 index 0c614fd571..fb75d7beaa 100644 --- a/ext/config.m4 +++ b/ext/config.m4 @@ -76,6 +76,7 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/encryption/security/uuid/uuidinterface.zep.c phalcon/paginator/exception.zep.c phalcon/support/exception.zep.c + phalcon/adr/exceptions/adrthrowable.zep.c phalcon/assets/assetinterface.zep.c phalcon/config/configinterface.zep.c phalcon/contracts/db/adapter/adapter.zep.c @@ -87,6 +88,7 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/events/exception.zep.c phalcon/mvc/model/metadatainterface.zep.c phalcon/storage/exception.zep.c + phalcon/adr/exceptions/exception.zep.c phalcon/config/config.zep.c phalcon/contracts/db/dialect.zep.c phalcon/contracts/logger/adapter/adapter.zep.c @@ -102,7 +104,6 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/http/request/exception.zep.c phalcon/mvc/model/metadata.zep.c phalcon/paginator/adapter/adapterinterface.zep.c - phalcon/adr/exceptions/adrthrowable.zep.c phalcon/annotations/adapter/adapterinterface.zep.c phalcon/auth/adapter/abstractadapter.zep.c phalcon/container/definition/processor/processor.zep.c @@ -133,7 +134,6 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/queue/adapter/abstractproducer.zep.c phalcon/queue/adapter/abstractsubscriptionconsumer.zep.c phalcon/translate/adapter/adapterinterface.zep.c - phalcon/adr/exceptions/exception.zep.c phalcon/adr/responder/chainresponder.zep.c phalcon/acl/adapter/adapterinterface.zep.c phalcon/annotations/adapter/abstractadapter.zep.c @@ -148,6 +148,7 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/contracts/auth/guard/guard.zep.c phalcon/contracts/auth/guard/guardconfig.zep.c phalcon/contracts/cache/cache.zep.c + phalcon/contracts/container/service/provider.zep.c phalcon/contracts/encryption/security/uuid/nodeprovider.zep.c phalcon/contracts/encryption/security/uuid/timebaseduuid.zep.c phalcon/contracts/forms/schema.zep.c @@ -191,13 +192,13 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/cache/cacheinterface.zep.c phalcon/cli/taskinterface.zep.c phalcon/container/resolver/lazy/env.zep.c + phalcon/contracts/adr/kernel/kernel.zep.c phalcon/contracts/adr/responder/formatter/formatter.zep.c phalcon/contracts/acl/component.zep.c phalcon/contracts/acl/role.zep.c phalcon/contracts/cli/dispatcher.zep.c phalcon/contracts/container/ioc/ioccontainer.zep.c phalcon/contracts/container/resolver/reflectionparameterresolver.zep.c - phalcon/contracts/container/service/provider.zep.c phalcon/contracts/db/check.zep.c phalcon/contracts/db/column.zep.c phalcon/contracts/db/index.zep.c @@ -246,6 +247,7 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/support/helper/str/pascalcase.zep.c phalcon/time/clock/clockinterface.zep.c phalcon/translate/interpolator/interpolatorinterface.zep.c + phalcon/adr/kernel/abstracthttpkernel.zep.c phalcon/acl/adapter/memory.zep.c phalcon/acl/componentinterface.zep.c phalcon/acl/roleinterface.zep.c @@ -255,7 +257,9 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/cli/router/routeinterface.zep.c phalcon/cli/routerinterface.zep.c phalcon/cli/task.zep.c + phalcon/contracts/adr/application.zep.c phalcon/contracts/adr/dispatcher.zep.c + phalcon/contracts/adr/emitter/emitter.zep.c phalcon/contracts/adr/payload/payload.zep.c phalcon/contracts/adr/router/group.zep.c phalcon/contracts/adr/router/route.zep.c @@ -354,11 +358,18 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/support/collection/exception.zep.c phalcon/support/debug/exception.zep.c phalcon/time/clock/exception.zep.c + phalcon/adr/application.zep.c + phalcon/adr/container/adrprovider.zep.c phalcon/adr/dispatcher.zep.c + phalcon/adr/emitter/exceptions/headersalreadysent.zep.c + phalcon/adr/emitter/exceptions/outputalreadysent.zep.c + phalcon/adr/emitter/sapiemitter.zep.c + phalcon/adr/errorresponder.zep.c phalcon/adr/eventfulhandler.zep.c phalcon/adr/events/event.zep.c phalcon/adr/exceptions/notanaction.zep.c phalcon/adr/input/input.zep.c + phalcon/adr/kernel/httpkernel.zep.c phalcon/adr/middleware/corsmiddleware.zep.c phalcon/adr/middleware/methodoverridemiddleware.zep.c phalcon/adr/middleware/requestidmiddleware.zep.c @@ -1520,7 +1531,9 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/90__closure.zep.c phalcon/91__closure.zep.c phalcon/92__closure.zep.c - phalcon/93__closure.zep.c phalcon/annotations/scanner.c + phalcon/93__closure.zep.c + phalcon/94__closure.zep.c + phalcon/95__closure.zep.c phalcon/annotations/scanner.c phalcon/annotations/parser.c phalcon/mvc/model/orm.c phalcon/mvc/model/query/scanner.c @@ -1530,7 +1543,7 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/mvc/url/utils.c" PHP_NEW_EXTENSION(phalcon, $phalcon_sources, $ext_shared,, ) PHP_ADD_BUILD_DIR([$ext_builddir/kernel/]) - for dir in "phalcon phalcon/acl phalcon/acl/adapter phalcon/acl/exceptions phalcon/acl/traits phalcon/adr phalcon/adr/events phalcon/adr/exceptions phalcon/adr/input phalcon/adr/middleware phalcon/adr/payload phalcon/adr/responder phalcon/adr/responder/formatter phalcon/adr/router phalcon/adr/router/exceptions phalcon/adr/router/traits phalcon/annotations phalcon/annotations/adapter phalcon/annotations/exceptions phalcon/application phalcon/application/exceptions phalcon/assets phalcon/assets/asset phalcon/assets/exceptions phalcon/assets/filters phalcon/assets/inline phalcon/assets/traits phalcon/auth phalcon/auth/access phalcon/auth/adapter phalcon/auth/adapter/config phalcon/auth/adapter/config/traits phalcon/auth/cli phalcon/auth/exceptions phalcon/auth/guard phalcon/auth/guard/config phalcon/auth/internal phalcon/auth/micro phalcon/auth/mvc phalcon/autoload phalcon/autoload/exceptions phalcon/cache phalcon/cache/adapter phalcon/cache/exception phalcon/cli phalcon/cli/console phalcon/cli/console/exceptions phalcon/cli/dispatcher phalcon/cli/router phalcon/cli/router/exceptions phalcon/config phalcon/config/adapter phalcon/config/exceptions phalcon/container phalcon/container/definition phalcon/container/definition/processor phalcon/container/exceptions phalcon/container/provider phalcon/container/resolver phalcon/container/resolver/lazy phalcon/contracts/acl phalcon/contracts/acl/adapter phalcon/contracts/adr phalcon/contracts/adr/payload phalcon/contracts/adr/responder phalcon/contracts/adr/responder/formatter phalcon/contracts/adr/router phalcon/contracts/assets phalcon/contracts/auth phalcon/contracts/auth/access phalcon/contracts/auth/adapter phalcon/contracts/auth/guard phalcon/contracts/cache phalcon/contracts/cli phalcon/contracts/container/ioc phalcon/contracts/container/resolver phalcon/contracts/container/service phalcon/contracts/db phalcon/contracts/db/adapter phalcon/contracts/db/geometry phalcon/contracts/dispatcher phalcon/contracts/domain/payload phalcon/contracts/encryption/crypt phalcon/contracts/encryption/crypt/padding phalcon/contracts/encryption/security phalcon/contracts/encryption/security/jwt/signer phalcon/contracts/encryption/security/uuid phalcon/contracts/events phalcon/contracts/filter phalcon/contracts/flash phalcon/contracts/forms phalcon/contracts/html/helper/input phalcon/contracts/http phalcon/contracts/logger phalcon/contracts/logger/adapter phalcon/contracts/logger/formatter phalcon/contracts/messages phalcon/contracts/mvc phalcon/contracts/mvc/model/relation phalcon/contracts/paginator phalcon/contracts/queue phalcon/contracts/support phalcon/contracts/support/debug phalcon/datamapper/pdo phalcon/datamapper/pdo/connection phalcon/datamapper/pdo/exception phalcon/datamapper/pdo/profiler phalcon/datamapper/query phalcon/db phalcon/db/adapter phalcon/db/adapter/pdo phalcon/db/dialect phalcon/db/exceptions phalcon/db/geometry phalcon/db/profiler phalcon/db/result phalcon/db/traits phalcon/di phalcon/di/exception phalcon/di/exceptions phalcon/di/factorydefault phalcon/di/service phalcon/dispatcher phalcon/dispatcher/exceptions phalcon/domain/payload phalcon/encryption phalcon/encryption/crypt phalcon/encryption/crypt/exception phalcon/encryption/crypt/padding phalcon/encryption/security phalcon/encryption/security/exceptions phalcon/encryption/security/jwt phalcon/encryption/security/jwt/exceptions phalcon/encryption/security/jwt/signer phalcon/encryption/security/jwt/token phalcon/encryption/security/uuid phalcon/events phalcon/events/exceptions phalcon/factory phalcon/filter phalcon/filter/exceptions phalcon/filter/sanitize phalcon/filter/validation phalcon/filter/validation/exceptions phalcon/filter/validation/traits phalcon/filter/validation/validator phalcon/filter/validation/validator/file phalcon/filter/validation/validator/file/resolution phalcon/filter/validation/validator/file/size phalcon/filter/validation/validator/stringlength phalcon/flash phalcon/flash/exceptions phalcon/forms phalcon/forms/element phalcon/forms/exceptions phalcon/forms/loader phalcon/html phalcon/html/attributes phalcon/html/escaper phalcon/html/escaper/traits phalcon/html/exceptions phalcon/html/helper phalcon/html/helper/input phalcon/html/helper/input/select phalcon/html/link phalcon/html/link/interfaces phalcon/html/link/serializer phalcon/http phalcon/http/cookie phalcon/http/cookie/exceptions phalcon/http/message phalcon/http/request phalcon/http/request/bag phalcon/http/request/exceptions phalcon/http/response phalcon/http/response/exceptions phalcon/http/traits phalcon/image phalcon/image/adapter phalcon/image/exceptions phalcon/logger phalcon/logger/adapter phalcon/logger/adapter/exceptions phalcon/logger/exceptions phalcon/logger/formatter phalcon/messages phalcon/messages/exceptions phalcon/mvc phalcon/mvc/application phalcon/mvc/application/exceptions phalcon/mvc/controller phalcon/mvc/dispatcher phalcon/mvc/dispatcher/exceptions phalcon/mvc/micro phalcon/mvc/micro/exceptions phalcon/mvc/model phalcon/mvc/model/behavior phalcon/mvc/model/behavior/exceptions phalcon/mvc/model/binder phalcon/mvc/model/exceptions phalcon/mvc/model/hydration phalcon/mvc/model/metadata phalcon/mvc/model/metadata/exceptions phalcon/mvc/model/metadata/strategy phalcon/mvc/model/query phalcon/mvc/model/query/exceptions phalcon/mvc/model/query/exceptions/builder phalcon/mvc/model/resultset phalcon/mvc/model/transaction phalcon/mvc/router phalcon/mvc/router/exceptions phalcon/mvc/url phalcon/mvc/url/exceptions phalcon/mvc/view phalcon/mvc/view/engine phalcon/mvc/view/engine/volt phalcon/mvc/view/engine/volt/exceptions phalcon/mvc/view/exceptions phalcon/mvc/view/traits phalcon/paginator phalcon/paginator/adapter phalcon/paginator/exceptions phalcon/queue phalcon/queue/adapter phalcon/queue/adapter/beanstalk phalcon/queue/adapter/memory phalcon/queue/adapter/redis phalcon/queue/adapter/stream phalcon/queue/adapter/traits phalcon/queue/cli phalcon/queue/consumer phalcon/queue/exceptions phalcon/session phalcon/session/adapter phalcon/session/adapter/exceptions phalcon/session/exceptions phalcon/storage phalcon/storage/adapter phalcon/storage/exceptions phalcon/storage/serializer phalcon/storage/serializer/exceptions phalcon/support phalcon/support/collection phalcon/support/collection/exceptions phalcon/support/debug phalcon/support/debug/exceptions phalcon/support/debug/renderer phalcon/support/debug/report phalcon/support/helper phalcon/support/helper/arr phalcon/support/helper/file phalcon/support/helper/json phalcon/support/helper/json/exceptions phalcon/support/helper/number phalcon/support/helper/str phalcon/support/helper/str/exceptions phalcon/tag phalcon/time/clock phalcon/time/clock/exceptions phalcon/traits/php phalcon/traits/support/helper/arr phalcon/traits/support/helper/json phalcon/traits/support/helper/str phalcon/translate phalcon/translate/adapter phalcon/translate/exceptions phalcon/translate/interpolator"; do + for dir in "phalcon phalcon/acl phalcon/acl/adapter phalcon/acl/exceptions phalcon/acl/traits phalcon/adr phalcon/adr/container phalcon/adr/emitter phalcon/adr/emitter/exceptions phalcon/adr/events phalcon/adr/exceptions phalcon/adr/input phalcon/adr/kernel phalcon/adr/middleware phalcon/adr/payload phalcon/adr/responder phalcon/adr/responder/formatter phalcon/adr/router phalcon/adr/router/exceptions phalcon/adr/router/traits phalcon/annotations phalcon/annotations/adapter phalcon/annotations/exceptions phalcon/application phalcon/application/exceptions phalcon/assets phalcon/assets/asset phalcon/assets/exceptions phalcon/assets/filters phalcon/assets/inline phalcon/assets/traits phalcon/auth phalcon/auth/access phalcon/auth/adapter phalcon/auth/adapter/config phalcon/auth/adapter/config/traits phalcon/auth/cli phalcon/auth/exceptions phalcon/auth/guard phalcon/auth/guard/config phalcon/auth/internal phalcon/auth/micro phalcon/auth/mvc phalcon/autoload phalcon/autoload/exceptions phalcon/cache phalcon/cache/adapter phalcon/cache/exception phalcon/cli phalcon/cli/console phalcon/cli/console/exceptions phalcon/cli/dispatcher phalcon/cli/router phalcon/cli/router/exceptions phalcon/config phalcon/config/adapter phalcon/config/exceptions phalcon/container phalcon/container/definition phalcon/container/definition/processor phalcon/container/exceptions phalcon/container/provider phalcon/container/resolver phalcon/container/resolver/lazy phalcon/contracts/acl phalcon/contracts/acl/adapter phalcon/contracts/adr phalcon/contracts/adr/emitter phalcon/contracts/adr/kernel phalcon/contracts/adr/payload phalcon/contracts/adr/responder phalcon/contracts/adr/responder/formatter phalcon/contracts/adr/router phalcon/contracts/assets phalcon/contracts/auth phalcon/contracts/auth/access phalcon/contracts/auth/adapter phalcon/contracts/auth/guard phalcon/contracts/cache phalcon/contracts/cli phalcon/contracts/container/ioc phalcon/contracts/container/resolver phalcon/contracts/container/service phalcon/contracts/db phalcon/contracts/db/adapter phalcon/contracts/db/geometry phalcon/contracts/dispatcher phalcon/contracts/domain/payload phalcon/contracts/encryption/crypt phalcon/contracts/encryption/crypt/padding phalcon/contracts/encryption/security phalcon/contracts/encryption/security/jwt/signer phalcon/contracts/encryption/security/uuid phalcon/contracts/events phalcon/contracts/filter phalcon/contracts/flash phalcon/contracts/forms phalcon/contracts/html/helper/input phalcon/contracts/http phalcon/contracts/logger phalcon/contracts/logger/adapter phalcon/contracts/logger/formatter phalcon/contracts/messages phalcon/contracts/mvc phalcon/contracts/mvc/model/relation phalcon/contracts/paginator phalcon/contracts/queue phalcon/contracts/support phalcon/contracts/support/debug phalcon/datamapper/pdo phalcon/datamapper/pdo/connection phalcon/datamapper/pdo/exception phalcon/datamapper/pdo/profiler phalcon/datamapper/query phalcon/db phalcon/db/adapter phalcon/db/adapter/pdo phalcon/db/dialect phalcon/db/exceptions phalcon/db/geometry phalcon/db/profiler phalcon/db/result phalcon/db/traits phalcon/di phalcon/di/exception phalcon/di/exceptions phalcon/di/factorydefault phalcon/di/service phalcon/dispatcher phalcon/dispatcher/exceptions phalcon/domain/payload phalcon/encryption phalcon/encryption/crypt phalcon/encryption/crypt/exception phalcon/encryption/crypt/padding phalcon/encryption/security phalcon/encryption/security/exceptions phalcon/encryption/security/jwt phalcon/encryption/security/jwt/exceptions phalcon/encryption/security/jwt/signer phalcon/encryption/security/jwt/token phalcon/encryption/security/uuid phalcon/events phalcon/events/exceptions phalcon/factory phalcon/filter phalcon/filter/exceptions phalcon/filter/sanitize phalcon/filter/validation phalcon/filter/validation/exceptions phalcon/filter/validation/traits phalcon/filter/validation/validator phalcon/filter/validation/validator/file phalcon/filter/validation/validator/file/resolution phalcon/filter/validation/validator/file/size phalcon/filter/validation/validator/stringlength phalcon/flash phalcon/flash/exceptions phalcon/forms phalcon/forms/element phalcon/forms/exceptions phalcon/forms/loader phalcon/html phalcon/html/attributes phalcon/html/escaper phalcon/html/escaper/traits phalcon/html/exceptions phalcon/html/helper phalcon/html/helper/input phalcon/html/helper/input/select phalcon/html/link phalcon/html/link/interfaces phalcon/html/link/serializer phalcon/http phalcon/http/cookie phalcon/http/cookie/exceptions phalcon/http/message phalcon/http/request phalcon/http/request/bag phalcon/http/request/exceptions phalcon/http/response phalcon/http/response/exceptions phalcon/http/traits phalcon/image phalcon/image/adapter phalcon/image/exceptions phalcon/logger phalcon/logger/adapter phalcon/logger/adapter/exceptions phalcon/logger/exceptions phalcon/logger/formatter phalcon/messages phalcon/messages/exceptions phalcon/mvc phalcon/mvc/application phalcon/mvc/application/exceptions phalcon/mvc/controller phalcon/mvc/dispatcher phalcon/mvc/dispatcher/exceptions phalcon/mvc/micro phalcon/mvc/micro/exceptions phalcon/mvc/model phalcon/mvc/model/behavior phalcon/mvc/model/behavior/exceptions phalcon/mvc/model/binder phalcon/mvc/model/exceptions phalcon/mvc/model/hydration phalcon/mvc/model/metadata phalcon/mvc/model/metadata/exceptions phalcon/mvc/model/metadata/strategy phalcon/mvc/model/query phalcon/mvc/model/query/exceptions phalcon/mvc/model/query/exceptions/builder phalcon/mvc/model/resultset phalcon/mvc/model/transaction phalcon/mvc/router phalcon/mvc/router/exceptions phalcon/mvc/url phalcon/mvc/url/exceptions phalcon/mvc/view phalcon/mvc/view/engine phalcon/mvc/view/engine/volt phalcon/mvc/view/engine/volt/exceptions phalcon/mvc/view/exceptions phalcon/mvc/view/traits phalcon/paginator phalcon/paginator/adapter phalcon/paginator/exceptions phalcon/queue phalcon/queue/adapter phalcon/queue/adapter/beanstalk phalcon/queue/adapter/memory phalcon/queue/adapter/redis phalcon/queue/adapter/stream phalcon/queue/adapter/traits phalcon/queue/cli phalcon/queue/consumer phalcon/queue/exceptions phalcon/session phalcon/session/adapter phalcon/session/adapter/exceptions phalcon/session/exceptions phalcon/storage phalcon/storage/adapter phalcon/storage/exceptions phalcon/storage/serializer phalcon/storage/serializer/exceptions phalcon/support phalcon/support/collection phalcon/support/collection/exceptions phalcon/support/debug phalcon/support/debug/exceptions phalcon/support/debug/renderer phalcon/support/debug/report phalcon/support/helper phalcon/support/helper/arr phalcon/support/helper/file phalcon/support/helper/json phalcon/support/helper/json/exceptions phalcon/support/helper/number phalcon/support/helper/str phalcon/support/helper/str/exceptions phalcon/tag phalcon/time/clock phalcon/time/clock/exceptions phalcon/traits/php phalcon/traits/support/helper/arr phalcon/traits/support/helper/json phalcon/traits/support/helper/str phalcon/translate phalcon/translate/adapter phalcon/translate/exceptions phalcon/translate/interpolator"; do PHP_ADD_BUILD_DIR([$ext_builddir/$dir]) done PHP_SUBST(PHALCON_SHARED_LIBADD) diff --git a/ext/config.w32 b/ext/config.w32 index bc49032c27..82f36160f1 100644 --- a/ext/config.w32 +++ b/ext/config.w32 @@ -65,6 +65,7 @@ if (PHP_PHALCON != "no") { ADD_SOURCES(configure_module_dirname + "/phalcon/encryption/crypt/padding", "padinterface.zep.c ansi.zep.c iso10126.zep.c isoiek.zep.c noop.zep.c pkcs7.zep.c space.zep.c zero.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/encryption/security/uuid", "uuidinterface.zep.c abstractuuid.zep.c nodeproviderinterface.zep.c timebaseduuidinterface.zep.c randomnodeprovider.zep.c sysnodeprovider.zep.c version1.zep.c version3.zep.c version4.zep.c version5.zep.c version6.zep.c version7.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/paginator", "exception.zep.c repositoryinterface.zep.c paginatorfactory.zep.c repository.zep.c", "phalcon"); + ADD_SOURCES(configure_module_dirname + "/phalcon/adr/exceptions", "adrthrowable.zep.c exception.zep.c notanaction.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/db/adapter", "adapter.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/domain/payload", "readable.zep.c writeable.zep.c payload.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/paginator", "adapter.zep.c repository.zep.c", "phalcon"); @@ -79,11 +80,10 @@ if (PHP_PHALCON != "no") { ADD_SOURCES(configure_module_dirname + "/phalcon/html/helper/input", "abstractinput.zep.c abstractchecked.zep.c abstractgroup.zep.c checkbox.zep.c checkboxgroup.zep.c generic.zep.c radio.zep.c radiogroup.zep.c select.zep.c textarea.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/http/request", "exception.zep.c fileinterface.zep.c file.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/paginator/adapter", "adapterinterface.zep.c abstractadapter.zep.c model.zep.c nativearray.zep.c querybuilder.zep.c querybuildercursor.zep.c", "phalcon"); - ADD_SOURCES(configure_module_dirname + "/phalcon/adr/exceptions", "adrthrowable.zep.c exception.zep.c notanaction.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/annotations/adapter", "adapterinterface.zep.c abstractadapter.zep.c apcu.zep.c memory.zep.c stream.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/auth/adapter", "abstractadapter.zep.c abstractarrayadapter.zep.c adapterlocator.zep.c memory.zep.c model.zep.c stream.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/container/definition/processor", "processor.zep.c closureprocessor.zep.c objectprocessor.zep.c parameterprocessor.zep.c stringprocessor.zep.c", "phalcon"); - ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/adr", "middleware.zep.c handler.zep.c dispatcher.zep.c action.zep.c domain.zep.c", "phalcon"); + ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/adr", "middleware.zep.c handler.zep.c application.zep.c dispatcher.zep.c action.zep.c domain.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/acl/adapter", "adapter.zep.c persistable.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/auth/access", "access.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/encryption/security/jwt/signer", "signer.zep.c", "phalcon"); @@ -125,6 +125,7 @@ if (PHP_PHALCON != "no") { ADD_SOURCES(configure_module_dirname + "/phalcon/autoload", "exception.zep.c loader.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/cache", "cacheinterface.zep.c abstractcache.zep.c adapterfactory.zep.c cache.zep.c cachefactory.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/cli", "taskinterface.zep.c dispatcherinterface.zep.c routerinterface.zep.c task.zep.c console.zep.c dispatcher.zep.c router.zep.c", "phalcon"); + ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/adr/kernel", "kernel.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/adr/responder/formatter", "formatter.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/acl", "component.zep.c role.zep.c componentaware.zep.c roleaware.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/cli", "dispatcher.zep.c", "phalcon"); @@ -144,6 +145,8 @@ if (PHP_PHALCON != "no") { ADD_SOURCES(configure_module_dirname + "/phalcon/support/helper", "exception.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/time/clock", "clockinterface.zep.c exception.zep.c frozenclock.zep.c systemclock.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/translate/interpolator", "interpolatorinterface.zep.c associativearray.zep.c indexedarray.zep.c", "phalcon"); + ADD_SOURCES(configure_module_dirname + "/phalcon/adr/kernel", "abstracthttpkernel.zep.c httpkernel.zep.c", "phalcon"); + ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/adr/emitter", "emitter.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/adr/payload", "payload.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/adr/router", "group.zep.c route.zep.c router.zep.c routermatch.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/auth", "authuser.zep.c manager.zep.c authremember.zep.c remembertoken.zep.c", "phalcon"); @@ -161,7 +164,10 @@ if (PHP_PHALCON != "no") { ADD_SOURCES(configure_module_dirname + "/phalcon/mvc/model/query", "builderinterface.zep.c statusinterface.zep.c builder.zep.c lang.zep.c status.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/mvc/model/transaction", "exception.zep.c managerinterface.zep.c failed.zep.c manager.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/support/debug", "exception.zep.c dump.zep.c reportbuilder.zep.c", "phalcon"); - ADD_SOURCES(configure_module_dirname + "/phalcon/adr", "dispatcher.zep.c eventfulhandler.zep.c pipeline.zep.c", "phalcon"); + ADD_SOURCES(configure_module_dirname + "/phalcon/adr", "application.zep.c dispatcher.zep.c errorresponder.zep.c eventfulhandler.zep.c pipeline.zep.c", "phalcon"); + ADD_SOURCES(configure_module_dirname + "/phalcon/adr/container", "adrprovider.zep.c", "phalcon"); + ADD_SOURCES(configure_module_dirname + "/phalcon/adr/emitter/exceptions", "headersalreadysent.zep.c outputalreadysent.zep.c", "phalcon"); + ADD_SOURCES(configure_module_dirname + "/phalcon/adr/emitter", "sapiemitter.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/adr/events", "event.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/adr/input", "input.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/adr/middleware", "corsmiddleware.zep.c methodoverridemiddleware.zep.c requestidmiddleware.zep.c timingmiddleware.zep.c", "phalcon"); @@ -273,7 +279,7 @@ if (PHP_PHALCON != "no") { ADD_SOURCES(configure_module_dirname + "/phalcon/support/helper/json/exceptions", "jsondecodeerror.zep.c jsonencodeerror.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/support/helper/number", "isbetween.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/support/helper/str/exceptions", "insufficientarguments.zep.c invalidreplaceformat.zep.c syntaxerror.zep.c", "phalcon"); - ADD_SOURCES(configure_module_dirname + "/phalcon", "tag.zep.c 0__closure.zep.c 1__closure.zep.c 2__closure.zep.c 3__closure.zep.c 4__closure.zep.c 5__closure.zep.c 6__closure.zep.c 7__closure.zep.c 8__closure.zep.c 9__closure.zep.c 10__closure.zep.c 11__closure.zep.c 12__closure.zep.c 13__closure.zep.c 14__closure.zep.c 15__closure.zep.c 16__closure.zep.c 17__closure.zep.c 18__closure.zep.c 19__closure.zep.c 20__closure.zep.c 21__closure.zep.c 22__closure.zep.c 23__closure.zep.c 24__closure.zep.c 25__closure.zep.c 26__closure.zep.c 27__closure.zep.c 28__closure.zep.c 29__closure.zep.c 30__closure.zep.c 31__closure.zep.c 32__closure.zep.c 33__closure.zep.c 34__closure.zep.c 35__closure.zep.c 36__closure.zep.c 37__closure.zep.c 38__closure.zep.c 39__closure.zep.c 40__closure.zep.c 41__closure.zep.c 42__closure.zep.c 43__closure.zep.c 44__closure.zep.c 45__closure.zep.c 46__closure.zep.c 47__closure.zep.c 48__closure.zep.c 49__closure.zep.c 50__closure.zep.c 51__closure.zep.c 52__closure.zep.c 53__closure.zep.c 54__closure.zep.c 55__closure.zep.c 56__closure.zep.c 57__closure.zep.c 58__closure.zep.c 59__closure.zep.c 60__closure.zep.c 61__closure.zep.c 62__closure.zep.c 63__closure.zep.c 64__closure.zep.c 65__closure.zep.c 66__closure.zep.c 67__closure.zep.c 68__closure.zep.c 69__closure.zep.c 70__closure.zep.c 71__closure.zep.c 72__closure.zep.c 73__closure.zep.c 74__closure.zep.c 75__closure.zep.c 76__closure.zep.c 77__closure.zep.c 78__closure.zep.c 79__closure.zep.c 80__closure.zep.c 81__closure.zep.c 82__closure.zep.c 83__closure.zep.c 84__closure.zep.c 85__closure.zep.c 86__closure.zep.c 87__closure.zep.c 88__closure.zep.c 89__closure.zep.c 90__closure.zep.c 91__closure.zep.c 92__closure.zep.c 93__closure.zep.c", "phalcon"); + ADD_SOURCES(configure_module_dirname + "/phalcon", "tag.zep.c 0__closure.zep.c 1__closure.zep.c 2__closure.zep.c 3__closure.zep.c 4__closure.zep.c 5__closure.zep.c 6__closure.zep.c 7__closure.zep.c 8__closure.zep.c 9__closure.zep.c 10__closure.zep.c 11__closure.zep.c 12__closure.zep.c 13__closure.zep.c 14__closure.zep.c 15__closure.zep.c 16__closure.zep.c 17__closure.zep.c 18__closure.zep.c 19__closure.zep.c 20__closure.zep.c 21__closure.zep.c 22__closure.zep.c 23__closure.zep.c 24__closure.zep.c 25__closure.zep.c 26__closure.zep.c 27__closure.zep.c 28__closure.zep.c 29__closure.zep.c 30__closure.zep.c 31__closure.zep.c 32__closure.zep.c 33__closure.zep.c 34__closure.zep.c 35__closure.zep.c 36__closure.zep.c 37__closure.zep.c 38__closure.zep.c 39__closure.zep.c 40__closure.zep.c 41__closure.zep.c 42__closure.zep.c 43__closure.zep.c 44__closure.zep.c 45__closure.zep.c 46__closure.zep.c 47__closure.zep.c 48__closure.zep.c 49__closure.zep.c 50__closure.zep.c 51__closure.zep.c 52__closure.zep.c 53__closure.zep.c 54__closure.zep.c 55__closure.zep.c 56__closure.zep.c 57__closure.zep.c 58__closure.zep.c 59__closure.zep.c 60__closure.zep.c 61__closure.zep.c 62__closure.zep.c 63__closure.zep.c 64__closure.zep.c 65__closure.zep.c 66__closure.zep.c 67__closure.zep.c 68__closure.zep.c 69__closure.zep.c 70__closure.zep.c 71__closure.zep.c 72__closure.zep.c 73__closure.zep.c 74__closure.zep.c 75__closure.zep.c 76__closure.zep.c 77__closure.zep.c 78__closure.zep.c 79__closure.zep.c 80__closure.zep.c 81__closure.zep.c 82__closure.zep.c 83__closure.zep.c 84__closure.zep.c 85__closure.zep.c 86__closure.zep.c 87__closure.zep.c 88__closure.zep.c 89__closure.zep.c 90__closure.zep.c 91__closure.zep.c 92__closure.zep.c 93__closure.zep.c 94__closure.zep.c 95__closure.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/tag", "exception.zep.c select.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/time/clock/exceptions", "invalidmodifier.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/traits/php", "apcutrait.zep.c base64trait.zep.c filetrait.zep.c hashtrait.zep.c headertrait.zep.c igbinarytrait.zep.c infotrait.zep.c initrait.zep.c mbcasetrait.zep.c msgpacktrait.zep.c openssltrait.zep.c serializetrait.zep.c urltrait.zep.c yamltrait.zep.c", "phalcon"); diff --git a/ext/phalcon.c b/ext/phalcon.c index bba91fc8b7..9abd318ca6 100644 --- a/ext/phalcon.c +++ b/ext/phalcon.c @@ -51,6 +51,7 @@ zend_class_entry *phalcon_contracts_assets_asset_ce; zend_class_entry *phalcon_contracts_auth_adapter_adapter_ce; zend_class_entry *phalcon_encryption_crypt_padding_padinterface_ce; zend_class_entry *phalcon_encryption_security_uuid_uuidinterface_ce; +zend_class_entry *phalcon_adr_exceptions_adrthrowable_ce; zend_class_entry *phalcon_assets_assetinterface_ce; zend_class_entry *phalcon_config_configinterface_ce; zend_class_entry *phalcon_contracts_db_adapter_adapter_ce; @@ -67,7 +68,6 @@ zend_class_entry *phalcon_contracts_queue_producer_ce; zend_class_entry *phalcon_contracts_queue_subscriptionconsumer_ce; zend_class_entry *phalcon_db_adapter_adapterinterface_ce; zend_class_entry *phalcon_paginator_adapter_adapterinterface_ce; -zend_class_entry *phalcon_adr_exceptions_adrthrowable_ce; zend_class_entry *phalcon_annotations_adapter_adapterinterface_ce; zend_class_entry *phalcon_container_definition_processor_processor_ce; zend_class_entry *phalcon_contracts_acl_adapter_adapter_ce; @@ -92,6 +92,7 @@ zend_class_entry *phalcon_contracts_adr_handler_ce; zend_class_entry *phalcon_contracts_auth_guard_guard_ce; zend_class_entry *phalcon_contracts_auth_guard_guardconfig_ce; zend_class_entry *phalcon_contracts_cache_cache_ce; +zend_class_entry *phalcon_contracts_container_service_provider_ce; zend_class_entry *phalcon_contracts_encryption_security_uuid_nodeprovider_ce; zend_class_entry *phalcon_contracts_encryption_security_uuid_timebaseduuid_ce; zend_class_entry *phalcon_contracts_forms_schema_ce; @@ -114,11 +115,11 @@ zend_class_entry *phalcon_cache_cacheinterface_ce; zend_class_entry *phalcon_cli_taskinterface_ce; zend_class_entry *phalcon_contracts_acl_component_ce; zend_class_entry *phalcon_contracts_acl_role_ce; +zend_class_entry *phalcon_contracts_adr_kernel_kernel_ce; zend_class_entry *phalcon_contracts_adr_responder_formatter_formatter_ce; zend_class_entry *phalcon_contracts_cli_dispatcher_ce; zend_class_entry *phalcon_contracts_container_ioc_ioccontainer_ce; zend_class_entry *phalcon_contracts_container_resolver_reflectionparameterresolver_ce; -zend_class_entry *phalcon_contracts_container_service_provider_ce; zend_class_entry *phalcon_contracts_db_check_ce; zend_class_entry *phalcon_contracts_db_column_ce; zend_class_entry *phalcon_contracts_db_index_ce; @@ -154,7 +155,9 @@ zend_class_entry *phalcon_cli_routerinterface_ce; zend_class_entry *phalcon_contracts_acl_adapter_persistable_ce; zend_class_entry *phalcon_contracts_acl_componentaware_ce; zend_class_entry *phalcon_contracts_acl_roleaware_ce; +zend_class_entry *phalcon_contracts_adr_application_ce; zend_class_entry *phalcon_contracts_adr_dispatcher_ce; +zend_class_entry *phalcon_contracts_adr_emitter_emitter_ce; zend_class_entry *phalcon_contracts_adr_payload_payload_ce; zend_class_entry *phalcon_contracts_adr_router_group_ce; zend_class_entry *phalcon_contracts_adr_router_route_ce; @@ -326,6 +329,7 @@ zend_class_entry *phalcon_encryption_security_jwt_exceptions_validatorexception_ zend_class_entry *phalcon_encryption_security_uuid_abstractuuid_ce; zend_class_entry *phalcon_events_exception_ce; zend_class_entry *phalcon_storage_exception_ce; +zend_class_entry *phalcon_adr_exceptions_exception_ce; zend_class_entry *phalcon_config_config_ce; zend_class_entry *phalcon_datamapper_query_abstractquery_ce; zend_class_entry *phalcon_html_escaper_abstractescaper_ce; @@ -344,7 +348,6 @@ zend_class_entry *phalcon_queue_adapter_abstractcontext_ce; zend_class_entry *phalcon_queue_adapter_abstractmessage_ce; zend_class_entry *phalcon_queue_adapter_abstractproducer_ce; zend_class_entry *phalcon_queue_adapter_abstractsubscriptionconsumer_ce; -zend_class_entry *phalcon_adr_exceptions_exception_ce; zend_class_entry *phalcon_adr_responder_chainresponder_ce; zend_class_entry *phalcon_annotations_adapter_abstractadapter_ce; zend_class_entry *phalcon_annotations_exception_ce; @@ -399,6 +402,7 @@ zend_class_entry *phalcon_session_adapter_abstractadapter_ce; zend_class_entry *phalcon_support_helper_exception_ce; zend_class_entry *phalcon_support_helper_str_pascalcase_ce; zend_class_entry *phalcon_acl_adapter_memory_ce; +zend_class_entry *phalcon_adr_kernel_abstracthttpkernel_ce; zend_class_entry *phalcon_cache_abstractcache_ce; zend_class_entry *phalcon_cli_task_ce; zend_class_entry *phalcon_di_factorydefault_ce; @@ -519,6 +523,8 @@ zend_class_entry *phalcon_90__closure_ce; zend_class_entry *phalcon_91__closure_ce; zend_class_entry *phalcon_92__closure_ce; zend_class_entry *phalcon_93__closure_ce; +zend_class_entry *phalcon_94__closure_ce; +zend_class_entry *phalcon_95__closure_ce; zend_class_entry *phalcon_9__closure_ce; zend_class_entry *phalcon_acl_adapter_storage_ce; zend_class_entry *phalcon_acl_component_ce; @@ -536,11 +542,18 @@ zend_class_entry *phalcon_acl_exceptions_missingfunctionparameters_ce; zend_class_entry *phalcon_acl_exceptions_parametertypemismatch_ce; zend_class_entry *phalcon_acl_exceptions_rolenotfoundexception_ce; zend_class_entry *phalcon_acl_role_ce; +zend_class_entry *phalcon_adr_application_ce; +zend_class_entry *phalcon_adr_container_adrprovider_ce; zend_class_entry *phalcon_adr_dispatcher_ce; +zend_class_entry *phalcon_adr_emitter_exceptions_headersalreadysent_ce; +zend_class_entry *phalcon_adr_emitter_exceptions_outputalreadysent_ce; +zend_class_entry *phalcon_adr_emitter_sapiemitter_ce; +zend_class_entry *phalcon_adr_errorresponder_ce; zend_class_entry *phalcon_adr_eventfulhandler_ce; zend_class_entry *phalcon_adr_events_event_ce; zend_class_entry *phalcon_adr_exceptions_notanaction_ce; zend_class_entry *phalcon_adr_input_input_ce; +zend_class_entry *phalcon_adr_kernel_httpkernel_ce; zend_class_entry *phalcon_adr_middleware_corsmiddleware_ce; zend_class_entry *phalcon_adr_middleware_methodoverridemiddleware_ce; zend_class_entry *phalcon_adr_middleware_requestidmiddleware_ce; @@ -1600,6 +1613,7 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(Phalcon_Contracts_Auth_Adapter_Adapter); ZEPHIR_INIT(Phalcon_Encryption_Crypt_Padding_PadInterface); ZEPHIR_INIT(Phalcon_Encryption_Security_Uuid_UuidInterface); + ZEPHIR_INIT(Phalcon_ADR_Exceptions_ADRThrowable); ZEPHIR_INIT(Phalcon_Assets_AssetInterface); ZEPHIR_INIT(Phalcon_Config_ConfigInterface); ZEPHIR_INIT(Phalcon_Contracts_Db_Adapter_Adapter); @@ -1616,7 +1630,6 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(Phalcon_Contracts_Queue_SubscriptionConsumer); ZEPHIR_INIT(Phalcon_Db_Adapter_AdapterInterface); ZEPHIR_INIT(Phalcon_Paginator_Adapter_AdapterInterface); - ZEPHIR_INIT(Phalcon_ADR_Exceptions_ADRThrowable); ZEPHIR_INIT(Phalcon_Annotations_Adapter_AdapterInterface); ZEPHIR_INIT(Phalcon_Container_Definition_Processor_Processor); ZEPHIR_INIT(Phalcon_Contracts_ADR_Middleware); @@ -1641,6 +1654,7 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(Phalcon_Contracts_Auth_Guard_Guard); ZEPHIR_INIT(Phalcon_Contracts_Auth_Guard_GuardConfig); ZEPHIR_INIT(Phalcon_Contracts_Cache_Cache); + ZEPHIR_INIT(Phalcon_Contracts_Container_Service_Provider); ZEPHIR_INIT(Phalcon_Contracts_Encryption_Security_Uuid_NodeProvider); ZEPHIR_INIT(Phalcon_Contracts_Encryption_Security_Uuid_TimeBasedUuid); ZEPHIR_INIT(Phalcon_Contracts_Forms_Schema); @@ -1661,13 +1675,13 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(Phalcon_Mvc_View_Engine_EngineInterface); ZEPHIR_INIT(Phalcon_Cache_CacheInterface); ZEPHIR_INIT(Phalcon_Cli_TaskInterface); + ZEPHIR_INIT(Phalcon_Contracts_ADR_Kernel_Kernel); ZEPHIR_INIT(Phalcon_Contracts_ADR_Responder_Formatter_Formatter); ZEPHIR_INIT(Phalcon_Contracts_Acl_Component); ZEPHIR_INIT(Phalcon_Contracts_Acl_Role); ZEPHIR_INIT(Phalcon_Contracts_Cli_Dispatcher); ZEPHIR_INIT(Phalcon_Contracts_Container_Ioc_IocContainer); ZEPHIR_INIT(Phalcon_Contracts_Container_Resolver_ReflectionParameterResolver); - ZEPHIR_INIT(Phalcon_Contracts_Container_Service_Provider); ZEPHIR_INIT(Phalcon_Contracts_Db_Check); ZEPHIR_INIT(Phalcon_Contracts_Db_Column); ZEPHIR_INIT(Phalcon_Contracts_Db_Index); @@ -1700,7 +1714,9 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(Phalcon_Cli_DispatcherInterface); ZEPHIR_INIT(Phalcon_Cli_RouterInterface); ZEPHIR_INIT(Phalcon_Cli_Router_RouteInterface); + ZEPHIR_INIT(Phalcon_Contracts_ADR_Application); ZEPHIR_INIT(Phalcon_Contracts_ADR_Dispatcher); + ZEPHIR_INIT(Phalcon_Contracts_ADR_Emitter_Emitter); ZEPHIR_INIT(Phalcon_Contracts_ADR_Payload_Payload); ZEPHIR_INIT(Phalcon_Contracts_ADR_Router_Group); ZEPHIR_INIT(Phalcon_Contracts_ADR_Router_Route); @@ -1875,6 +1891,7 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(Phalcon_Encryption_Security_Uuid_AbstractUuid); ZEPHIR_INIT(Phalcon_Events_Exception); ZEPHIR_INIT(Phalcon_Storage_Exception); + ZEPHIR_INIT(Phalcon_ADR_Exceptions_Exception); ZEPHIR_INIT(Phalcon_Config_Config); ZEPHIR_INIT(Phalcon_DataMapper_Query_AbstractQuery); ZEPHIR_INIT(Phalcon_Html_Escaper_AbstractEscaper); @@ -1893,7 +1910,6 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(Phalcon_Queue_Adapter_AbstractMessage); ZEPHIR_INIT(Phalcon_Queue_Adapter_AbstractProducer); ZEPHIR_INIT(Phalcon_Queue_Adapter_AbstractSubscriptionConsumer); - ZEPHIR_INIT(Phalcon_ADR_Exceptions_Exception); ZEPHIR_INIT(Phalcon_ADR_Responder_ChainResponder); ZEPHIR_INIT(Phalcon_Annotations_Adapter_AbstractAdapter); ZEPHIR_INIT(Phalcon_Annotations_Exception); @@ -1947,6 +1963,7 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(Phalcon_Session_Adapter_AbstractAdapter); ZEPHIR_INIT(Phalcon_Support_Helper_Exception); ZEPHIR_INIT(Phalcon_Support_Helper_Str_PascalCase); + ZEPHIR_INIT(Phalcon_ADR_Kernel_AbstractHttpKernel); ZEPHIR_INIT(Phalcon_Acl_Adapter_Memory); ZEPHIR_INIT(Phalcon_Cache_AbstractCache); ZEPHIR_INIT(Phalcon_Cli_Task); @@ -1975,11 +1992,18 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(Phalcon_Support_Collection_Exception); ZEPHIR_INIT(Phalcon_Support_Debug_Exception); ZEPHIR_INIT(Phalcon_Time_Clock_Exception); + ZEPHIR_INIT(Phalcon_ADR_Application); + ZEPHIR_INIT(Phalcon_ADR_Container_AdrProvider); ZEPHIR_INIT(Phalcon_ADR_Dispatcher); + ZEPHIR_INIT(Phalcon_ADR_Emitter_Exceptions_HeadersAlreadySent); + ZEPHIR_INIT(Phalcon_ADR_Emitter_Exceptions_OutputAlreadySent); + ZEPHIR_INIT(Phalcon_ADR_Emitter_SapiEmitter); + ZEPHIR_INIT(Phalcon_ADR_ErrorResponder); ZEPHIR_INIT(Phalcon_ADR_EventfulHandler); ZEPHIR_INIT(Phalcon_ADR_Events_Event); ZEPHIR_INIT(Phalcon_ADR_Exceptions_NotAnAction); ZEPHIR_INIT(Phalcon_ADR_Input_Input); + ZEPHIR_INIT(Phalcon_ADR_Kernel_HttpKernel); ZEPHIR_INIT(Phalcon_ADR_Middleware_CorsMiddleware); ZEPHIR_INIT(Phalcon_ADR_Middleware_MethodOverrideMiddleware); ZEPHIR_INIT(Phalcon_ADR_Middleware_RequestIdMiddleware); @@ -3084,6 +3108,8 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(phalcon_91__closure); ZEPHIR_INIT(phalcon_92__closure); ZEPHIR_INIT(phalcon_93__closure); + ZEPHIR_INIT(phalcon_94__closure); + ZEPHIR_INIT(phalcon_95__closure); ZEPHIR_INIT(phalcon_9__closure); return SUCCESS; diff --git a/ext/phalcon.h b/ext/phalcon.h index ecefe8f3fa..d7f6c4ade0 100644 --- a/ext/phalcon.h +++ b/ext/phalcon.h @@ -71,6 +71,7 @@ #include "phalcon/encryption/security/uuid/uuidinterface.zep.h" #include "phalcon/paginator/exception.zep.h" #include "phalcon/support/exception.zep.h" +#include "phalcon/adr/exceptions/adrthrowable.zep.h" #include "phalcon/assets/assetinterface.zep.h" #include "phalcon/config/configinterface.zep.h" #include "phalcon/contracts/db/adapter/adapter.zep.h" @@ -82,6 +83,7 @@ #include "phalcon/events/exception.zep.h" #include "phalcon/mvc/model/metadatainterface.zep.h" #include "phalcon/storage/exception.zep.h" +#include "phalcon/adr/exceptions/exception.zep.h" #include "phalcon/config/config.zep.h" #include "phalcon/contracts/db/dialect.zep.h" #include "phalcon/contracts/logger/adapter/adapter.zep.h" @@ -97,7 +99,6 @@ #include "phalcon/http/request/exception.zep.h" #include "phalcon/mvc/model/metadata.zep.h" #include "phalcon/paginator/adapter/adapterinterface.zep.h" -#include "phalcon/adr/exceptions/adrthrowable.zep.h" #include "phalcon/annotations/adapter/adapterinterface.zep.h" #include "phalcon/auth/adapter/abstractadapter.zep.h" #include "phalcon/container/definition/processor/processor.zep.h" @@ -128,7 +129,6 @@ #include "phalcon/queue/adapter/abstractproducer.zep.h" #include "phalcon/queue/adapter/abstractsubscriptionconsumer.zep.h" #include "phalcon/translate/adapter/adapterinterface.zep.h" -#include "phalcon/adr/exceptions/exception.zep.h" #include "phalcon/adr/responder/chainresponder.zep.h" #include "phalcon/acl/adapter/adapterinterface.zep.h" #include "phalcon/annotations/adapter/abstractadapter.zep.h" @@ -143,6 +143,7 @@ #include "phalcon/contracts/auth/guard/guard.zep.h" #include "phalcon/contracts/auth/guard/guardconfig.zep.h" #include "phalcon/contracts/cache/cache.zep.h" +#include "phalcon/contracts/container/service/provider.zep.h" #include "phalcon/contracts/encryption/security/uuid/nodeprovider.zep.h" #include "phalcon/contracts/encryption/security/uuid/timebaseduuid.zep.h" #include "phalcon/contracts/forms/schema.zep.h" @@ -186,13 +187,13 @@ #include "phalcon/cache/cacheinterface.zep.h" #include "phalcon/cli/taskinterface.zep.h" #include "phalcon/container/resolver/lazy/env.zep.h" +#include "phalcon/contracts/adr/kernel/kernel.zep.h" #include "phalcon/contracts/adr/responder/formatter/formatter.zep.h" #include "phalcon/contracts/acl/component.zep.h" #include "phalcon/contracts/acl/role.zep.h" #include "phalcon/contracts/cli/dispatcher.zep.h" #include "phalcon/contracts/container/ioc/ioccontainer.zep.h" #include "phalcon/contracts/container/resolver/reflectionparameterresolver.zep.h" -#include "phalcon/contracts/container/service/provider.zep.h" #include "phalcon/contracts/db/check.zep.h" #include "phalcon/contracts/db/column.zep.h" #include "phalcon/contracts/db/index.zep.h" @@ -241,6 +242,7 @@ #include "phalcon/support/helper/str/pascalcase.zep.h" #include "phalcon/time/clock/clockinterface.zep.h" #include "phalcon/translate/interpolator/interpolatorinterface.zep.h" +#include "phalcon/adr/kernel/abstracthttpkernel.zep.h" #include "phalcon/acl/adapter/memory.zep.h" #include "phalcon/acl/componentinterface.zep.h" #include "phalcon/acl/roleinterface.zep.h" @@ -250,7 +252,9 @@ #include "phalcon/cli/router/routeinterface.zep.h" #include "phalcon/cli/routerinterface.zep.h" #include "phalcon/cli/task.zep.h" +#include "phalcon/contracts/adr/application.zep.h" #include "phalcon/contracts/adr/dispatcher.zep.h" +#include "phalcon/contracts/adr/emitter/emitter.zep.h" #include "phalcon/contracts/adr/payload/payload.zep.h" #include "phalcon/contracts/adr/router/group.zep.h" #include "phalcon/contracts/adr/router/route.zep.h" @@ -349,11 +353,18 @@ #include "phalcon/support/collection/exception.zep.h" #include "phalcon/support/debug/exception.zep.h" #include "phalcon/time/clock/exception.zep.h" +#include "phalcon/adr/application.zep.h" +#include "phalcon/adr/container/adrprovider.zep.h" #include "phalcon/adr/dispatcher.zep.h" +#include "phalcon/adr/emitter/exceptions/headersalreadysent.zep.h" +#include "phalcon/adr/emitter/exceptions/outputalreadysent.zep.h" +#include "phalcon/adr/emitter/sapiemitter.zep.h" +#include "phalcon/adr/errorresponder.zep.h" #include "phalcon/adr/eventfulhandler.zep.h" #include "phalcon/adr/events/event.zep.h" #include "phalcon/adr/exceptions/notanaction.zep.h" #include "phalcon/adr/input/input.zep.h" +#include "phalcon/adr/kernel/httpkernel.zep.h" #include "phalcon/adr/middleware/corsmiddleware.zep.h" #include "phalcon/adr/middleware/methodoverridemiddleware.zep.h" #include "phalcon/adr/middleware/requestidmiddleware.zep.h" @@ -1516,5 +1527,7 @@ #include "phalcon/91__closure.zep.h" #include "phalcon/92__closure.zep.h" #include "phalcon/93__closure.zep.h" +#include "phalcon/94__closure.zep.h" +#include "phalcon/95__closure.zep.h" #endif \ No newline at end of file diff --git a/ext/phalcon/10__closure.zep.c b/ext/phalcon/10__closure.zep.c index 87af8b5f4e..50f9e841b0 100644 --- a/ext/phalcon/10__closure.zep.c +++ b/ext/phalcon/10__closure.zep.c @@ -12,15 +12,16 @@ #include #include "kernel/main.h" -#include "kernel/memory.h" #include "kernel/fcall.h" #include "kernel/object.h" +#include "kernel/memory.h" ZEPHIR_INIT_CLASS(phalcon_10__closure) { ZEPHIR_REGISTER_CLASS(phalcon, 10__closure, phalcon, 10__closure, phalcon_10__closure_method_entry, ZEND_ACC_FINAL_CLASS); + zend_declare_property_null(phalcon_10__closure_ce, SL("serviceName"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } @@ -28,24 +29,15 @@ PHP_METHOD(phalcon_10__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *container, container_sub, _0; + zval serviceName; + zval *this_ptr = getThis(); - ZVAL_UNDEF(&container_sub); - ZVAL_UNDEF(&_0); - ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_ZVAL(container) - ZEND_PARSE_PARAMETERS_END(); + ZVAL_UNDEF(&serviceName); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_fetch_params(1, 1, 0, &container); - ZEPHIR_INIT_VAR(&_0); - object_init_ex(&_0, phalcon_filter_filterfactory_ce); - if (zephir_has_constructor(&_0)) { - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 0); - zephir_check_call_status(); - } - - ZEPHIR_RETURN_CALL_METHOD(&_0, "newinstance", NULL, 239); + zephir_read_static_property_ce(&serviceName, phalcon_10__closure_ce, SL("serviceName"), PH_NOISY_CC); + + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "new", NULL, 0, &serviceName); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/10__closure.zep.h b/ext/phalcon/10__closure.zep.h index f6b97d2b8b..e3d5bea176 100644 --- a/ext/phalcon/10__closure.zep.h +++ b/ext/phalcon/10__closure.zep.h @@ -5,11 +5,10 @@ ZEPHIR_INIT_CLASS(phalcon_10__closure); PHP_METHOD(phalcon_10__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_10__closure___invoke, 0, 0, 1) - ZEND_ARG_INFO(0, container) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_10__closure___invoke, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_10__closure_method_entry) { - PHP_ME(phalcon_10__closure, __invoke, arginfo_phalcon_10__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +PHP_ME(phalcon_10__closure, __invoke, arginfo_phalcon_10__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) PHP_FE_END }; diff --git a/ext/phalcon/11__closure.zep.c b/ext/phalcon/11__closure.zep.c index 9e2ac5be8f..5ff6897099 100644 --- a/ext/phalcon/11__closure.zep.c +++ b/ext/phalcon/11__closure.zep.c @@ -12,8 +12,6 @@ #include #include "kernel/main.h" -#include "kernel/fcall.h" -#include "kernel/memory.h" #include "kernel/object.h" @@ -21,25 +19,18 @@ ZEPHIR_INIT_CLASS(phalcon_11__closure) { ZEPHIR_REGISTER_CLASS(phalcon, 11__closure, phalcon, 11__closure, phalcon_11__closure_method_entry, ZEND_ACC_FINAL_CLASS); + zend_declare_property_null(phalcon_11__closure_ce, SL("definition"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } PHP_METHOD(phalcon_11__closure, __invoke) { - zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; - zend_long ZEPHIR_LAST_CALL_STATUS; - zval *container, container_sub; - - ZVAL_UNDEF(&container_sub); - ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_ZVAL(container) - ZEND_PARSE_PARAMETERS_END(); - ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); - zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_fetch_params(1, 1, 0, &container); - object_init_ex(return_value, phalcon_auth_access_accesslocator_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 383, container); - zephir_check_call_status(); - RETURN_MM(); + zval definition; + + ZVAL_UNDEF(&definition); + zephir_read_static_property_ce(&definition, phalcon_11__closure_ce, SL("definition"), PH_NOISY_CC); + + RETVAL_ZVAL(&definition, 1, 0); + return; } diff --git a/ext/phalcon/11__closure.zep.h b/ext/phalcon/11__closure.zep.h index 4bb9d015df..25cecabdca 100644 --- a/ext/phalcon/11__closure.zep.h +++ b/ext/phalcon/11__closure.zep.h @@ -5,11 +5,10 @@ ZEPHIR_INIT_CLASS(phalcon_11__closure); PHP_METHOD(phalcon_11__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_11__closure___invoke, 0, 0, 1) - ZEND_ARG_INFO(0, container) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_11__closure___invoke, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_11__closure_method_entry) { - PHP_ME(phalcon_11__closure, __invoke, arginfo_phalcon_11__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +PHP_ME(phalcon_11__closure, __invoke, arginfo_phalcon_11__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) PHP_FE_END }; diff --git a/ext/phalcon/12__closure.zep.c b/ext/phalcon/12__closure.zep.c index c862888c51..8feaa792af 100644 --- a/ext/phalcon/12__closure.zep.c +++ b/ext/phalcon/12__closure.zep.c @@ -45,7 +45,7 @@ PHP_METHOD(phalcon_12__closure, __invoke) zephir_check_call_status(); } - ZEPHIR_RETURN_CALL_METHOD(&_0, "newinstance", NULL, 239); + ZEPHIR_RETURN_CALL_METHOD(&_0, "newinstance", NULL, 245); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/13__closure.zep.c b/ext/phalcon/13__closure.zep.c index 65f34cb72f..533048daa1 100644 --- a/ext/phalcon/13__closure.zep.c +++ b/ext/phalcon/13__closure.zep.c @@ -38,7 +38,7 @@ PHP_METHOD(phalcon_13__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &container); object_init_ex(return_value, phalcon_auth_access_accesslocator_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 383, container); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 395, container); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/14__closure.zep.c b/ext/phalcon/14__closure.zep.c index b10e724d76..ef722a3b62 100644 --- a/ext/phalcon/14__closure.zep.c +++ b/ext/phalcon/14__closure.zep.c @@ -12,16 +12,15 @@ #include #include "kernel/main.h" +#include "kernel/memory.h" #include "kernel/fcall.h" #include "kernel/object.h" -#include "kernel/memory.h" ZEPHIR_INIT_CLASS(phalcon_14__closure) { ZEPHIR_REGISTER_CLASS(phalcon, 14__closure, phalcon, 14__closure, phalcon_14__closure_method_entry, ZEND_ACC_FINAL_CLASS); - zend_declare_property_null(phalcon_14__closure_ce, SL("ioc"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } @@ -29,24 +28,24 @@ PHP_METHOD(phalcon_14__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval ioc, id, _0; - zval *this_ptr = getThis(); + zval *container, container_sub, _0; - ZVAL_UNDEF(&ioc); - ZVAL_UNDEF(&id); + ZVAL_UNDEF(&container_sub); ZVAL_UNDEF(&_0); - static zend_string *_zephir_prop_0 = NULL; - if (UNEXPECTED(!_zephir_prop_0)) { - _zephir_prop_0 = zend_string_init("id", 2, 1); - } + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(container) + ZEND_PARSE_PARAMETERS_END(); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_static_property_ce(&ioc, phalcon_14__closure_ce, SL("ioc"), PH_NOISY_CC); + zephir_fetch_params(1, 1, 0, &container); + ZEPHIR_INIT_VAR(&_0); + object_init_ex(&_0, phalcon_filter_filterfactory_ce); + if (zephir_has_constructor(&_0)) { + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 0); + zephir_check_call_status(); + } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1361, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(&id, this_ptr, "resolveargument", NULL, 0, &ioc, &_0); - zephir_check_call_status(); - ZEPHIR_RETURN_CALL_METHOD(&ioc, "get", NULL, 0, &id); + ZEPHIR_RETURN_CALL_METHOD(&_0, "newinstance", NULL, 245); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/14__closure.zep.h b/ext/phalcon/14__closure.zep.h index 9fbf55e0c1..b72e468f86 100644 --- a/ext/phalcon/14__closure.zep.h +++ b/ext/phalcon/14__closure.zep.h @@ -5,10 +5,11 @@ ZEPHIR_INIT_CLASS(phalcon_14__closure); PHP_METHOD(phalcon_14__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_14__closure___invoke, 0, 0, 0) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_14__closure___invoke, 0, 0, 1) + ZEND_ARG_INFO(0, container) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_14__closure_method_entry) { -PHP_ME(phalcon_14__closure, __invoke, arginfo_phalcon_14__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) + PHP_ME(phalcon_14__closure, __invoke, arginfo_phalcon_14__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) PHP_FE_END }; diff --git a/ext/phalcon/15__closure.zep.c b/ext/phalcon/15__closure.zep.c index ee325d73d8..cce8e4c0bc 100644 --- a/ext/phalcon/15__closure.zep.c +++ b/ext/phalcon/15__closure.zep.c @@ -13,15 +13,14 @@ #include "kernel/main.h" #include "kernel/fcall.h" -#include "kernel/object.h" #include "kernel/memory.h" +#include "kernel/object.h" ZEPHIR_INIT_CLASS(phalcon_15__closure) { ZEPHIR_REGISTER_CLASS(phalcon, 15__closure, phalcon, 15__closure, phalcon_15__closure_method_entry, ZEND_ACC_FINAL_CLASS); - zend_declare_property_null(phalcon_15__closure_ce, SL("ioc"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } @@ -29,24 +28,17 @@ PHP_METHOD(phalcon_15__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval ioc, id, _0; - zval *this_ptr = getThis(); - - ZVAL_UNDEF(&ioc); - ZVAL_UNDEF(&id); - ZVAL_UNDEF(&_0); - static zend_string *_zephir_prop_0 = NULL; - if (UNEXPECTED(!_zephir_prop_0)) { - _zephir_prop_0 = zend_string_init("id", 2, 1); - } + zval *container, container_sub; + + ZVAL_UNDEF(&container_sub); + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(container) + ZEND_PARSE_PARAMETERS_END(); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_static_property_ce(&ioc, phalcon_15__closure_ce, SL("ioc"), PH_NOISY_CC); - - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1362, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(&id, this_ptr, "resolveargument", NULL, 0, &ioc, &_0); - zephir_check_call_status(); - ZEPHIR_RETURN_CALL_METHOD(&ioc, "new", NULL, 0, &id); + zephir_fetch_params(1, 1, 0, &container); + object_init_ex(return_value, phalcon_auth_access_accesslocator_ce); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 395, container); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/15__closure.zep.h b/ext/phalcon/15__closure.zep.h index 09d474e022..ea3342abc7 100644 --- a/ext/phalcon/15__closure.zep.h +++ b/ext/phalcon/15__closure.zep.h @@ -5,10 +5,11 @@ ZEPHIR_INIT_CLASS(phalcon_15__closure); PHP_METHOD(phalcon_15__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_15__closure___invoke, 0, 0, 0) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_15__closure___invoke, 0, 0, 1) + ZEND_ARG_INFO(0, container) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_15__closure_method_entry) { -PHP_ME(phalcon_15__closure, __invoke, arginfo_phalcon_15__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) + PHP_ME(phalcon_15__closure, __invoke, arginfo_phalcon_15__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) PHP_FE_END }; diff --git a/ext/phalcon/16__closure.zep.c b/ext/phalcon/16__closure.zep.c index 32e33bc87e..5cab79c938 100644 --- a/ext/phalcon/16__closure.zep.c +++ b/ext/phalcon/16__closure.zep.c @@ -12,41 +12,42 @@ #include #include "kernel/main.h" -#include "kernel/memory.h" -#include "kernel/array.h" +#include "kernel/fcall.h" #include "kernel/object.h" +#include "kernel/memory.h" ZEPHIR_INIT_CLASS(phalcon_16__closure) { ZEPHIR_REGISTER_CLASS(phalcon, 16__closure, phalcon, 16__closure, phalcon_16__closure_method_entry, ZEND_ACC_FINAL_CLASS); + zend_declare_property_null(phalcon_16__closure_ce, SL("ioc"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } PHP_METHOD(phalcon_16__closure, __invoke) { - zend_bool _1; zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; - zval *element, element_sub, _0, _2; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval ioc, id, _0; + zval *this_ptr = getThis(); - ZVAL_UNDEF(&element_sub); + ZVAL_UNDEF(&ioc); + ZVAL_UNDEF(&id); ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_2); - ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_ZVAL(element) - ZEND_PARSE_PARAMETERS_END(); + static zend_string *_zephir_prop_0 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("id", 2, 1); + } ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_fetch_params(1, 1, 0, &element); - zephir_memory_observe(&_0); - zephir_array_fetch_long(&_0, element, 0, PH_NOISY, "phalcon/Filter/Validation.zep", 109); - _1 = Z_TYPE_P(&_0) != IS_ARRAY; - if (!(_1)) { - zephir_memory_observe(&_2); - zephir_array_fetch_long(&_2, element, 1, PH_NOISY, "phalcon/Filter/Validation.zep", 109); - _1 = !(zephir_instance_of_ev(&_2, phalcon_filter_validation_abstractcombinedfieldsvalidator_ce)); - } - RETURN_MM_BOOL(_1); + zephir_read_static_property_ce(&ioc, phalcon_16__closure_ce, SL("ioc"), PH_NOISY_CC); + + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1370, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(&id, this_ptr, "resolveargument", NULL, 0, &ioc, &_0); + zephir_check_call_status(); + ZEPHIR_RETURN_CALL_METHOD(&ioc, "get", NULL, 0, &id); + zephir_check_call_status(); + RETURN_MM(); } diff --git a/ext/phalcon/16__closure.zep.h b/ext/phalcon/16__closure.zep.h index b2f66fcac6..c1bca609b8 100644 --- a/ext/phalcon/16__closure.zep.h +++ b/ext/phalcon/16__closure.zep.h @@ -5,11 +5,10 @@ ZEPHIR_INIT_CLASS(phalcon_16__closure); PHP_METHOD(phalcon_16__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_16__closure___invoke, 0, 0, 1) - ZEND_ARG_INFO(0, element) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_16__closure___invoke, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_16__closure_method_entry) { - PHP_ME(phalcon_16__closure, __invoke, arginfo_phalcon_16__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +PHP_ME(phalcon_16__closure, __invoke, arginfo_phalcon_16__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) PHP_FE_END }; diff --git a/ext/phalcon/17__closure.zep.c b/ext/phalcon/17__closure.zep.c index c363710b67..c706ae02d3 100644 --- a/ext/phalcon/17__closure.zep.c +++ b/ext/phalcon/17__closure.zep.c @@ -12,41 +12,42 @@ #include #include "kernel/main.h" -#include "kernel/memory.h" -#include "kernel/array.h" +#include "kernel/fcall.h" #include "kernel/object.h" +#include "kernel/memory.h" ZEPHIR_INIT_CLASS(phalcon_17__closure) { ZEPHIR_REGISTER_CLASS(phalcon, 17__closure, phalcon, 17__closure, phalcon_17__closure_method_entry, ZEND_ACC_FINAL_CLASS); + zend_declare_property_null(phalcon_17__closure_ce, SL("ioc"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } PHP_METHOD(phalcon_17__closure, __invoke) { - zend_bool _1; zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; - zval *element, element_sub, _0, _2; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval ioc, id, _0; + zval *this_ptr = getThis(); - ZVAL_UNDEF(&element_sub); + ZVAL_UNDEF(&ioc); + ZVAL_UNDEF(&id); ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_2); - ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_ZVAL(element) - ZEND_PARSE_PARAMETERS_END(); + static zend_string *_zephir_prop_0 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("id", 2, 1); + } ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_fetch_params(1, 1, 0, &element); - zephir_memory_observe(&_0); - zephir_array_fetch_long(&_0, element, 0, PH_NOISY, "phalcon/Filter/Validation.zep", 116); - _1 = Z_TYPE_P(&_0) == IS_ARRAY; - if (_1) { - zephir_memory_observe(&_2); - zephir_array_fetch_long(&_2, element, 1, PH_NOISY, "phalcon/Filter/Validation.zep", 116); - _1 = zephir_instance_of_ev(&_2, phalcon_filter_validation_abstractcombinedfieldsvalidator_ce); - } - RETURN_MM_BOOL(_1); + zephir_read_static_property_ce(&ioc, phalcon_17__closure_ce, SL("ioc"), PH_NOISY_CC); + + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1371, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(&id, this_ptr, "resolveargument", NULL, 0, &ioc, &_0); + zephir_check_call_status(); + ZEPHIR_RETURN_CALL_METHOD(&ioc, "new", NULL, 0, &id); + zephir_check_call_status(); + RETURN_MM(); } diff --git a/ext/phalcon/17__closure.zep.h b/ext/phalcon/17__closure.zep.h index 83882688b2..9ac9eb109d 100644 --- a/ext/phalcon/17__closure.zep.h +++ b/ext/phalcon/17__closure.zep.h @@ -5,11 +5,10 @@ ZEPHIR_INIT_CLASS(phalcon_17__closure); PHP_METHOD(phalcon_17__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_17__closure___invoke, 0, 0, 1) - ZEND_ARG_INFO(0, element) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_17__closure___invoke, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_17__closure_method_entry) { - PHP_ME(phalcon_17__closure, __invoke, arginfo_phalcon_17__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +PHP_ME(phalcon_17__closure, __invoke, arginfo_phalcon_17__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) PHP_FE_END }; diff --git a/ext/phalcon/18__closure.zep.c b/ext/phalcon/18__closure.zep.c index cc1777a0a2..5c9472495c 100644 --- a/ext/phalcon/18__closure.zep.c +++ b/ext/phalcon/18__closure.zep.c @@ -12,9 +12,8 @@ #include #include "kernel/main.h" -#include "kernel/fcall.h" -#include "kernel/operators.h" #include "kernel/memory.h" +#include "kernel/array.h" #include "kernel/object.h" @@ -27,29 +26,27 @@ ZEPHIR_INIT_CLASS(phalcon_18__closure) PHP_METHOD(phalcon_18__closure, __invoke) { + zend_bool _1; zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; - zend_long ZEPHIR_LAST_CALL_STATUS; - zval options, attributes; - zval *name_param = NULL, *options_param = NULL, *attributes_param = NULL; - zval name; - - ZVAL_UNDEF(&name); - ZVAL_UNDEF(&options); - ZVAL_UNDEF(&attributes); - ZEND_PARSE_PARAMETERS_START(3, 3) - Z_PARAM_ZVAL(name_param) - ZEPHIR_Z_PARAM_ARRAY(options, options_param) - ZEPHIR_Z_PARAM_ARRAY(attributes, attributes_param) + zval *element, element_sub, _0, _2; + + ZVAL_UNDEF(&element_sub); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_2); + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(element) ZEND_PARSE_PARAMETERS_END(); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_fetch_params(1, 3, 0, &name_param, &options_param, &attributes_param); - zephir_get_strval(&name, name_param); - zephir_get_arrval(&options, options_param); - zephir_get_arrval(&attributes, attributes_param); - object_init_ex(return_value, phalcon_forms_element_check_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &attributes); - zephir_check_call_status(); - RETURN_MM(); + zephir_fetch_params(1, 1, 0, &element); + zephir_memory_observe(&_0); + zephir_array_fetch_long(&_0, element, 0, PH_NOISY, "phalcon/Filter/Validation.zep", 109); + _1 = Z_TYPE_P(&_0) != IS_ARRAY; + if (!(_1)) { + zephir_memory_observe(&_2); + zephir_array_fetch_long(&_2, element, 1, PH_NOISY, "phalcon/Filter/Validation.zep", 109); + _1 = !(zephir_instance_of_ev(&_2, phalcon_filter_validation_abstractcombinedfieldsvalidator_ce)); + } + RETURN_MM_BOOL(_1); } diff --git a/ext/phalcon/18__closure.zep.h b/ext/phalcon/18__closure.zep.h index 4a84e93570..03a0d15e68 100644 --- a/ext/phalcon/18__closure.zep.h +++ b/ext/phalcon/18__closure.zep.h @@ -5,10 +5,8 @@ ZEPHIR_INIT_CLASS(phalcon_18__closure); PHP_METHOD(phalcon_18__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_18__closure___invoke, 0, 0, 3) - ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) - ZEND_ARG_ARRAY_INFO(0, options, 0) - ZEND_ARG_ARRAY_INFO(0, attributes, 0) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_18__closure___invoke, 0, 0, 1) + ZEND_ARG_INFO(0, element) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_18__closure_method_entry) { diff --git a/ext/phalcon/19__closure.zep.c b/ext/phalcon/19__closure.zep.c index 153934d06d..cb1d51f3da 100644 --- a/ext/phalcon/19__closure.zep.c +++ b/ext/phalcon/19__closure.zep.c @@ -12,9 +12,8 @@ #include #include "kernel/main.h" -#include "kernel/fcall.h" -#include "kernel/operators.h" #include "kernel/memory.h" +#include "kernel/array.h" #include "kernel/object.h" @@ -27,29 +26,27 @@ ZEPHIR_INIT_CLASS(phalcon_19__closure) PHP_METHOD(phalcon_19__closure, __invoke) { + zend_bool _1; zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; - zend_long ZEPHIR_LAST_CALL_STATUS; - zval options, attributes; - zval *name_param = NULL, *options_param = NULL, *attributes_param = NULL; - zval name; - - ZVAL_UNDEF(&name); - ZVAL_UNDEF(&options); - ZVAL_UNDEF(&attributes); - ZEND_PARSE_PARAMETERS_START(3, 3) - Z_PARAM_ZVAL(name_param) - ZEPHIR_Z_PARAM_ARRAY(options, options_param) - ZEPHIR_Z_PARAM_ARRAY(attributes, attributes_param) + zval *element, element_sub, _0, _2; + + ZVAL_UNDEF(&element_sub); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_2); + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(element) ZEND_PARSE_PARAMETERS_END(); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_fetch_params(1, 3, 0, &name_param, &options_param, &attributes_param); - zephir_get_strval(&name, name_param); - zephir_get_arrval(&options, options_param); - zephir_get_arrval(&attributes, attributes_param); - object_init_ex(return_value, phalcon_forms_element_checkgroup_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &options, &attributes); - zephir_check_call_status(); - RETURN_MM(); + zephir_fetch_params(1, 1, 0, &element); + zephir_memory_observe(&_0); + zephir_array_fetch_long(&_0, element, 0, PH_NOISY, "phalcon/Filter/Validation.zep", 116); + _1 = Z_TYPE_P(&_0) == IS_ARRAY; + if (_1) { + zephir_memory_observe(&_2); + zephir_array_fetch_long(&_2, element, 1, PH_NOISY, "phalcon/Filter/Validation.zep", 116); + _1 = zephir_instance_of_ev(&_2, phalcon_filter_validation_abstractcombinedfieldsvalidator_ce); + } + RETURN_MM_BOOL(_1); } diff --git a/ext/phalcon/19__closure.zep.h b/ext/phalcon/19__closure.zep.h index a2028ae102..7cb7ed35dc 100644 --- a/ext/phalcon/19__closure.zep.h +++ b/ext/phalcon/19__closure.zep.h @@ -5,10 +5,8 @@ ZEPHIR_INIT_CLASS(phalcon_19__closure); PHP_METHOD(phalcon_19__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_19__closure___invoke, 0, 0, 3) - ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) - ZEND_ARG_ARRAY_INFO(0, options, 0) - ZEND_ARG_ARRAY_INFO(0, attributes, 0) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_19__closure___invoke, 0, 0, 1) + ZEND_ARG_INFO(0, element) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_19__closure_method_entry) { diff --git a/ext/phalcon/20__closure.zep.c b/ext/phalcon/20__closure.zep.c index b216e4d16e..db6568bda8 100644 --- a/ext/phalcon/20__closure.zep.c +++ b/ext/phalcon/20__closure.zep.c @@ -47,7 +47,7 @@ PHP_METHOD(phalcon_20__closure, __invoke) zephir_get_strval(&name, name_param); zephir_get_arrval(&options, options_param); zephir_get_arrval(&attributes, attributes_param); - object_init_ex(return_value, phalcon_forms_element_date_ce); + object_init_ex(return_value, phalcon_forms_element_check_ce); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &attributes); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/21__closure.zep.c b/ext/phalcon/21__closure.zep.c index 959a6b2235..e676f1f245 100644 --- a/ext/phalcon/21__closure.zep.c +++ b/ext/phalcon/21__closure.zep.c @@ -47,8 +47,8 @@ PHP_METHOD(phalcon_21__closure, __invoke) zephir_get_strval(&name, name_param); zephir_get_arrval(&options, options_param); zephir_get_arrval(&attributes, attributes_param); - object_init_ex(return_value, phalcon_forms_element_email_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &attributes); + object_init_ex(return_value, phalcon_forms_element_checkgroup_ce); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &options, &attributes); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/22__closure.zep.c b/ext/phalcon/22__closure.zep.c index fc4dacf8d7..1edebc2862 100644 --- a/ext/phalcon/22__closure.zep.c +++ b/ext/phalcon/22__closure.zep.c @@ -47,7 +47,7 @@ PHP_METHOD(phalcon_22__closure, __invoke) zephir_get_strval(&name, name_param); zephir_get_arrval(&options, options_param); zephir_get_arrval(&attributes, attributes_param); - object_init_ex(return_value, phalcon_forms_element_file_ce); + object_init_ex(return_value, phalcon_forms_element_date_ce); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &attributes); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/23__closure.zep.c b/ext/phalcon/23__closure.zep.c index 97a22fd8fe..6a47da086b 100644 --- a/ext/phalcon/23__closure.zep.c +++ b/ext/phalcon/23__closure.zep.c @@ -47,7 +47,7 @@ PHP_METHOD(phalcon_23__closure, __invoke) zephir_get_strval(&name, name_param); zephir_get_arrval(&options, options_param); zephir_get_arrval(&attributes, attributes_param); - object_init_ex(return_value, phalcon_forms_element_hidden_ce); + object_init_ex(return_value, phalcon_forms_element_email_ce); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &attributes); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/24__closure.zep.c b/ext/phalcon/24__closure.zep.c index 9af8ef45e6..6a8d2d1eb4 100644 --- a/ext/phalcon/24__closure.zep.c +++ b/ext/phalcon/24__closure.zep.c @@ -47,7 +47,7 @@ PHP_METHOD(phalcon_24__closure, __invoke) zephir_get_strval(&name, name_param); zephir_get_arrval(&options, options_param); zephir_get_arrval(&attributes, attributes_param); - object_init_ex(return_value, phalcon_forms_element_numeric_ce); + object_init_ex(return_value, phalcon_forms_element_file_ce); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &attributes); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/25__closure.zep.c b/ext/phalcon/25__closure.zep.c index 77e07a948b..a8173dc2dc 100644 --- a/ext/phalcon/25__closure.zep.c +++ b/ext/phalcon/25__closure.zep.c @@ -47,7 +47,7 @@ PHP_METHOD(phalcon_25__closure, __invoke) zephir_get_strval(&name, name_param); zephir_get_arrval(&options, options_param); zephir_get_arrval(&attributes, attributes_param); - object_init_ex(return_value, phalcon_forms_element_password_ce); + object_init_ex(return_value, phalcon_forms_element_hidden_ce); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &attributes); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/26__closure.zep.c b/ext/phalcon/26__closure.zep.c index ed5399c3ea..e6c5172570 100644 --- a/ext/phalcon/26__closure.zep.c +++ b/ext/phalcon/26__closure.zep.c @@ -47,7 +47,7 @@ PHP_METHOD(phalcon_26__closure, __invoke) zephir_get_strval(&name, name_param); zephir_get_arrval(&options, options_param); zephir_get_arrval(&attributes, attributes_param); - object_init_ex(return_value, phalcon_forms_element_radio_ce); + object_init_ex(return_value, phalcon_forms_element_numeric_ce); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &attributes); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/27__closure.zep.c b/ext/phalcon/27__closure.zep.c index 4211beb253..c0e3385109 100644 --- a/ext/phalcon/27__closure.zep.c +++ b/ext/phalcon/27__closure.zep.c @@ -47,8 +47,8 @@ PHP_METHOD(phalcon_27__closure, __invoke) zephir_get_strval(&name, name_param); zephir_get_arrval(&options, options_param); zephir_get_arrval(&attributes, attributes_param); - object_init_ex(return_value, phalcon_forms_element_radiogroup_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &options, &attributes); + object_init_ex(return_value, phalcon_forms_element_password_ce); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &attributes); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/28__closure.zep.c b/ext/phalcon/28__closure.zep.c index 1a85ab0647..94288852b8 100644 --- a/ext/phalcon/28__closure.zep.c +++ b/ext/phalcon/28__closure.zep.c @@ -47,8 +47,8 @@ PHP_METHOD(phalcon_28__closure, __invoke) zephir_get_strval(&name, name_param); zephir_get_arrval(&options, options_param); zephir_get_arrval(&attributes, attributes_param); - object_init_ex(return_value, phalcon_forms_element_select_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &options, &attributes); + object_init_ex(return_value, phalcon_forms_element_radio_ce); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &attributes); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/29__closure.zep.c b/ext/phalcon/29__closure.zep.c index 6df198e170..c61747eda4 100644 --- a/ext/phalcon/29__closure.zep.c +++ b/ext/phalcon/29__closure.zep.c @@ -47,8 +47,8 @@ PHP_METHOD(phalcon_29__closure, __invoke) zephir_get_strval(&name, name_param); zephir_get_arrval(&options, options_param); zephir_get_arrval(&attributes, attributes_param); - object_init_ex(return_value, phalcon_forms_element_submit_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &attributes); + object_init_ex(return_value, phalcon_forms_element_radiogroup_ce); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &options, &attributes); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/30__closure.zep.c b/ext/phalcon/30__closure.zep.c index 40cdda11da..fea06a678b 100644 --- a/ext/phalcon/30__closure.zep.c +++ b/ext/phalcon/30__closure.zep.c @@ -47,8 +47,8 @@ PHP_METHOD(phalcon_30__closure, __invoke) zephir_get_strval(&name, name_param); zephir_get_arrval(&options, options_param); zephir_get_arrval(&attributes, attributes_param); - object_init_ex(return_value, phalcon_forms_element_text_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &attributes); + object_init_ex(return_value, phalcon_forms_element_select_ce); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &options, &attributes); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/31__closure.zep.c b/ext/phalcon/31__closure.zep.c index b644c53f76..fc4111b195 100644 --- a/ext/phalcon/31__closure.zep.c +++ b/ext/phalcon/31__closure.zep.c @@ -47,7 +47,7 @@ PHP_METHOD(phalcon_31__closure, __invoke) zephir_get_strval(&name, name_param); zephir_get_arrval(&options, options_param); zephir_get_arrval(&attributes, attributes_param); - object_init_ex(return_value, phalcon_forms_element_textarea_ce); + object_init_ex(return_value, phalcon_forms_element_submit_ce); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &attributes); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/32__closure.zep.c b/ext/phalcon/32__closure.zep.c index 4491ce8bc7..fc0a19c034 100644 --- a/ext/phalcon/32__closure.zep.c +++ b/ext/phalcon/32__closure.zep.c @@ -12,8 +12,9 @@ #include #include "kernel/main.h" -#include "kernel/memory.h" #include "kernel/fcall.h" +#include "kernel/operators.h" +#include "kernel/memory.h" #include "kernel/object.h" @@ -21,8 +22,6 @@ ZEPHIR_INIT_CLASS(phalcon_32__closure) { ZEPHIR_REGISTER_CLASS(phalcon, 32__closure, phalcon, 32__closure, phalcon_32__closure_method_entry, ZEND_ACC_FINAL_CLASS); - zend_declare_property_null(phalcon_32__closure_ce, SL("schema"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); - zend_declare_property_null(phalcon_32__closure_ce, SL("locator"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } @@ -30,25 +29,26 @@ PHP_METHOD(phalcon_32__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval schema, locator, *e, e_sub, _0; - - ZVAL_UNDEF(&schema); - ZVAL_UNDEF(&locator); - ZVAL_UNDEF(&e_sub); - ZVAL_UNDEF(&_0); - ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_ZVAL(e) + zval options, attributes; + zval *name_param = NULL, *options_param = NULL, *attributes_param = NULL; + zval name; + + ZVAL_UNDEF(&name); + ZVAL_UNDEF(&options); + ZVAL_UNDEF(&attributes); + ZEND_PARSE_PARAMETERS_START(3, 3) + Z_PARAM_ZVAL(name_param) + ZEPHIR_Z_PARAM_ARRAY(options, options_param) + ZEPHIR_Z_PARAM_ARRAY(attributes, attributes_param) ZEND_PARSE_PARAMETERS_END(); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_static_property_ce(&locator, phalcon_32__closure_ce, SL("locator"), PH_NOISY_CC); - zephir_read_static_property_ce(&schema, phalcon_32__closure_ce, SL("schema"), PH_NOISY_CC); - zephir_fetch_params(1, 1, 0, &e); - ZEPHIR_INIT_VAR(&_0); - object_init_ex(&_0, phalcon_forms_form_ce); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 0, e); - zephir_check_call_status(); - ZEPHIR_RETURN_CALL_METHOD(&_0, "load", NULL, 0, &schema, &locator); + zephir_fetch_params(1, 3, 0, &name_param, &options_param, &attributes_param); + zephir_get_strval(&name, name_param); + zephir_get_arrval(&options, options_param); + zephir_get_arrval(&attributes, attributes_param); + object_init_ex(return_value, phalcon_forms_element_text_ce); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &attributes); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/32__closure.zep.h b/ext/phalcon/32__closure.zep.h index e73fe8a775..c4b1ac162f 100644 --- a/ext/phalcon/32__closure.zep.h +++ b/ext/phalcon/32__closure.zep.h @@ -5,8 +5,10 @@ ZEPHIR_INIT_CLASS(phalcon_32__closure); PHP_METHOD(phalcon_32__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_32__closure___invoke, 0, 0, 1) - ZEND_ARG_INFO(0, e) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_32__closure___invoke, 0, 0, 3) + ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) + ZEND_ARG_ARRAY_INFO(0, options, 0) + ZEND_ARG_ARRAY_INFO(0, attributes, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_32__closure_method_entry) { diff --git a/ext/phalcon/33__closure.zep.c b/ext/phalcon/33__closure.zep.c index 32862da22a..027e493386 100644 --- a/ext/phalcon/33__closure.zep.c +++ b/ext/phalcon/33__closure.zep.c @@ -13,6 +13,7 @@ #include "kernel/main.h" #include "kernel/fcall.h" +#include "kernel/operators.h" #include "kernel/memory.h" #include "kernel/object.h" @@ -21,7 +22,6 @@ ZEPHIR_INIT_CLASS(phalcon_33__closure) { ZEPHIR_REGISTER_CLASS(phalcon, 33__closure, phalcon, 33__closure, phalcon_33__closure_method_entry, ZEND_ACC_FINAL_CLASS); - zend_declare_property_null(phalcon_33__closure_ce, SL("escaper"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } @@ -29,22 +29,26 @@ PHP_METHOD(phalcon_33__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval escaper, _0, _1; - zval *this_ptr = getThis(); - - ZVAL_UNDEF(&escaper); - ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_1); + zval options, attributes; + zval *name_param = NULL, *options_param = NULL, *attributes_param = NULL; + zval name; + + ZVAL_UNDEF(&name); + ZVAL_UNDEF(&options); + ZVAL_UNDEF(&attributes); + ZEND_PARSE_PARAMETERS_START(3, 3) + Z_PARAM_ZVAL(name_param) + ZEPHIR_Z_PARAM_ARRAY(options, options_param) + ZEPHIR_Z_PARAM_ARRAY(attributes, attributes_param) + ZEND_PARSE_PARAMETERS_END(); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_static_property_ce(&escaper, phalcon_33__closure_ce, SL("escaper"), PH_NOISY_CC); - - object_init_ex(return_value, phalcon_html_helper_anchor_ce); - ZEPHIR_INIT_VAR(&_1); - ZVAL_STRING(&_1, "doctype"); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); - zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); + zephir_fetch_params(1, 3, 0, &name_param, &options_param, &attributes_param); + zephir_get_strval(&name, name_param); + zephir_get_arrval(&options, options_param); + zephir_get_arrval(&attributes, attributes_param); + object_init_ex(return_value, phalcon_forms_element_textarea_ce); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &name, &attributes); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/33__closure.zep.h b/ext/phalcon/33__closure.zep.h index 7fde18dbe2..b7ceaa6a55 100644 --- a/ext/phalcon/33__closure.zep.h +++ b/ext/phalcon/33__closure.zep.h @@ -5,10 +5,13 @@ ZEPHIR_INIT_CLASS(phalcon_33__closure); PHP_METHOD(phalcon_33__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_33__closure___invoke, 0, 0, 0) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_33__closure___invoke, 0, 0, 3) + ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) + ZEND_ARG_ARRAY_INFO(0, options, 0) + ZEND_ARG_ARRAY_INFO(0, attributes, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_33__closure_method_entry) { -PHP_ME(phalcon_33__closure, __invoke, arginfo_phalcon_33__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) + PHP_ME(phalcon_33__closure, __invoke, arginfo_phalcon_33__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) PHP_FE_END }; diff --git a/ext/phalcon/34__closure.zep.c b/ext/phalcon/34__closure.zep.c index 84f7200e58..054a76c577 100644 --- a/ext/phalcon/34__closure.zep.c +++ b/ext/phalcon/34__closure.zep.c @@ -12,8 +12,8 @@ #include #include "kernel/main.h" -#include "kernel/fcall.h" #include "kernel/memory.h" +#include "kernel/fcall.h" #include "kernel/object.h" @@ -21,7 +21,8 @@ ZEPHIR_INIT_CLASS(phalcon_34__closure) { ZEPHIR_REGISTER_CLASS(phalcon, 34__closure, phalcon, 34__closure, phalcon_34__closure_method_entry, ZEND_ACC_FINAL_CLASS); - zend_declare_property_null(phalcon_34__closure_ce, SL("escaper"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); + zend_declare_property_null(phalcon_34__closure_ce, SL("schema"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); + zend_declare_property_null(phalcon_34__closure_ce, SL("locator"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } @@ -29,24 +30,25 @@ PHP_METHOD(phalcon_34__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval escaper, _0, _1, _2; - zval *this_ptr = getThis(); + zval schema, locator, *e, e_sub, _0; - ZVAL_UNDEF(&escaper); + ZVAL_UNDEF(&schema); + ZVAL_UNDEF(&locator); + ZVAL_UNDEF(&e_sub); ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_1); - ZVAL_UNDEF(&_2); + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(e) + ZEND_PARSE_PARAMETERS_END(); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_static_property_ce(&escaper, phalcon_34__closure_ce, SL("escaper"), PH_NOISY_CC); - - object_init_ex(return_value, phalcon_html_helper_anchor_ce); - ZEPHIR_INIT_VAR(&_1); - ZVAL_STRING(&_1, "doctype"); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); + zephir_read_static_property_ce(&locator, phalcon_34__closure_ce, SL("locator"), PH_NOISY_CC); + zephir_read_static_property_ce(&schema, phalcon_34__closure_ce, SL("schema"), PH_NOISY_CC); + zephir_fetch_params(1, 1, 0, &e); + ZEPHIR_INIT_VAR(&_0); + object_init_ex(&_0, phalcon_forms_form_ce); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 0, e); zephir_check_call_status(); - ZVAL_BOOL(&_2, 1); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_2); + ZEPHIR_RETURN_CALL_METHOD(&_0, "load", NULL, 0, &schema, &locator); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/34__closure.zep.h b/ext/phalcon/34__closure.zep.h index 676f6ac2a4..c42dc9a9c7 100644 --- a/ext/phalcon/34__closure.zep.h +++ b/ext/phalcon/34__closure.zep.h @@ -5,10 +5,11 @@ ZEPHIR_INIT_CLASS(phalcon_34__closure); PHP_METHOD(phalcon_34__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_34__closure___invoke, 0, 0, 0) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_34__closure___invoke, 0, 0, 1) + ZEND_ARG_INFO(0, e) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_34__closure_method_entry) { -PHP_ME(phalcon_34__closure, __invoke, arginfo_phalcon_34__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) + PHP_ME(phalcon_34__closure, __invoke, arginfo_phalcon_34__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) PHP_FE_END }; diff --git a/ext/phalcon/35__closure.zep.c b/ext/phalcon/35__closure.zep.c index 618521d78b..a07ea6ba73 100644 --- a/ext/phalcon/35__closure.zep.c +++ b/ext/phalcon/35__closure.zep.c @@ -39,7 +39,7 @@ PHP_METHOD(phalcon_35__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_35__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_base_ce); + object_init_ex(return_value, phalcon_html_helper_anchor_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); diff --git a/ext/phalcon/36__closure.zep.c b/ext/phalcon/36__closure.zep.c index 5234586e3a..4d91f4df5b 100644 --- a/ext/phalcon/36__closure.zep.c +++ b/ext/phalcon/36__closure.zep.c @@ -29,22 +29,24 @@ PHP_METHOD(phalcon_36__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval escaper, _0, _1; + zval escaper, _0, _1, _2; zval *this_ptr = getThis(); ZVAL_UNDEF(&escaper); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_36__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_body_ce); + object_init_ex(return_value, phalcon_html_helper_anchor_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); + ZVAL_BOOL(&_2, 1); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_2); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/37__closure.zep.c b/ext/phalcon/37__closure.zep.c index 6ebfe52317..b79735320a 100644 --- a/ext/phalcon/37__closure.zep.c +++ b/ext/phalcon/37__closure.zep.c @@ -13,8 +13,8 @@ #include "kernel/main.h" #include "kernel/fcall.h" -#include "kernel/object.h" #include "kernel/memory.h" +#include "kernel/object.h" ZEPHIR_INIT_CLASS(phalcon_37__closure) @@ -22,7 +22,6 @@ ZEPHIR_INIT_CLASS(phalcon_37__closure) ZEPHIR_REGISTER_CLASS(phalcon, 37__closure, phalcon, 37__closure, phalcon_37__closure_method_entry, ZEND_ACC_FINAL_CLASS); zend_declare_property_null(phalcon_37__closure_ce, SL("escaper"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); - zend_declare_property_null(phalcon_37__closure_ce, SL("url"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } @@ -30,17 +29,22 @@ PHP_METHOD(phalcon_37__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval escaper, url; + zval escaper, _0, _1; + zval *this_ptr = getThis(); ZVAL_UNDEF(&escaper); - ZVAL_UNDEF(&url); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_static_property_ce(&url, phalcon_37__closure_ce, SL("url"), PH_NOISY_CC); zephir_read_static_property_ce(&escaper, phalcon_37__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_breadcrumbs_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &url); + object_init_ex(return_value, phalcon_html_helper_base_ce); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "doctype"); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); + zephir_check_call_status(); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/38__closure.zep.c b/ext/phalcon/38__closure.zep.c index 3b8945e84a..6ae232355c 100644 --- a/ext/phalcon/38__closure.zep.c +++ b/ext/phalcon/38__closure.zep.c @@ -39,7 +39,7 @@ PHP_METHOD(phalcon_38__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_38__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_button_ce); + object_init_ex(return_value, phalcon_html_helper_body_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); diff --git a/ext/phalcon/39__closure.zep.c b/ext/phalcon/39__closure.zep.c index d543e70081..381db94a5c 100644 --- a/ext/phalcon/39__closure.zep.c +++ b/ext/phalcon/39__closure.zep.c @@ -13,8 +13,8 @@ #include "kernel/main.h" #include "kernel/fcall.h" -#include "kernel/memory.h" #include "kernel/object.h" +#include "kernel/memory.h" ZEPHIR_INIT_CLASS(phalcon_39__closure) @@ -22,6 +22,7 @@ ZEPHIR_INIT_CLASS(phalcon_39__closure) ZEPHIR_REGISTER_CLASS(phalcon, 39__closure, phalcon, 39__closure, phalcon_39__closure_method_entry, ZEND_ACC_FINAL_CLASS); zend_declare_property_null(phalcon_39__closure_ce, SL("escaper"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); + zend_declare_property_null(phalcon_39__closure_ce, SL("url"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } @@ -29,24 +30,17 @@ PHP_METHOD(phalcon_39__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval escaper, _0, _1, _2; - zval *this_ptr = getThis(); + zval escaper, url; ZVAL_UNDEF(&escaper); - ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_1); - ZVAL_UNDEF(&_2); + ZVAL_UNDEF(&url); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + zephir_read_static_property_ce(&url, phalcon_39__closure_ce, SL("url"), PH_NOISY_CC); zephir_read_static_property_ce(&escaper, phalcon_39__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_button_ce); - ZEPHIR_INIT_VAR(&_1); - ZVAL_STRING(&_1, "doctype"); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); - zephir_check_call_status(); - ZVAL_BOOL(&_2, 1); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_2); + object_init_ex(return_value, phalcon_html_helper_breadcrumbs_ce); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &url); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/40__closure.zep.c b/ext/phalcon/40__closure.zep.c index 1560adfb0a..d8cc2baecb 100644 --- a/ext/phalcon/40__closure.zep.c +++ b/ext/phalcon/40__closure.zep.c @@ -39,7 +39,7 @@ PHP_METHOD(phalcon_40__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_40__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_close_ce); + object_init_ex(return_value, phalcon_html_helper_button_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); diff --git a/ext/phalcon/41__closure.zep.c b/ext/phalcon/41__closure.zep.c index f7406e6625..282af61d11 100644 --- a/ext/phalcon/41__closure.zep.c +++ b/ext/phalcon/41__closure.zep.c @@ -12,6 +12,8 @@ #include #include "kernel/main.h" +#include "kernel/fcall.h" +#include "kernel/memory.h" #include "kernel/object.h" @@ -19,12 +21,33 @@ ZEPHIR_INIT_CLASS(phalcon_41__closure) { ZEPHIR_REGISTER_CLASS(phalcon, 41__closure, phalcon, 41__closure, phalcon_41__closure_method_entry, ZEND_ACC_FINAL_CLASS); + zend_declare_property_null(phalcon_41__closure_ce, SL("escaper"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } PHP_METHOD(phalcon_41__closure, __invoke) { - - RETURN_MEMBER(getThis(), "doctype"); + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval escaper, _0, _1, _2; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&escaper); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + zephir_read_static_property_ce(&escaper, phalcon_41__closure_ce, SL("escaper"), PH_NOISY_CC); + + object_init_ex(return_value, phalcon_html_helper_button_ce); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "doctype"); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); + zephir_check_call_status(); + ZVAL_BOOL(&_2, 1); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_2); + zephir_check_call_status(); + RETURN_MM(); } diff --git a/ext/phalcon/42__closure.zep.c b/ext/phalcon/42__closure.zep.c index 286ea09f58..6015654015 100644 --- a/ext/phalcon/42__closure.zep.c +++ b/ext/phalcon/42__closure.zep.c @@ -39,7 +39,7 @@ PHP_METHOD(phalcon_42__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_42__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_element_ce); + object_init_ex(return_value, phalcon_html_helper_close_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); diff --git a/ext/phalcon/43__closure.zep.c b/ext/phalcon/43__closure.zep.c index 0f5e06305e..f3ff0ac1d8 100644 --- a/ext/phalcon/43__closure.zep.c +++ b/ext/phalcon/43__closure.zep.c @@ -12,8 +12,6 @@ #include #include "kernel/main.h" -#include "kernel/fcall.h" -#include "kernel/memory.h" #include "kernel/object.h" @@ -21,33 +19,12 @@ ZEPHIR_INIT_CLASS(phalcon_43__closure) { ZEPHIR_REGISTER_CLASS(phalcon, 43__closure, phalcon, 43__closure, phalcon_43__closure_method_entry, ZEND_ACC_FINAL_CLASS); - zend_declare_property_null(phalcon_43__closure_ce, SL("escaper"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } PHP_METHOD(phalcon_43__closure, __invoke) { - zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; - zend_long ZEPHIR_LAST_CALL_STATUS; - zval escaper, _0, _1, _2; - zval *this_ptr = getThis(); - - ZVAL_UNDEF(&escaper); - ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_1); - ZVAL_UNDEF(&_2); - ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); - zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_static_property_ce(&escaper, phalcon_43__closure_ce, SL("escaper"), PH_NOISY_CC); - - object_init_ex(return_value, phalcon_html_helper_element_ce); - ZEPHIR_INIT_VAR(&_1); - ZVAL_STRING(&_1, "doctype"); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); - zephir_check_call_status(); - ZVAL_BOOL(&_2, 1); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_2); - zephir_check_call_status(); - RETURN_MM(); + + RETURN_MEMBER(getThis(), "doctype"); } diff --git a/ext/phalcon/44__closure.zep.c b/ext/phalcon/44__closure.zep.c index 7896e8b9d2..0ba309eb2b 100644 --- a/ext/phalcon/44__closure.zep.c +++ b/ext/phalcon/44__closure.zep.c @@ -39,7 +39,7 @@ PHP_METHOD(phalcon_44__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_44__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_form_ce); + object_init_ex(return_value, phalcon_html_helper_element_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); diff --git a/ext/phalcon/45__closure.zep.c b/ext/phalcon/45__closure.zep.c index 6bcf0af1ab..18722a65ef 100644 --- a/ext/phalcon/45__closure.zep.c +++ b/ext/phalcon/45__closure.zep.c @@ -13,8 +13,8 @@ #include "kernel/main.h" #include "kernel/fcall.h" -#include "kernel/object.h" #include "kernel/memory.h" +#include "kernel/object.h" ZEPHIR_INIT_CLASS(phalcon_45__closure) @@ -29,15 +29,24 @@ PHP_METHOD(phalcon_45__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval escaper; + zval escaper, _0, _1, _2; + zval *this_ptr = getThis(); ZVAL_UNDEF(&escaper); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_45__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_friendlytitle_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper); + object_init_ex(return_value, phalcon_html_helper_element_ce); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "doctype"); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); + zephir_check_call_status(); + ZVAL_BOOL(&_2, 1); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_2); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/46__closure.zep.c b/ext/phalcon/46__closure.zep.c index d848e7f806..23733a689a 100644 --- a/ext/phalcon/46__closure.zep.c +++ b/ext/phalcon/46__closure.zep.c @@ -39,7 +39,7 @@ PHP_METHOD(phalcon_46__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_46__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_img_ce); + object_init_ex(return_value, phalcon_html_helper_form_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); diff --git a/ext/phalcon/47__closure.zep.c b/ext/phalcon/47__closure.zep.c index 154e5ccfb6..8060a35857 100644 --- a/ext/phalcon/47__closure.zep.c +++ b/ext/phalcon/47__closure.zep.c @@ -13,8 +13,8 @@ #include "kernel/main.h" #include "kernel/fcall.h" -#include "kernel/memory.h" #include "kernel/object.h" +#include "kernel/memory.h" ZEPHIR_INIT_CLASS(phalcon_47__closure) @@ -29,22 +29,15 @@ PHP_METHOD(phalcon_47__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval escaper, _0, _1; - zval *this_ptr = getThis(); + zval escaper; ZVAL_UNDEF(&escaper); - ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_1); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_47__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_input_checkbox_ce); - ZEPHIR_INIT_VAR(&_1); - ZVAL_STRING(&_1, "doctype"); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); - zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); + object_init_ex(return_value, phalcon_html_helper_friendlytitle_ce); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/48__closure.zep.c b/ext/phalcon/48__closure.zep.c index 81564244c1..f32ac68174 100644 --- a/ext/phalcon/48__closure.zep.c +++ b/ext/phalcon/48__closure.zep.c @@ -39,7 +39,7 @@ PHP_METHOD(phalcon_48__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_48__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_input_checkboxgroup_ce); + object_init_ex(return_value, phalcon_html_helper_img_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); diff --git a/ext/phalcon/49__closure.zep.c b/ext/phalcon/49__closure.zep.c index 054bd25e30..af1d3f6a15 100644 --- a/ext/phalcon/49__closure.zep.c +++ b/ext/phalcon/49__closure.zep.c @@ -39,14 +39,12 @@ PHP_METHOD(phalcon_49__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_49__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_input_generic_ce); + object_init_ex(return_value, phalcon_html_helper_input_checkbox_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "color"); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/4__closure.zep.c b/ext/phalcon/4__closure.zep.c index 4844ab0459..b465d3ddc2 100644 --- a/ext/phalcon/4__closure.zep.c +++ b/ext/phalcon/4__closure.zep.c @@ -13,6 +13,8 @@ #include "kernel/main.h" #include "kernel/memory.h" +#include "kernel/fcall.h" +#include "kernel/array.h" #include "kernel/object.h" @@ -25,20 +27,35 @@ ZEPHIR_INIT_CLASS(phalcon_4__closure) PHP_METHOD(phalcon_4__closure, __invoke) { - zval *number, number_sub, *message, message_sub, *file, file_sub, *line, line_sub, __$true; - - ZVAL_UNDEF(&number_sub); - ZVAL_UNDEF(&message_sub); - ZVAL_UNDEF(&file_sub); - ZVAL_UNDEF(&line_sub); - ZVAL_BOOL(&__$true, 1); - ZEND_PARSE_PARAMETERS_START(4, 4) - Z_PARAM_ZVAL(number) - Z_PARAM_ZVAL(message) - Z_PARAM_ZVAL(file) - Z_PARAM_ZVAL(line) + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *container, container_sub, adapters, noop, _0; + + ZVAL_UNDEF(&container_sub); + ZVAL_UNDEF(&adapters); + ZVAL_UNDEF(&noop); + ZVAL_UNDEF(&_0); + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(container) ZEND_PARSE_PARAMETERS_END(); - zephir_fetch_params_without_memory_grow(4, 0, &number, &message, &file, &line); - ZEPHIR_GLOBAL(warning).enable = zend_is_true(&__$true); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + zephir_fetch_params(1, 1, 0, &container); + ZEPHIR_INIT_VAR(&noop); + object_init_ex(&noop, phalcon_logger_adapter_noop_ce); + if (zephir_has_constructor(&noop)) { + ZEPHIR_CALL_METHOD(NULL, &noop, "__construct", NULL, 0); + zephir_check_call_status(); + } + + ZEPHIR_INIT_VAR(&adapters); + zephir_create_array(&adapters, 1, 0); + zephir_array_update_string(&adapters, SL("main"), &noop, PH_COPY | PH_SEPARATE); + object_init_ex(return_value, phalcon_logger_logger_ce); + ZEPHIR_INIT_VAR(&_0); + ZVAL_STRING(&_0, "adr"); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &_0, &adapters); + zephir_check_call_status(); + RETURN_MM(); } diff --git a/ext/phalcon/4__closure.zep.h b/ext/phalcon/4__closure.zep.h index ccc9d38ec8..f043cf10e9 100644 --- a/ext/phalcon/4__closure.zep.h +++ b/ext/phalcon/4__closure.zep.h @@ -5,11 +5,8 @@ ZEPHIR_INIT_CLASS(phalcon_4__closure); PHP_METHOD(phalcon_4__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_4__closure___invoke, 0, 0, 4) - ZEND_ARG_INFO(0, number) - ZEND_ARG_INFO(0, message) - ZEND_ARG_INFO(0, file) - ZEND_ARG_INFO(0, line) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_4__closure___invoke, 0, 0, 1) + ZEND_ARG_INFO(0, container) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_4__closure_method_entry) { diff --git a/ext/phalcon/50__closure.zep.c b/ext/phalcon/50__closure.zep.c index 8b124b5f42..64806e7db7 100644 --- a/ext/phalcon/50__closure.zep.c +++ b/ext/phalcon/50__closure.zep.c @@ -39,14 +39,12 @@ PHP_METHOD(phalcon_50__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_50__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_input_generic_ce); + object_init_ex(return_value, phalcon_html_helper_input_checkboxgroup_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "date"); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/51__closure.zep.c b/ext/phalcon/51__closure.zep.c index 643e373ac6..e1b4fdcffa 100644 --- a/ext/phalcon/51__closure.zep.c +++ b/ext/phalcon/51__closure.zep.c @@ -45,7 +45,7 @@ PHP_METHOD(phalcon_51__closure, __invoke) ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "datetime"); + ZVAL_STRING(&_1, "color"); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/52__closure.zep.c b/ext/phalcon/52__closure.zep.c index 9b3427f312..c7c617bac8 100644 --- a/ext/phalcon/52__closure.zep.c +++ b/ext/phalcon/52__closure.zep.c @@ -45,7 +45,7 @@ PHP_METHOD(phalcon_52__closure, __invoke) ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "datetime-local"); + ZVAL_STRING(&_1, "date"); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/53__closure.zep.c b/ext/phalcon/53__closure.zep.c index ce6a7cc0dc..4e85588457 100644 --- a/ext/phalcon/53__closure.zep.c +++ b/ext/phalcon/53__closure.zep.c @@ -45,7 +45,7 @@ PHP_METHOD(phalcon_53__closure, __invoke) ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "email"); + ZVAL_STRING(&_1, "datetime"); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/54__closure.zep.c b/ext/phalcon/54__closure.zep.c index fe3083f7ff..fa2c9b2e9c 100644 --- a/ext/phalcon/54__closure.zep.c +++ b/ext/phalcon/54__closure.zep.c @@ -45,7 +45,7 @@ PHP_METHOD(phalcon_54__closure, __invoke) ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "file"); + ZVAL_STRING(&_1, "datetime-local"); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/55__closure.zep.c b/ext/phalcon/55__closure.zep.c index 70e9e9725b..a82b81fef8 100644 --- a/ext/phalcon/55__closure.zep.c +++ b/ext/phalcon/55__closure.zep.c @@ -45,7 +45,7 @@ PHP_METHOD(phalcon_55__closure, __invoke) ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "hidden"); + ZVAL_STRING(&_1, "email"); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/56__closure.zep.c b/ext/phalcon/56__closure.zep.c index df77414823..5b9efd7480 100644 --- a/ext/phalcon/56__closure.zep.c +++ b/ext/phalcon/56__closure.zep.c @@ -45,7 +45,7 @@ PHP_METHOD(phalcon_56__closure, __invoke) ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "image"); + ZVAL_STRING(&_1, "file"); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/57__closure.zep.c b/ext/phalcon/57__closure.zep.c index 13c6dffed0..d07adc3d63 100644 --- a/ext/phalcon/57__closure.zep.c +++ b/ext/phalcon/57__closure.zep.c @@ -44,7 +44,9 @@ PHP_METHOD(phalcon_57__closure, __invoke) ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); + ZEPHIR_INIT_NVAR(&_1); + ZVAL_STRING(&_1, "hidden"); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/58__closure.zep.c b/ext/phalcon/58__closure.zep.c index f96f527062..f5e05b9e02 100644 --- a/ext/phalcon/58__closure.zep.c +++ b/ext/phalcon/58__closure.zep.c @@ -45,7 +45,7 @@ PHP_METHOD(phalcon_58__closure, __invoke) ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "month"); + ZVAL_STRING(&_1, "image"); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/59__closure.zep.c b/ext/phalcon/59__closure.zep.c index faae8dd935..53c5d01da8 100644 --- a/ext/phalcon/59__closure.zep.c +++ b/ext/phalcon/59__closure.zep.c @@ -44,9 +44,7 @@ PHP_METHOD(phalcon_59__closure, __invoke) ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "number"); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/5__closure.zep.c b/ext/phalcon/5__closure.zep.c index 4a54ebd417..1e6011f2b2 100644 --- a/ext/phalcon/5__closure.zep.c +++ b/ext/phalcon/5__closure.zep.c @@ -21,7 +21,6 @@ ZEPHIR_INIT_CLASS(phalcon_5__closure) { ZEPHIR_REGISTER_CLASS(phalcon, 5__closure, phalcon, 5__closure, phalcon_5__closure_method_entry, ZEND_ACC_FINAL_CLASS); - zend_declare_property_null(phalcon_5__closure_ce, SL("dispatcher"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } @@ -29,19 +28,24 @@ PHP_METHOD(phalcon_5__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval dispatcher, *target, target_sub; + zval *container, container_sub, _0, _1; - ZVAL_UNDEF(&dispatcher); - ZVAL_UNDEF(&target_sub); + ZVAL_UNDEF(&container_sub); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_ZVAL(target) + Z_PARAM_ZVAL(container) ZEND_PARSE_PARAMETERS_END(); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_static_property_ce(&dispatcher, phalcon_5__closure_ce, SL("dispatcher"), PH_NOISY_CC); - zephir_fetch_params(1, 1, 0, &target); - ZEPHIR_CALL_METHOD(NULL, &dispatcher, "forward", NULL, 0, target); + zephir_fetch_params(1, 1, 0, &container); + object_init_ex(return_value, phalcon_adr_dispatcher_ce); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "eventsManager"); + ZEPHIR_CALL_METHOD(&_0, container, "get", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_MM_RESTORE(); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, container, &_0); + zephir_check_call_status(); + RETURN_MM(); } diff --git a/ext/phalcon/5__closure.zep.h b/ext/phalcon/5__closure.zep.h index 4abe26d34c..64c6548e15 100644 --- a/ext/phalcon/5__closure.zep.h +++ b/ext/phalcon/5__closure.zep.h @@ -6,7 +6,7 @@ ZEPHIR_INIT_CLASS(phalcon_5__closure); PHP_METHOD(phalcon_5__closure, __invoke); ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_5__closure___invoke, 0, 0, 1) - ZEND_ARG_INFO(0, target) + ZEND_ARG_INFO(0, container) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_5__closure_method_entry) { diff --git a/ext/phalcon/60__closure.zep.c b/ext/phalcon/60__closure.zep.c index 95941a81bc..4bcae780db 100644 --- a/ext/phalcon/60__closure.zep.c +++ b/ext/phalcon/60__closure.zep.c @@ -45,7 +45,7 @@ PHP_METHOD(phalcon_60__closure, __invoke) ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "password"); + ZVAL_STRING(&_1, "month"); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/61__closure.zep.c b/ext/phalcon/61__closure.zep.c index 59c9e04403..17b9c19f6d 100644 --- a/ext/phalcon/61__closure.zep.c +++ b/ext/phalcon/61__closure.zep.c @@ -39,12 +39,14 @@ PHP_METHOD(phalcon_61__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_61__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_input_radio_ce); + object_init_ex(return_value, phalcon_html_helper_input_generic_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); + ZEPHIR_INIT_NVAR(&_1); + ZVAL_STRING(&_1, "number"); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/62__closure.zep.c b/ext/phalcon/62__closure.zep.c index 700f4b6dfc..0be7e31480 100644 --- a/ext/phalcon/62__closure.zep.c +++ b/ext/phalcon/62__closure.zep.c @@ -39,12 +39,14 @@ PHP_METHOD(phalcon_62__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_62__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_input_radiogroup_ce); + object_init_ex(return_value, phalcon_html_helper_input_generic_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); + ZEPHIR_INIT_NVAR(&_1); + ZVAL_STRING(&_1, "password"); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/63__closure.zep.c b/ext/phalcon/63__closure.zep.c index 6cbe832158..4e55bfb582 100644 --- a/ext/phalcon/63__closure.zep.c +++ b/ext/phalcon/63__closure.zep.c @@ -39,14 +39,12 @@ PHP_METHOD(phalcon_63__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_63__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_input_generic_ce); + object_init_ex(return_value, phalcon_html_helper_input_radio_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "range"); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/64__closure.zep.c b/ext/phalcon/64__closure.zep.c index d903d7f3ef..be97e11da7 100644 --- a/ext/phalcon/64__closure.zep.c +++ b/ext/phalcon/64__closure.zep.c @@ -39,14 +39,12 @@ PHP_METHOD(phalcon_64__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_64__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_input_generic_ce); + object_init_ex(return_value, phalcon_html_helper_input_radiogroup_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "search"); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/65__closure.zep.c b/ext/phalcon/65__closure.zep.c index dca2d975eb..b127a7d864 100644 --- a/ext/phalcon/65__closure.zep.c +++ b/ext/phalcon/65__closure.zep.c @@ -39,12 +39,14 @@ PHP_METHOD(phalcon_65__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_65__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_input_select_ce); + object_init_ex(return_value, phalcon_html_helper_input_generic_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); + ZEPHIR_INIT_NVAR(&_1); + ZVAL_STRING(&_1, "range"); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/66__closure.zep.c b/ext/phalcon/66__closure.zep.c index dfa8b19996..659fe93df1 100644 --- a/ext/phalcon/66__closure.zep.c +++ b/ext/phalcon/66__closure.zep.c @@ -45,7 +45,7 @@ PHP_METHOD(phalcon_66__closure, __invoke) ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "submit"); + ZVAL_STRING(&_1, "search"); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/67__closure.zep.c b/ext/phalcon/67__closure.zep.c index 842e0d87fd..5ef00f3afe 100644 --- a/ext/phalcon/67__closure.zep.c +++ b/ext/phalcon/67__closure.zep.c @@ -39,14 +39,12 @@ PHP_METHOD(phalcon_67__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_67__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_input_generic_ce); + object_init_ex(return_value, phalcon_html_helper_input_select_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "tel"); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/68__closure.zep.c b/ext/phalcon/68__closure.zep.c index 74fd70fc7c..3944fb7b0e 100644 --- a/ext/phalcon/68__closure.zep.c +++ b/ext/phalcon/68__closure.zep.c @@ -45,7 +45,7 @@ PHP_METHOD(phalcon_68__closure, __invoke) ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "text"); + ZVAL_STRING(&_1, "submit"); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/69__closure.zep.c b/ext/phalcon/69__closure.zep.c index d7277decd8..8dbfec412a 100644 --- a/ext/phalcon/69__closure.zep.c +++ b/ext/phalcon/69__closure.zep.c @@ -39,12 +39,14 @@ PHP_METHOD(phalcon_69__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_69__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_input_textarea_ce); + object_init_ex(return_value, phalcon_html_helper_input_generic_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); + ZEPHIR_INIT_NVAR(&_1); + ZVAL_STRING(&_1, "tel"); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/6__closure.zep.c b/ext/phalcon/6__closure.zep.c index 1fcc2e9264..496b3a6124 100644 --- a/ext/phalcon/6__closure.zep.c +++ b/ext/phalcon/6__closure.zep.c @@ -25,13 +25,20 @@ ZEPHIR_INIT_CLASS(phalcon_6__closure) PHP_METHOD(phalcon_6__closure, __invoke) { - zval *file, file_sub; + zval *number, number_sub, *message, message_sub, *file, file_sub, *line, line_sub, __$true; + ZVAL_UNDEF(&number_sub); + ZVAL_UNDEF(&message_sub); ZVAL_UNDEF(&file_sub); - ZEND_PARSE_PARAMETERS_START(1, 1) + ZVAL_UNDEF(&line_sub); + ZVAL_BOOL(&__$true, 1); + ZEND_PARSE_PARAMETERS_START(4, 4) + Z_PARAM_ZVAL(number) + Z_PARAM_ZVAL(message) Z_PARAM_ZVAL(file) + Z_PARAM_ZVAL(line) ZEND_PARSE_PARAMETERS_END(); - zephir_fetch_params_without_memory_grow(1, 0, &file); - RETURN_BOOL(1); + zephir_fetch_params_without_memory_grow(4, 0, &number, &message, &file, &line); + ZEPHIR_GLOBAL(warning).enable = zend_is_true(&__$true); } diff --git a/ext/phalcon/6__closure.zep.h b/ext/phalcon/6__closure.zep.h index 1dd3d0a03c..a54bfa3ba0 100644 --- a/ext/phalcon/6__closure.zep.h +++ b/ext/phalcon/6__closure.zep.h @@ -5,8 +5,11 @@ ZEPHIR_INIT_CLASS(phalcon_6__closure); PHP_METHOD(phalcon_6__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_6__closure___invoke, 0, 0, 1) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_6__closure___invoke, 0, 0, 4) + ZEND_ARG_INFO(0, number) + ZEND_ARG_INFO(0, message) ZEND_ARG_INFO(0, file) + ZEND_ARG_INFO(0, line) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_6__closure_method_entry) { diff --git a/ext/phalcon/70__closure.zep.c b/ext/phalcon/70__closure.zep.c index 08ef6704f3..de940e06e7 100644 --- a/ext/phalcon/70__closure.zep.c +++ b/ext/phalcon/70__closure.zep.c @@ -45,7 +45,7 @@ PHP_METHOD(phalcon_70__closure, __invoke) ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "time"); + ZVAL_STRING(&_1, "text"); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/71__closure.zep.c b/ext/phalcon/71__closure.zep.c index ce29db59e5..16daf8b1c4 100644 --- a/ext/phalcon/71__closure.zep.c +++ b/ext/phalcon/71__closure.zep.c @@ -39,14 +39,12 @@ PHP_METHOD(phalcon_71__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_71__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_input_generic_ce); + object_init_ex(return_value, phalcon_html_helper_input_textarea_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "url"); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/72__closure.zep.c b/ext/phalcon/72__closure.zep.c index e6b2048692..a94b2a2903 100644 --- a/ext/phalcon/72__closure.zep.c +++ b/ext/phalcon/72__closure.zep.c @@ -45,7 +45,7 @@ PHP_METHOD(phalcon_72__closure, __invoke) ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); - ZVAL_STRING(&_1, "week"); + ZVAL_STRING(&_1, "time"); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/73__closure.zep.c b/ext/phalcon/73__closure.zep.c index 6a2ce28bb4..5e50be24a4 100644 --- a/ext/phalcon/73__closure.zep.c +++ b/ext/phalcon/73__closure.zep.c @@ -39,12 +39,14 @@ PHP_METHOD(phalcon_73__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_73__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_label_ce); + object_init_ex(return_value, phalcon_html_helper_input_generic_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); + ZEPHIR_INIT_NVAR(&_1); + ZVAL_STRING(&_1, "url"); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/74__closure.zep.c b/ext/phalcon/74__closure.zep.c index a82aa0a64c..d00c97c66d 100644 --- a/ext/phalcon/74__closure.zep.c +++ b/ext/phalcon/74__closure.zep.c @@ -29,24 +29,24 @@ PHP_METHOD(phalcon_74__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval escaper, _0, _1, _2; + zval escaper, _0, _1; zval *this_ptr = getThis(); ZVAL_UNDEF(&escaper); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); - ZVAL_UNDEF(&_2); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_74__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_label_ce); + object_init_ex(return_value, phalcon_html_helper_input_generic_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZVAL_BOOL(&_2, 1); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_2); + ZEPHIR_INIT_NVAR(&_1); + ZVAL_STRING(&_1, "week"); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/75__closure.zep.c b/ext/phalcon/75__closure.zep.c index 6a44f103a7..c63c254969 100644 --- a/ext/phalcon/75__closure.zep.c +++ b/ext/phalcon/75__closure.zep.c @@ -39,7 +39,7 @@ PHP_METHOD(phalcon_75__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_75__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_link_ce); + object_init_ex(return_value, phalcon_html_helper_label_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); diff --git a/ext/phalcon/76__closure.zep.c b/ext/phalcon/76__closure.zep.c index 202887d71b..218fd10c49 100644 --- a/ext/phalcon/76__closure.zep.c +++ b/ext/phalcon/76__closure.zep.c @@ -29,22 +29,24 @@ PHP_METHOD(phalcon_76__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval escaper, _0, _1; + zval escaper, _0, _1, _2; zval *this_ptr = getThis(); ZVAL_UNDEF(&escaper); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_76__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_meta_ce); + object_init_ex(return_value, phalcon_html_helper_label_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); + ZVAL_BOOL(&_2, 1); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_2); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/77__closure.zep.c b/ext/phalcon/77__closure.zep.c index 00c5b4d9b0..569beffe2f 100644 --- a/ext/phalcon/77__closure.zep.c +++ b/ext/phalcon/77__closure.zep.c @@ -39,7 +39,7 @@ PHP_METHOD(phalcon_77__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_77__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_ol_ce); + object_init_ex(return_value, phalcon_html_helper_link_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); diff --git a/ext/phalcon/78__closure.zep.c b/ext/phalcon/78__closure.zep.c index 58209271c7..fdc53745d1 100644 --- a/ext/phalcon/78__closure.zep.c +++ b/ext/phalcon/78__closure.zep.c @@ -29,24 +29,22 @@ PHP_METHOD(phalcon_78__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval escaper, _0, _1, _2; + zval escaper, _0, _1; zval *this_ptr = getThis(); ZVAL_UNDEF(&escaper); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); - ZVAL_UNDEF(&_2); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_78__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_ol_ce); + object_init_ex(return_value, phalcon_html_helper_meta_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZVAL_BOOL(&_2, 1); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_2); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/79__closure.zep.c b/ext/phalcon/79__closure.zep.c index 7c90647e77..67c50d3b29 100644 --- a/ext/phalcon/79__closure.zep.c +++ b/ext/phalcon/79__closure.zep.c @@ -13,8 +13,8 @@ #include "kernel/main.h" #include "kernel/fcall.h" -#include "kernel/object.h" #include "kernel/memory.h" +#include "kernel/object.h" ZEPHIR_INIT_CLASS(phalcon_79__closure) @@ -22,7 +22,6 @@ ZEPHIR_INIT_CLASS(phalcon_79__closure) ZEPHIR_REGISTER_CLASS(phalcon, 79__closure, phalcon, 79__closure, phalcon_79__closure_method_entry, ZEND_ACC_FINAL_CLASS); zend_declare_property_null(phalcon_79__closure_ce, SL("escaper"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); - zend_declare_property_null(phalcon_79__closure_ce, SL("response"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } @@ -30,17 +29,22 @@ PHP_METHOD(phalcon_79__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval escaper, response; + zval escaper, _0, _1; + zval *this_ptr = getThis(); ZVAL_UNDEF(&escaper); - ZVAL_UNDEF(&response); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_static_property_ce(&response, phalcon_79__closure_ce, SL("response"), PH_NOISY_CC); zephir_read_static_property_ce(&escaper, phalcon_79__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_preload_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &response); + object_init_ex(return_value, phalcon_html_helper_ol_ce); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "doctype"); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); + zephir_check_call_status(); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/7__closure.zep.c b/ext/phalcon/7__closure.zep.c index aec27334c0..ad10fc3629 100644 --- a/ext/phalcon/7__closure.zep.c +++ b/ext/phalcon/7__closure.zep.c @@ -13,15 +13,15 @@ #include "kernel/main.h" #include "kernel/fcall.h" -#include "kernel/object.h" #include "kernel/memory.h" +#include "kernel/object.h" ZEPHIR_INIT_CLASS(phalcon_7__closure) { ZEPHIR_REGISTER_CLASS(phalcon, 7__closure, phalcon, 7__closure, phalcon_7__closure_method_entry, ZEND_ACC_FINAL_CLASS); - zend_declare_property_null(phalcon_7__closure_ce, SL("serviceName"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); + zend_declare_property_null(phalcon_7__closure_ce, SL("dispatcher"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } @@ -29,16 +29,19 @@ PHP_METHOD(phalcon_7__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval serviceName; - zval *this_ptr = getThis(); + zval dispatcher, *target, target_sub; - ZVAL_UNDEF(&serviceName); + ZVAL_UNDEF(&dispatcher); + ZVAL_UNDEF(&target_sub); + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(target) + ZEND_PARSE_PARAMETERS_END(); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_static_property_ce(&serviceName, phalcon_7__closure_ce, SL("serviceName"), PH_NOISY_CC); - - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "get", NULL, 0, &serviceName); + zephir_read_static_property_ce(&dispatcher, phalcon_7__closure_ce, SL("dispatcher"), PH_NOISY_CC); + zephir_fetch_params(1, 1, 0, &target); + ZEPHIR_CALL_METHOD(NULL, &dispatcher, "forward", NULL, 0, target); zephir_check_call_status(); - RETURN_MM(); + ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/7__closure.zep.h b/ext/phalcon/7__closure.zep.h index 4676e2a65a..76514c158e 100644 --- a/ext/phalcon/7__closure.zep.h +++ b/ext/phalcon/7__closure.zep.h @@ -5,10 +5,11 @@ ZEPHIR_INIT_CLASS(phalcon_7__closure); PHP_METHOD(phalcon_7__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_7__closure___invoke, 0, 0, 0) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_7__closure___invoke, 0, 0, 1) + ZEND_ARG_INFO(0, target) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_7__closure_method_entry) { -PHP_ME(phalcon_7__closure, __invoke, arginfo_phalcon_7__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) + PHP_ME(phalcon_7__closure, __invoke, arginfo_phalcon_7__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) PHP_FE_END }; diff --git a/ext/phalcon/80__closure.zep.c b/ext/phalcon/80__closure.zep.c index 93aed2a801..4974f2c5a5 100644 --- a/ext/phalcon/80__closure.zep.c +++ b/ext/phalcon/80__closure.zep.c @@ -29,22 +29,24 @@ PHP_METHOD(phalcon_80__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval escaper, _0, _1; + zval escaper, _0, _1, _2; zval *this_ptr = getThis(); ZVAL_UNDEF(&escaper); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_80__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_script_ce); + object_init_ex(return_value, phalcon_html_helper_ol_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); + ZVAL_BOOL(&_2, 1); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_2); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/81__closure.zep.c b/ext/phalcon/81__closure.zep.c index 377035a0bf..fe7394dd2d 100644 --- a/ext/phalcon/81__closure.zep.c +++ b/ext/phalcon/81__closure.zep.c @@ -13,8 +13,8 @@ #include "kernel/main.h" #include "kernel/fcall.h" -#include "kernel/memory.h" #include "kernel/object.h" +#include "kernel/memory.h" ZEPHIR_INIT_CLASS(phalcon_81__closure) @@ -22,6 +22,7 @@ ZEPHIR_INIT_CLASS(phalcon_81__closure) ZEPHIR_REGISTER_CLASS(phalcon, 81__closure, phalcon, 81__closure, phalcon_81__closure_method_entry, ZEND_ACC_FINAL_CLASS); zend_declare_property_null(phalcon_81__closure_ce, SL("escaper"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); + zend_declare_property_null(phalcon_81__closure_ce, SL("response"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } @@ -29,22 +30,17 @@ PHP_METHOD(phalcon_81__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval escaper, _0, _1; - zval *this_ptr = getThis(); + zval escaper, response; ZVAL_UNDEF(&escaper); - ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&response); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + zephir_read_static_property_ce(&response, phalcon_81__closure_ce, SL("response"), PH_NOISY_CC); zephir_read_static_property_ce(&escaper, phalcon_81__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_style_ce); - ZEPHIR_INIT_VAR(&_1); - ZVAL_STRING(&_1, "doctype"); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); - zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); + object_init_ex(return_value, phalcon_html_helper_preload_ce); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &response); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/82__closure.zep.c b/ext/phalcon/82__closure.zep.c index 30e19447f5..dd1a727ac7 100644 --- a/ext/phalcon/82__closure.zep.c +++ b/ext/phalcon/82__closure.zep.c @@ -39,7 +39,7 @@ PHP_METHOD(phalcon_82__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_82__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_tag_ce); + object_init_ex(return_value, phalcon_html_helper_script_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); diff --git a/ext/phalcon/83__closure.zep.c b/ext/phalcon/83__closure.zep.c index 1fddae708a..e144eba9d4 100644 --- a/ext/phalcon/83__closure.zep.c +++ b/ext/phalcon/83__closure.zep.c @@ -39,7 +39,7 @@ PHP_METHOD(phalcon_83__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_83__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_title_ce); + object_init_ex(return_value, phalcon_html_helper_style_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); diff --git a/ext/phalcon/84__closure.zep.c b/ext/phalcon/84__closure.zep.c index f32d681af2..e209aff84d 100644 --- a/ext/phalcon/84__closure.zep.c +++ b/ext/phalcon/84__closure.zep.c @@ -39,7 +39,7 @@ PHP_METHOD(phalcon_84__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_84__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_ul_ce); + object_init_ex(return_value, phalcon_html_helper_tag_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); diff --git a/ext/phalcon/85__closure.zep.c b/ext/phalcon/85__closure.zep.c index c24ff2476d..952678e26d 100644 --- a/ext/phalcon/85__closure.zep.c +++ b/ext/phalcon/85__closure.zep.c @@ -29,24 +29,22 @@ PHP_METHOD(phalcon_85__closure, __invoke) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval escaper, _0, _1, _2; + zval escaper, _0, _1; zval *this_ptr = getThis(); ZVAL_UNDEF(&escaper); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); - ZVAL_UNDEF(&_2); ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_85__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_ul_ce); + object_init_ex(return_value, phalcon_html_helper_title_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); zephir_check_call_status(); - ZVAL_BOOL(&_2, 1); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_2); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/86__closure.zep.c b/ext/phalcon/86__closure.zep.c index b9819f26ce..6adaf5635d 100644 --- a/ext/phalcon/86__closure.zep.c +++ b/ext/phalcon/86__closure.zep.c @@ -39,7 +39,7 @@ PHP_METHOD(phalcon_86__closure, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_read_static_property_ce(&escaper, phalcon_86__closure_ce, SL("escaper"), PH_NOISY_CC); - object_init_ex(return_value, phalcon_html_helper_voidtag_ce); + object_init_ex(return_value, phalcon_html_helper_ul_ce); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "doctype"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); diff --git a/ext/phalcon/87__closure.zep.c b/ext/phalcon/87__closure.zep.c index 5aa1480274..efee736bf6 100644 --- a/ext/phalcon/87__closure.zep.c +++ b/ext/phalcon/87__closure.zep.c @@ -12,7 +12,7 @@ #include #include "kernel/main.h" -#include "kernel/string.h" +#include "kernel/fcall.h" #include "kernel/memory.h" #include "kernel/object.h" @@ -21,20 +21,33 @@ ZEPHIR_INIT_CLASS(phalcon_87__closure) { ZEPHIR_REGISTER_CLASS(phalcon, 87__closure, phalcon, 87__closure, phalcon_87__closure_method_entry, ZEND_ACC_FINAL_CLASS); + zend_declare_property_null(phalcon_87__closure_ce, SL("escaper"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } PHP_METHOD(phalcon_87__closure, __invoke) { - zval *a, a_sub, *b, b_sub; - - ZVAL_UNDEF(&a_sub); - ZVAL_UNDEF(&b_sub); - ZEND_PARSE_PARAMETERS_START(2, 2) - Z_PARAM_ZVAL(a) - Z_PARAM_ZVAL(b) - ZEND_PARSE_PARAMETERS_END(); - zephir_fetch_params_without_memory_grow(2, 0, &a, &b); - RETURN_LONG((zephir_fast_strlen_ev(b) - zephir_fast_strlen_ev(a))); + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval escaper, _0, _1, _2; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&escaper); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + zephir_read_static_property_ce(&escaper, phalcon_87__closure_ce, SL("escaper"), PH_NOISY_CC); + + object_init_ex(return_value, phalcon_html_helper_ul_ce); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "doctype"); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); + zephir_check_call_status(); + ZVAL_BOOL(&_2, 1); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0, &_2); + zephir_check_call_status(); + RETURN_MM(); } diff --git a/ext/phalcon/87__closure.zep.h b/ext/phalcon/87__closure.zep.h index f718114e7f..d34115752b 100644 --- a/ext/phalcon/87__closure.zep.h +++ b/ext/phalcon/87__closure.zep.h @@ -5,12 +5,10 @@ ZEPHIR_INIT_CLASS(phalcon_87__closure); PHP_METHOD(phalcon_87__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_87__closure___invoke, 0, 0, 2) - ZEND_ARG_INFO(0, a) - ZEND_ARG_INFO(0, b) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_87__closure___invoke, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_87__closure_method_entry) { - PHP_ME(phalcon_87__closure, __invoke, arginfo_phalcon_87__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +PHP_ME(phalcon_87__closure, __invoke, arginfo_phalcon_87__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) PHP_FE_END }; diff --git a/ext/phalcon/88__closure.zep.c b/ext/phalcon/88__closure.zep.c index 1159ab8c96..3f13336e59 100644 --- a/ext/phalcon/88__closure.zep.c +++ b/ext/phalcon/88__closure.zep.c @@ -12,7 +12,7 @@ #include #include "kernel/main.h" -#include "kernel/string.h" +#include "kernel/fcall.h" #include "kernel/memory.h" #include "kernel/object.h" @@ -21,20 +21,31 @@ ZEPHIR_INIT_CLASS(phalcon_88__closure) { ZEPHIR_REGISTER_CLASS(phalcon, 88__closure, phalcon, 88__closure, phalcon_88__closure_method_entry, ZEND_ACC_FINAL_CLASS); + zend_declare_property_null(phalcon_88__closure_ce, SL("escaper"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } PHP_METHOD(phalcon_88__closure, __invoke) { - zval *a, a_sub, *b, b_sub; - - ZVAL_UNDEF(&a_sub); - ZVAL_UNDEF(&b_sub); - ZEND_PARSE_PARAMETERS_START(2, 2) - Z_PARAM_ZVAL(a) - Z_PARAM_ZVAL(b) - ZEND_PARSE_PARAMETERS_END(); - zephir_fetch_params_without_memory_grow(2, 0, &a, &b); - RETURN_LONG((zephir_fast_strlen_ev(b) - zephir_fast_strlen_ev(a))); + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval escaper, _0, _1; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&escaper); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + zephir_read_static_property_ce(&escaper, phalcon_88__closure_ce, SL("escaper"), PH_NOISY_CC); + + object_init_ex(return_value, phalcon_html_helper_voidtag_ce); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "doctype"); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "newinstance", NULL, 0, &_1); + zephir_check_call_status(); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &escaper, &_0); + zephir_check_call_status(); + RETURN_MM(); } diff --git a/ext/phalcon/88__closure.zep.h b/ext/phalcon/88__closure.zep.h index 2f601fe6f3..4f64727289 100644 --- a/ext/phalcon/88__closure.zep.h +++ b/ext/phalcon/88__closure.zep.h @@ -5,12 +5,10 @@ ZEPHIR_INIT_CLASS(phalcon_88__closure); PHP_METHOD(phalcon_88__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_88__closure___invoke, 0, 0, 2) - ZEND_ARG_INFO(0, a) - ZEND_ARG_INFO(0, b) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_88__closure___invoke, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_88__closure_method_entry) { - PHP_ME(phalcon_88__closure, __invoke, arginfo_phalcon_88__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +PHP_ME(phalcon_88__closure, __invoke, arginfo_phalcon_88__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) PHP_FE_END }; diff --git a/ext/phalcon/89__closure.zep.c b/ext/phalcon/89__closure.zep.c index fed934818e..3d242e0ecc 100644 --- a/ext/phalcon/89__closure.zep.c +++ b/ext/phalcon/89__closure.zep.c @@ -26,20 +26,15 @@ ZEPHIR_INIT_CLASS(phalcon_89__closure) PHP_METHOD(phalcon_89__closure, __invoke) { - zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; - zval *action, action_sub, _0; + zval *a, a_sub, *b, b_sub; - ZVAL_UNDEF(&action_sub); - ZVAL_UNDEF(&_0); - ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_ZVAL(action) + ZVAL_UNDEF(&a_sub); + ZVAL_UNDEF(&b_sub); + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) ZEND_PARSE_PARAMETERS_END(); - ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); - zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_fetch_params(1, 1, 0, &action); - ZEPHIR_INIT_VAR(&_0); - ZVAL_STRING(&_0, "-"); - zephir_uncamelize(return_value, action, &_0); - RETURN_MM(); + zephir_fetch_params_without_memory_grow(2, 0, &a, &b); + RETURN_LONG((zephir_fast_strlen_ev(b) - zephir_fast_strlen_ev(a))); } diff --git a/ext/phalcon/89__closure.zep.h b/ext/phalcon/89__closure.zep.h index 0afab1535c..189eafaae8 100644 --- a/ext/phalcon/89__closure.zep.h +++ b/ext/phalcon/89__closure.zep.h @@ -5,8 +5,9 @@ ZEPHIR_INIT_CLASS(phalcon_89__closure); PHP_METHOD(phalcon_89__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_89__closure___invoke, 0, 0, 1) - ZEND_ARG_INFO(0, action) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_89__closure___invoke, 0, 0, 2) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_89__closure_method_entry) { diff --git a/ext/phalcon/8__closure.zep.c b/ext/phalcon/8__closure.zep.c index 04f9a55fca..378d6dd5e6 100644 --- a/ext/phalcon/8__closure.zep.c +++ b/ext/phalcon/8__closure.zep.c @@ -12,33 +12,26 @@ #include #include "kernel/main.h" -#include "kernel/fcall.h" -#include "kernel/object.h" #include "kernel/memory.h" +#include "kernel/object.h" ZEPHIR_INIT_CLASS(phalcon_8__closure) { ZEPHIR_REGISTER_CLASS(phalcon, 8__closure, phalcon, 8__closure, phalcon_8__closure_method_entry, ZEND_ACC_FINAL_CLASS); - zend_declare_property_null(phalcon_8__closure_ce, SL("serviceName"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } PHP_METHOD(phalcon_8__closure, __invoke) { - zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; - zend_long ZEPHIR_LAST_CALL_STATUS; - zval serviceName; - zval *this_ptr = getThis(); - - ZVAL_UNDEF(&serviceName); - ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); - zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_static_property_ce(&serviceName, phalcon_8__closure_ce, SL("serviceName"), PH_NOISY_CC); - - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "new", NULL, 0, &serviceName); - zephir_check_call_status(); - RETURN_MM(); + zval *file, file_sub; + + ZVAL_UNDEF(&file_sub); + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(file) + ZEND_PARSE_PARAMETERS_END(); + zephir_fetch_params_without_memory_grow(1, 0, &file); + RETURN_BOOL(1); } diff --git a/ext/phalcon/8__closure.zep.h b/ext/phalcon/8__closure.zep.h index 1511266c9e..dd94a850f8 100644 --- a/ext/phalcon/8__closure.zep.h +++ b/ext/phalcon/8__closure.zep.h @@ -5,10 +5,11 @@ ZEPHIR_INIT_CLASS(phalcon_8__closure); PHP_METHOD(phalcon_8__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_8__closure___invoke, 0, 0, 0) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_8__closure___invoke, 0, 0, 1) + ZEND_ARG_INFO(0, file) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_8__closure_method_entry) { -PHP_ME(phalcon_8__closure, __invoke, arginfo_phalcon_8__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) + PHP_ME(phalcon_8__closure, __invoke, arginfo_phalcon_8__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) PHP_FE_END }; diff --git a/ext/phalcon/90__closure.zep.c b/ext/phalcon/90__closure.zep.c index 0f10a5ad11..ce21182317 100644 --- a/ext/phalcon/90__closure.zep.c +++ b/ext/phalcon/90__closure.zep.c @@ -12,6 +12,7 @@ #include #include "kernel/main.h" +#include "kernel/string.h" #include "kernel/memory.h" #include "kernel/object.h" @@ -25,20 +26,15 @@ ZEPHIR_INIT_CLASS(phalcon_90__closure) PHP_METHOD(phalcon_90__closure, __invoke) { - zval *number, number_sub, *message, message_sub, *file, file_sub, *line, line_sub, __$true; - - ZVAL_UNDEF(&number_sub); - ZVAL_UNDEF(&message_sub); - ZVAL_UNDEF(&file_sub); - ZVAL_UNDEF(&line_sub); - ZVAL_BOOL(&__$true, 1); - ZEND_PARSE_PARAMETERS_START(4, 4) - Z_PARAM_ZVAL(number) - Z_PARAM_ZVAL(message) - Z_PARAM_ZVAL(file) - Z_PARAM_ZVAL(line) + zval *a, a_sub, *b, b_sub; + + ZVAL_UNDEF(&a_sub); + ZVAL_UNDEF(&b_sub); + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) ZEND_PARSE_PARAMETERS_END(); - zephir_fetch_params_without_memory_grow(4, 0, &number, &message, &file, &line); - ZEPHIR_GLOBAL(warning).enable = zend_is_true(&__$true); + zephir_fetch_params_without_memory_grow(2, 0, &a, &b); + RETURN_LONG((zephir_fast_strlen_ev(b) - zephir_fast_strlen_ev(a))); } diff --git a/ext/phalcon/90__closure.zep.h b/ext/phalcon/90__closure.zep.h index a60ad49360..213a7eae50 100644 --- a/ext/phalcon/90__closure.zep.h +++ b/ext/phalcon/90__closure.zep.h @@ -5,11 +5,9 @@ ZEPHIR_INIT_CLASS(phalcon_90__closure); PHP_METHOD(phalcon_90__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_90__closure___invoke, 0, 0, 4) - ZEND_ARG_INFO(0, number) - ZEND_ARG_INFO(0, message) - ZEND_ARG_INFO(0, file) - ZEND_ARG_INFO(0, line) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_90__closure___invoke, 0, 0, 2) + ZEND_ARG_INFO(0, a) + ZEND_ARG_INFO(0, b) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_90__closure_method_entry) { diff --git a/ext/phalcon/91__closure.zep.c b/ext/phalcon/91__closure.zep.c index cc1b9a298c..f91e08e989 100644 --- a/ext/phalcon/91__closure.zep.c +++ b/ext/phalcon/91__closure.zep.c @@ -12,6 +12,7 @@ #include #include "kernel/main.h" +#include "kernel/string.h" #include "kernel/memory.h" #include "kernel/object.h" @@ -25,18 +26,20 @@ ZEPHIR_INIT_CLASS(phalcon_91__closure) PHP_METHOD(phalcon_91__closure, __invoke) { - zend_bool _0; - zval *element, element_sub; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zval *action, action_sub, _0; - ZVAL_UNDEF(&element_sub); + ZVAL_UNDEF(&action_sub); + ZVAL_UNDEF(&_0); ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_ZVAL(element) + Z_PARAM_ZVAL(action) ZEND_PARSE_PARAMETERS_END(); - zephir_fetch_params_without_memory_grow(1, 0, &element); - _0 = Z_TYPE_P(element) == IS_LONG; - if (!(_0)) { - _0 = Z_TYPE_P(element) == IS_STRING; - } - RETURN_BOOL(_0); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + zephir_fetch_params(1, 1, 0, &action); + ZEPHIR_INIT_VAR(&_0); + ZVAL_STRING(&_0, "-"); + zephir_uncamelize(return_value, action, &_0); + RETURN_MM(); } diff --git a/ext/phalcon/91__closure.zep.h b/ext/phalcon/91__closure.zep.h index 51b703451b..9529b16cfc 100644 --- a/ext/phalcon/91__closure.zep.h +++ b/ext/phalcon/91__closure.zep.h @@ -6,7 +6,7 @@ ZEPHIR_INIT_CLASS(phalcon_91__closure); PHP_METHOD(phalcon_91__closure, __invoke); ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_91__closure___invoke, 0, 0, 1) - ZEND_ARG_INFO(0, element) + ZEND_ARG_INFO(0, action) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_91__closure_method_entry) { diff --git a/ext/phalcon/92__closure.zep.c b/ext/phalcon/92__closure.zep.c index 9e1a590672..834c899bf2 100644 --- a/ext/phalcon/92__closure.zep.c +++ b/ext/phalcon/92__closure.zep.c @@ -25,18 +25,20 @@ ZEPHIR_INIT_CLASS(phalcon_92__closure) PHP_METHOD(phalcon_92__closure, __invoke) { - zend_bool _0; - zval *element, element_sub; - - ZVAL_UNDEF(&element_sub); - ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_ZVAL(element) + zval *number, number_sub, *message, message_sub, *file, file_sub, *line, line_sub, __$true; + + ZVAL_UNDEF(&number_sub); + ZVAL_UNDEF(&message_sub); + ZVAL_UNDEF(&file_sub); + ZVAL_UNDEF(&line_sub); + ZVAL_BOOL(&__$true, 1); + ZEND_PARSE_PARAMETERS_START(4, 4) + Z_PARAM_ZVAL(number) + Z_PARAM_ZVAL(message) + Z_PARAM_ZVAL(file) + Z_PARAM_ZVAL(line) ZEND_PARSE_PARAMETERS_END(); - zephir_fetch_params_without_memory_grow(1, 0, &element); - _0 = Z_TYPE_P(element) == IS_LONG; - if (!(_0)) { - _0 = Z_TYPE_P(element) == IS_STRING; - } - RETURN_BOOL(_0); + zephir_fetch_params_without_memory_grow(4, 0, &number, &message, &file, &line); + ZEPHIR_GLOBAL(warning).enable = zend_is_true(&__$true); } diff --git a/ext/phalcon/92__closure.zep.h b/ext/phalcon/92__closure.zep.h index c9cab821bb..d558fd7554 100644 --- a/ext/phalcon/92__closure.zep.h +++ b/ext/phalcon/92__closure.zep.h @@ -5,8 +5,11 @@ ZEPHIR_INIT_CLASS(phalcon_92__closure); PHP_METHOD(phalcon_92__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_92__closure___invoke, 0, 0, 1) - ZEND_ARG_INFO(0, element) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_92__closure___invoke, 0, 0, 4) + ZEND_ARG_INFO(0, number) + ZEND_ARG_INFO(0, message) + ZEND_ARG_INFO(0, file) + ZEND_ARG_INFO(0, line) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_92__closure_method_entry) { diff --git a/ext/phalcon/93__closure.zep.c b/ext/phalcon/93__closure.zep.c index 4b11c3ce90..38dacb654e 100644 --- a/ext/phalcon/93__closure.zep.c +++ b/ext/phalcon/93__closure.zep.c @@ -25,20 +25,18 @@ ZEPHIR_INIT_CLASS(phalcon_93__closure) PHP_METHOD(phalcon_93__closure, __invoke) { - zval *number, number_sub, *message, message_sub, *file, file_sub, *line, line_sub, __$true; - - ZVAL_UNDEF(&number_sub); - ZVAL_UNDEF(&message_sub); - ZVAL_UNDEF(&file_sub); - ZVAL_UNDEF(&line_sub); - ZVAL_BOOL(&__$true, 1); - ZEND_PARSE_PARAMETERS_START(4, 4) - Z_PARAM_ZVAL(number) - Z_PARAM_ZVAL(message) - Z_PARAM_ZVAL(file) - Z_PARAM_ZVAL(line) + zend_bool _0; + zval *element, element_sub; + + ZVAL_UNDEF(&element_sub); + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(element) ZEND_PARSE_PARAMETERS_END(); - zephir_fetch_params_without_memory_grow(4, 0, &number, &message, &file, &line); - ZEPHIR_GLOBAL(warning).enable = zend_is_true(&__$true); + zephir_fetch_params_without_memory_grow(1, 0, &element); + _0 = Z_TYPE_P(element) == IS_LONG; + if (!(_0)) { + _0 = Z_TYPE_P(element) == IS_STRING; + } + RETURN_BOOL(_0); } diff --git a/ext/phalcon/93__closure.zep.h b/ext/phalcon/93__closure.zep.h index 8e1b6230c3..4f9a916c10 100644 --- a/ext/phalcon/93__closure.zep.h +++ b/ext/phalcon/93__closure.zep.h @@ -5,11 +5,8 @@ ZEPHIR_INIT_CLASS(phalcon_93__closure); PHP_METHOD(phalcon_93__closure, __invoke); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_93__closure___invoke, 0, 0, 4) - ZEND_ARG_INFO(0, number) - ZEND_ARG_INFO(0, message) - ZEND_ARG_INFO(0, file) - ZEND_ARG_INFO(0, line) +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_93__closure___invoke, 0, 0, 1) + ZEND_ARG_INFO(0, element) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_93__closure_method_entry) { diff --git a/ext/phalcon/94__closure.zep.c b/ext/phalcon/94__closure.zep.c new file mode 100644 index 0000000000..03219ad0e7 --- /dev/null +++ b/ext/phalcon/94__closure.zep.c @@ -0,0 +1,42 @@ + +#ifdef HAVE_CONFIG_H +#include "../ext_config.h" +#endif + +#include +#include "../php_ext.h" +#include "../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/memory.h" +#include "kernel/object.h" + + +ZEPHIR_INIT_CLASS(phalcon_94__closure) +{ + ZEPHIR_REGISTER_CLASS(phalcon, 94__closure, phalcon, 94__closure, phalcon_94__closure_method_entry, ZEND_ACC_FINAL_CLASS); + + return SUCCESS; +} + +PHP_METHOD(phalcon_94__closure, __invoke) +{ + zend_bool _0; + zval *element, element_sub; + + ZVAL_UNDEF(&element_sub); + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(element) + ZEND_PARSE_PARAMETERS_END(); + zephir_fetch_params_without_memory_grow(1, 0, &element); + _0 = Z_TYPE_P(element) == IS_LONG; + if (!(_0)) { + _0 = Z_TYPE_P(element) == IS_STRING; + } + RETURN_BOOL(_0); +} + diff --git a/ext/phalcon/94__closure.zep.h b/ext/phalcon/94__closure.zep.h new file mode 100644 index 0000000000..bc3b1e1dab --- /dev/null +++ b/ext/phalcon/94__closure.zep.h @@ -0,0 +1,15 @@ + +extern zend_class_entry *phalcon_94__closure_ce; + +ZEPHIR_INIT_CLASS(phalcon_94__closure); + +PHP_METHOD(phalcon_94__closure, __invoke); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_94__closure___invoke, 0, 0, 1) + ZEND_ARG_INFO(0, element) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_94__closure_method_entry) { + PHP_ME(phalcon_94__closure, __invoke, arginfo_phalcon_94__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) + PHP_FE_END +}; diff --git a/ext/phalcon/95__closure.zep.c b/ext/phalcon/95__closure.zep.c new file mode 100644 index 0000000000..78fbe1c714 --- /dev/null +++ b/ext/phalcon/95__closure.zep.c @@ -0,0 +1,44 @@ + +#ifdef HAVE_CONFIG_H +#include "../ext_config.h" +#endif + +#include +#include "../php_ext.h" +#include "../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/memory.h" +#include "kernel/object.h" + + +ZEPHIR_INIT_CLASS(phalcon_95__closure) +{ + ZEPHIR_REGISTER_CLASS(phalcon, 95__closure, phalcon, 95__closure, phalcon_95__closure_method_entry, ZEND_ACC_FINAL_CLASS); + + return SUCCESS; +} + +PHP_METHOD(phalcon_95__closure, __invoke) +{ + zval *number, number_sub, *message, message_sub, *file, file_sub, *line, line_sub, __$true; + + ZVAL_UNDEF(&number_sub); + ZVAL_UNDEF(&message_sub); + ZVAL_UNDEF(&file_sub); + ZVAL_UNDEF(&line_sub); + ZVAL_BOOL(&__$true, 1); + ZEND_PARSE_PARAMETERS_START(4, 4) + Z_PARAM_ZVAL(number) + Z_PARAM_ZVAL(message) + Z_PARAM_ZVAL(file) + Z_PARAM_ZVAL(line) + ZEND_PARSE_PARAMETERS_END(); + zephir_fetch_params_without_memory_grow(4, 0, &number, &message, &file, &line); + ZEPHIR_GLOBAL(warning).enable = zend_is_true(&__$true); +} + diff --git a/ext/phalcon/95__closure.zep.h b/ext/phalcon/95__closure.zep.h new file mode 100644 index 0000000000..321e3e8e4f --- /dev/null +++ b/ext/phalcon/95__closure.zep.h @@ -0,0 +1,18 @@ + +extern zend_class_entry *phalcon_95__closure_ce; + +ZEPHIR_INIT_CLASS(phalcon_95__closure); + +PHP_METHOD(phalcon_95__closure, __invoke); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_95__closure___invoke, 0, 0, 4) + ZEND_ARG_INFO(0, number) + ZEND_ARG_INFO(0, message) + ZEND_ARG_INFO(0, file) + ZEND_ARG_INFO(0, line) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_95__closure_method_entry) { + PHP_ME(phalcon_95__closure, __invoke, arginfo_phalcon_95__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) + PHP_FE_END +}; diff --git a/ext/phalcon/9__closure.zep.c b/ext/phalcon/9__closure.zep.c index ef82cf9e9d..a09b3f19a7 100644 --- a/ext/phalcon/9__closure.zep.c +++ b/ext/phalcon/9__closure.zep.c @@ -12,25 +12,33 @@ #include #include "kernel/main.h" +#include "kernel/fcall.h" #include "kernel/object.h" +#include "kernel/memory.h" ZEPHIR_INIT_CLASS(phalcon_9__closure) { ZEPHIR_REGISTER_CLASS(phalcon, 9__closure, phalcon, 9__closure, phalcon_9__closure_method_entry, ZEND_ACC_FINAL_CLASS); - zend_declare_property_null(phalcon_9__closure_ce, SL("definition"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); + zend_declare_property_null(phalcon_9__closure_ce, SL("serviceName"), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC); return SUCCESS; } PHP_METHOD(phalcon_9__closure, __invoke) { - zval definition; - - ZVAL_UNDEF(&definition); - zephir_read_static_property_ce(&definition, phalcon_9__closure_ce, SL("definition"), PH_NOISY_CC); - - RETVAL_ZVAL(&definition, 1, 0); - return; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval serviceName; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&serviceName); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + zephir_read_static_property_ce(&serviceName, phalcon_9__closure_ce, SL("serviceName"), PH_NOISY_CC); + + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "get", NULL, 0, &serviceName); + zephir_check_call_status(); + RETURN_MM(); } diff --git a/ext/phalcon/acl/adapter/memory.zep.c b/ext/phalcon/acl/adapter/memory.zep.c index a5440945ac..060f656e5c 100644 --- a/ext/phalcon/acl/adapter/memory.zep.c +++ b/ext/phalcon/acl/adapter/memory.zep.c @@ -216,27 +216,27 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, __construct) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 243, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 244, &_0); ZEPHIR_INIT_VAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 244, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 245, &_1); ZEPHIR_INIT_VAR(&_2); zephir_create_array(&_2, 1, 0); zephir_array_update_string(&_2, SL("*"), &__$true, PH_COPY | PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 245, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 246, &_2); ZEPHIR_INIT_VAR(&_3); array_init(&_3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 246, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 247, &_3); ZEPHIR_INIT_VAR(&_4); array_init(&_4); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 247, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 248, &_4); ZEPHIR_INIT_VAR(&_5); array_init(&_5); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 248, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 249, &_5); ZEPHIR_INIT_VAR(&_6); zephir_create_array(&_6, 1, 0); zephir_array_update_string(&_6, SL("*!*"), &__$true, PH_COPY | PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 249, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 250, &_6); ZEPHIR_MM_RESTORE(); } @@ -309,12 +309,12 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addComponent) } else { ZEPHIR_INIT_NVAR(&componentObject); object_init_ex(&componentObject, phalcon_acl_component_ce); - ZEPHIR_CALL_METHOD(NULL, &componentObject, "__construct", NULL, 213, componentValue); + ZEPHIR_CALL_METHOD(NULL, &componentObject, "__construct", NULL, 219, componentValue); zephir_check_call_status(); } - ZEPHIR_CALL_METHOD(&componentName, &componentObject, "getname", NULL, 214); + ZEPHIR_CALL_METHOD(&componentName, &componentObject, "getname", NULL, 220); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 245, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 246, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_1, &componentName))) { zephir_update_property_array(this_ptr, SL("components"), &componentName, &componentObject); zephir_update_property_array(this_ptr, SL("componentsNames"), &componentName, &__$true); @@ -369,10 +369,10 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addComponentAccess) accessList = ZEND_CALL_ARG(execute_data, 2); zephir_memory_observe(&componentName_zv); ZVAL_STR_COPY(&componentName_zv, componentName); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 245, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 246, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "Component"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkexists", NULL, 215, &_0, &componentName_zv, &_1); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkexists", NULL, 221, &_0, &componentName_zv, &_1); zephir_check_call_status(); _2 = Z_TYPE_P(accessList) != IS_ARRAY; if (_2) { @@ -381,7 +381,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addComponentAccess) if (UNEXPECTED(_2)) { ZEPHIR_INIT_VAR(&_3$$3); object_init_ex(&_3$$3, phalcon_acl_exceptions_invalidaccesslist_ce); - ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 216); + ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 222); zephir_check_call_status(); zephir_throw_exception_debug(&_3$$3, "phalcon/Acl/Adapter/Memory.zep", 255); ZEPHIR_MM_RESTORE(); @@ -395,9 +395,9 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addComponentAccess) { ZEPHIR_INIT_NVAR(&accessName); ZVAL_COPY(&accessName, _4$$4); - ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildaccesskey", &_5, 217, &componentName_zv, &accessName); + ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildaccesskey", &_5, 223, &componentName_zv, &accessName); zephir_check_call_status(); - zephir_read_property_cached(&_6$$5, this_ptr, _zephir_prop_1, 249, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$5, this_ptr, _zephir_prop_1, 250, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_6$$5, &accessKey))) { ZEPHIR_INIT_NVAR(&_7$$6); ZVAL_BOOL(&_7$$6, exists); @@ -422,9 +422,9 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addComponentAccess) } ZEPHIR_CALL_METHOD(&accessName, accessList, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildaccesskey", &_5, 217, &componentName_zv, &accessName); + ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildaccesskey", &_5, 223, &componentName_zv, &accessName); zephir_check_call_status(); - zephir_read_property_cached(&_10$$7, this_ptr, _zephir_prop_1, 249, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$7, this_ptr, _zephir_prop_1, 250, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_10$$7, &accessKey))) { ZEPHIR_INIT_NVAR(&_11$$8); ZVAL_BOOL(&_11$$8, exists); @@ -434,9 +434,9 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addComponentAccess) } ZEPHIR_INIT_NVAR(&accessName); } else { - ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildaccesskey", &_5, 217, &componentName_zv, accessList); + ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildaccesskey", &_5, 223, &componentName_zv, accessList); zephir_check_call_status(); - zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_1, 249, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_1, 250, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_12$$9, &accessKey))) { ZEPHIR_INIT_VAR(&_13$$10); ZVAL_BOOL(&_13$$10, exists); @@ -525,14 +525,14 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addInherit) roleToInherits = ZEND_CALL_ARG(execute_data, 2); zephir_memory_observe(&roleName_zv); ZVAL_STR_COPY(&roleName_zv, roleName); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 248, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 249, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "Role"); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "role list"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkexists", NULL, 215, &_0, &roleName_zv, &_1, &_2); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkexists", NULL, 221, &_0, &roleName_zv, &_1, &_2); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 248, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_3, &roleName_zv))) { ZEPHIR_INIT_VAR(&_4$$3); array_init(&_4$$3); @@ -561,16 +561,16 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addInherit) } else { ZEPHIR_CPY_WRT(&roleInheritName, &roleToInherit); } - zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_1, 247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_1, 248, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_8$$6, &_7$$6, &roleName_zv, PH_NOISY | PH_READONLY, "phalcon/Acl/Adapter/Memory.zep", 322); if (zephir_fast_in_array(&roleInheritName, &_8$$6)) { continue; } - zephir_read_property_cached(&_9$$6, this_ptr, _zephir_prop_0, 248, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$6, this_ptr, _zephir_prop_0, 249, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(!(zephir_array_isset_value(&_9$$6, &roleInheritName)))) { ZEPHIR_INIT_NVAR(&_10$$10); object_init_ex(&_10$$10, phalcon_acl_exceptions_rolenotfoundexception_ce); - ZEPHIR_CALL_METHOD(NULL, &_10$$10, "__construct", &_11, 218, &roleInheritName); + ZEPHIR_CALL_METHOD(NULL, &_10$$10, "__construct", &_11, 224, &roleInheritName); zephir_check_call_status(); zephir_throw_exception_debug(&_10$$10, "phalcon/Acl/Adapter/Memory.zep", 330); ZEPHIR_MM_RESTORE(); @@ -579,11 +579,11 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addInherit) if (ZEPHIR_IS_EQUAL(&roleName_zv, &roleInheritName)) { RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_12$$6, this_ptr, _zephir_prop_1, 247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$6, this_ptr, _zephir_prop_1, 248, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_12$$6, &roleInheritName)) { ZEPHIR_INIT_NVAR(&checkRoleToInherits); array_init(&checkRoleToInherits); - zephir_read_property_cached(&_13$$12, this_ptr, _zephir_prop_1, 247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$12, this_ptr, _zephir_prop_1, 248, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_14$$12, &_13$$12, &roleInheritName, PH_NOISY | PH_READONLY, "phalcon/Acl/Adapter/Memory.zep", 343); zephir_is_iterable(&_14$$12, 0, "phalcon/Acl/Adapter/Memory.zep", 347); if (Z_TYPE_P(&_14$$12) == IS_ARRAY) { @@ -592,7 +592,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addInherit) ZEPHIR_INIT_NVAR(&usedRoleToInherit); ZVAL_COPY(&usedRoleToInherit, _15$$12); ZEPHIR_MAKE_REF(&checkRoleToInherits); - ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_16, 219, &checkRoleToInherits, &usedRoleToInherit); + ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_16, 225, &checkRoleToInherits, &usedRoleToInherit); ZEPHIR_UNREF(&checkRoleToInherits); zephir_check_call_status(); } ZEND_HASH_FOREACH_END(); @@ -615,7 +615,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addInherit) ZEPHIR_CALL_METHOD(&usedRoleToInherit, &_14$$12, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_MAKE_REF(&checkRoleToInherits); - ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_16, 219, &checkRoleToInherits, &usedRoleToInherit); + ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_16, 225, &checkRoleToInherits, &usedRoleToInherit); ZEPHIR_UNREF(&checkRoleToInherits); zephir_check_call_status(); } @@ -638,15 +638,15 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addInherit) if (UNEXPECTED(ZEPHIR_IS_EQUAL(&roleName_zv, &checkRoleToInherit))) { ZEPHIR_INIT_NVAR(&_19$$17); object_init_ex(&_19$$17, phalcon_acl_exceptions_circularinheritanceerror_ce); - ZEPHIR_CALL_METHOD(NULL, &_19$$17, "__construct", &_20, 220, &roleInheritName); + ZEPHIR_CALL_METHOD(NULL, &_19$$17, "__construct", &_20, 226, &roleInheritName); zephir_check_call_status(); zephir_throw_exception_debug(&_19$$17, "phalcon/Acl/Adapter/Memory.zep", 368); ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_21$$15, this_ptr, _zephir_prop_1, 247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$15, this_ptr, _zephir_prop_1, 248, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_21$$15, &checkRoleToInherit)) { - zephir_read_property_cached(&_22$$18, this_ptr, _zephir_prop_1, 247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$18, this_ptr, _zephir_prop_1, 248, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_23$$18, &_22$$18, &checkRoleToInherit, PH_NOISY | PH_READONLY, "phalcon/Acl/Adapter/Memory.zep", 375); zephir_is_iterable(&_23$$18, 0, "phalcon/Acl/Adapter/Memory.zep", 378); if (Z_TYPE_P(&_23$$18) == IS_ARRAY) { @@ -655,7 +655,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addInherit) ZEPHIR_INIT_NVAR(&usedRoleToInherit); ZVAL_COPY(&usedRoleToInherit, _24$$18); ZEPHIR_MAKE_REF(&checkRoleToInherits); - ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_16, 219, &checkRoleToInherits, &usedRoleToInherit); + ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_16, 225, &checkRoleToInherits, &usedRoleToInherit); ZEPHIR_UNREF(&checkRoleToInherits); zephir_check_call_status(); } ZEND_HASH_FOREACH_END(); @@ -678,7 +678,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addInherit) ZEPHIR_CALL_METHOD(&usedRoleToInherit, &_23$$18, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_MAKE_REF(&checkRoleToInherits); - ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_16, 219, &checkRoleToInherits, &usedRoleToInherit); + ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_16, 225, &checkRoleToInherits, &usedRoleToInherit); ZEPHIR_UNREF(&checkRoleToInherits); zephir_check_call_status(); } @@ -717,16 +717,16 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addInherit) } else { ZEPHIR_CPY_WRT(&roleInheritName, &roleToInherit); } - zephir_read_property_cached(&_30$$21, this_ptr, _zephir_prop_1, 247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_30$$21, this_ptr, _zephir_prop_1, 248, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_31$$21, &_30$$21, &roleName_zv, PH_NOISY | PH_READONLY, "phalcon/Acl/Adapter/Memory.zep", 322); if (zephir_fast_in_array(&roleInheritName, &_31$$21)) { continue; } - zephir_read_property_cached(&_32$$21, this_ptr, _zephir_prop_0, 248, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_32$$21, this_ptr, _zephir_prop_0, 249, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(!(zephir_array_isset_value(&_32$$21, &roleInheritName)))) { ZEPHIR_INIT_NVAR(&_33$$25); object_init_ex(&_33$$25, phalcon_acl_exceptions_rolenotfoundexception_ce); - ZEPHIR_CALL_METHOD(NULL, &_33$$25, "__construct", &_11, 218, &roleInheritName); + ZEPHIR_CALL_METHOD(NULL, &_33$$25, "__construct", &_11, 224, &roleInheritName); zephir_check_call_status(); zephir_throw_exception_debug(&_33$$25, "phalcon/Acl/Adapter/Memory.zep", 330); ZEPHIR_MM_RESTORE(); @@ -735,11 +735,11 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addInherit) if (ZEPHIR_IS_EQUAL(&roleName_zv, &roleInheritName)) { RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_34$$21, this_ptr, _zephir_prop_1, 247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_34$$21, this_ptr, _zephir_prop_1, 248, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_34$$21, &roleInheritName)) { ZEPHIR_INIT_NVAR(&checkRoleToInherits); array_init(&checkRoleToInherits); - zephir_read_property_cached(&_35$$27, this_ptr, _zephir_prop_1, 247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_35$$27, this_ptr, _zephir_prop_1, 248, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_36$$27, &_35$$27, &roleInheritName, PH_NOISY | PH_READONLY, "phalcon/Acl/Adapter/Memory.zep", 343); zephir_is_iterable(&_36$$27, 0, "phalcon/Acl/Adapter/Memory.zep", 347); if (Z_TYPE_P(&_36$$27) == IS_ARRAY) { @@ -748,7 +748,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addInherit) ZEPHIR_INIT_NVAR(&usedRoleToInherit); ZVAL_COPY(&usedRoleToInherit, _37$$27); ZEPHIR_MAKE_REF(&checkRoleToInherits); - ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_16, 219, &checkRoleToInherits, &usedRoleToInherit); + ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_16, 225, &checkRoleToInherits, &usedRoleToInherit); ZEPHIR_UNREF(&checkRoleToInherits); zephir_check_call_status(); } ZEND_HASH_FOREACH_END(); @@ -771,7 +771,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addInherit) ZEPHIR_CALL_METHOD(&usedRoleToInherit, &_36$$27, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_MAKE_REF(&checkRoleToInherits); - ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_16, 219, &checkRoleToInherits, &usedRoleToInherit); + ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_16, 225, &checkRoleToInherits, &usedRoleToInherit); ZEPHIR_UNREF(&checkRoleToInherits); zephir_check_call_status(); } @@ -794,15 +794,15 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addInherit) if (UNEXPECTED(ZEPHIR_IS_EQUAL(&roleName_zv, &checkRoleToInherit))) { ZEPHIR_INIT_NVAR(&_40$$32); object_init_ex(&_40$$32, phalcon_acl_exceptions_circularinheritanceerror_ce); - ZEPHIR_CALL_METHOD(NULL, &_40$$32, "__construct", &_20, 220, &roleInheritName); + ZEPHIR_CALL_METHOD(NULL, &_40$$32, "__construct", &_20, 226, &roleInheritName); zephir_check_call_status(); zephir_throw_exception_debug(&_40$$32, "phalcon/Acl/Adapter/Memory.zep", 368); ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_41$$30, this_ptr, _zephir_prop_1, 247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_41$$30, this_ptr, _zephir_prop_1, 248, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_41$$30, &checkRoleToInherit)) { - zephir_read_property_cached(&_42$$33, this_ptr, _zephir_prop_1, 247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_42$$33, this_ptr, _zephir_prop_1, 248, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_43$$33, &_42$$33, &checkRoleToInherit, PH_NOISY | PH_READONLY, "phalcon/Acl/Adapter/Memory.zep", 375); zephir_is_iterable(&_43$$33, 0, "phalcon/Acl/Adapter/Memory.zep", 378); if (Z_TYPE_P(&_43$$33) == IS_ARRAY) { @@ -811,7 +811,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addInherit) ZEPHIR_INIT_NVAR(&usedRoleToInherit); ZVAL_COPY(&usedRoleToInherit, _44$$33); ZEPHIR_MAKE_REF(&checkRoleToInherits); - ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_16, 219, &checkRoleToInherits, &usedRoleToInherit); + ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_16, 225, &checkRoleToInherits, &usedRoleToInherit); ZEPHIR_UNREF(&checkRoleToInherits); zephir_check_call_status(); } ZEND_HASH_FOREACH_END(); @@ -834,7 +834,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addInherit) ZEPHIR_CALL_METHOD(&usedRoleToInherit, &_43$$33, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_MAKE_REF(&checkRoleToInherits); - ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_16, 219, &checkRoleToInherits, &usedRoleToInherit); + ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_16, 225, &checkRoleToInherits, &usedRoleToInherit); ZEPHIR_UNREF(&checkRoleToInherits); zephir_check_call_status(); } @@ -909,20 +909,20 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addRole) } else if (Z_TYPE_P(role) == IS_STRING) { ZEPHIR_INIT_NVAR(&roleObject); object_init_ex(&roleObject, phalcon_acl_role_ce); - ZEPHIR_CALL_METHOD(NULL, &roleObject, "__construct", NULL, 221, role); + ZEPHIR_CALL_METHOD(NULL, &roleObject, "__construct", NULL, 227, role); zephir_check_call_status(); } else { ZEPHIR_INIT_VAR(&_1$$5); object_init_ex(&_1$$5, phalcon_acl_exceptions_invalidroletype_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$5, "__construct", NULL, 222); + ZEPHIR_CALL_METHOD(NULL, &_1$$5, "__construct", NULL, 228); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$5, "phalcon/Acl/Adapter/Memory.zep", 414); ZEPHIR_MM_RESTORE(); return; } - ZEPHIR_CALL_METHOD(&roleName, &roleObject, "getname", NULL, 214); + ZEPHIR_CALL_METHOD(&roleName, &roleObject, "getname", NULL, 220); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 248, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 249, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_2, &roleName)) { RETURN_MM_BOOL(0); } @@ -1007,7 +1007,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, allow) ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "*"); if (ZEPHIR_IS_IDENTICAL(&_0, &roleName_zv)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 248, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 249, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&rolesArray); zephir_array_keys(&rolesArray, &_1$$3); } @@ -1017,7 +1017,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, allow) ZEPHIR_INIT_NVAR(&role); ZVAL_COPY(&role, _2); ZVAL_LONG(&_3$$4, 1); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "allowordeny", &_4, 223, &role, &componentName_zv, access, &_3$$4, func); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "allowordeny", &_4, 229, &role, &componentName_zv, access, &_3$$4, func); zephir_check_call_status(); } ZEND_HASH_FOREACH_END(); ZEPHIR_INIT_NVAR(&role); @@ -1096,7 +1096,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, deny) ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "*"); if (ZEPHIR_IS_IDENTICAL(&_0, &roleName_zv)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 248, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 249, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&rolesArray); zephir_array_keys(&rolesArray, &_1$$3); } @@ -1106,7 +1106,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, deny) ZEPHIR_INIT_NVAR(&role); ZVAL_COPY(&role, _2); ZVAL_LONG(&_3$$4, 0); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "allowordeny", &_4, 223, &role, &componentName_zv, access, &_3$$4, func); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "allowordeny", &_4, 229, &role, &componentName_zv, access, &_3$$4, func); zephir_check_call_status(); } ZEND_HASH_FOREACH_END(); ZEPHIR_INIT_NVAR(&role); @@ -1163,12 +1163,12 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, dropComponentAccess) { ZEPHIR_INIT_NVAR(&accessName); ZVAL_COPY(&accessName, _1); - ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildaccesskey", &_2, 217, &componentName_zv, &accessName); + ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildaccesskey", &_2, 223, &componentName_zv, &accessName); zephir_check_call_status(); - zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_0, 249, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_0, 250, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_3$$5, &accessKey)) { zephir_unset_property_array(this_ptr, ZEND_STRL("accessList"), &accessKey); - zephir_read_property_cached(&_4$$6, this_ptr, _zephir_prop_0, 249, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$6, this_ptr, _zephir_prop_0, 250, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_4$$6, &accessKey, PH_SEPARATE); } } ZEND_HASH_FOREACH_END(); @@ -1259,7 +1259,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, getInheritedRoles) RETURN_MM_MEMBER_TYPED(getThis(), "roleInherits", IS_ARRAY); } zephir_memory_observe(&result); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 248, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&result, &_1, &roleName_zv, 0))) { array_init(return_value); RETURN_MM(); @@ -1420,24 +1420,24 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, isAllowed) if (_1) { ZEPHIR_CPY_WRT(&componentObject, componentName); } - ZEPHIR_CALL_METHOD(&_2, this_ptr, "torolename", NULL, 224, roleName); + ZEPHIR_CALL_METHOD(&_2, this_ptr, "torolename", NULL, 230, roleName); zephir_check_call_status(); ZEPHIR_CPY_WRT(roleName, &_2); - ZEPHIR_CALL_METHOD(&_2, this_ptr, "tocomponentname", NULL, 225, componentName); + ZEPHIR_CALL_METHOD(&_2, this_ptr, "tocomponentname", NULL, 231, componentName); zephir_check_call_status(); ZEPHIR_CPY_WRT(componentName, &_2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 250, roleName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 251, componentName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 252, &access_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 253, &__$null); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 254, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 251, roleName); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 252, componentName); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 253, &access_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 254, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 255, &__$null); zephir_memory_observe(&accessList); - zephir_read_property_cached(&accessList, this_ptr, _zephir_prop_5, 243, PH_NOISY_CC); + zephir_read_property_cached(&accessList, this_ptr, _zephir_prop_5, 244, PH_NOISY_CC); zephir_memory_observe(&funcList); - zephir_read_property_cached(&funcList, this_ptr, _zephir_prop_6, 246, PH_NOISY_CC); + zephir_read_property_cached(&funcList, this_ptr, _zephir_prop_6, 247, PH_NOISY_CC); ZVAL_UNDEF(&_3); ZVAL_LONG(&_3, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 255, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 256, &_3); ZEPHIR_INIT_VAR(&_4); zephir_create_array(&_4, 3, 0); zephir_array_update_string(&_4, SL("role"), roleName, PH_COPY | PH_SEPARATE); @@ -1450,12 +1450,12 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, isAllowed) if (ZEPHIR_IS_FALSE_IDENTICAL(&_2)) { RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_8, 248, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_8, 249, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_3, roleName))) { - zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_9, 256, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_9, 257, PH_NOISY_CC | PH_READONLY); RETURN_MM_BOOL((ZEPHIR_IS_LONG(&_6$$6, 1))); } - ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "canaccess", NULL, 226, roleName, componentName, &access_zv); + ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "canaccess", NULL, 232, roleName, componentName, &access_zv); zephir_check_call_status(); _7 = Z_TYPE_P(&accessKey) != IS_NULL; if (_7) { @@ -1474,30 +1474,30 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, isAllowed) } else { ZEPHIR_CPY_WRT(&_8, &haveAccess); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 257, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 258, &_8); ZEPHIR_INIT_VAR(&_9); zephir_create_array(&_9, 4, 0); zephir_array_update_string(&_9, SL("role"), roleName, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_9, SL("component"), componentName, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_9, SL("access"), &access_zv, PH_COPY | PH_SEPARATE); zephir_memory_observe(&_10); - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_10, 257, PH_NOISY_CC); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_10, 258, PH_NOISY_CC); zephir_array_update_string(&_9, SL("granted"), &_10, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_5); ZVAL_STRING(&_5, "acl:afterCheckAccess"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "firemanagerevent", NULL, 0, &_5, &_9); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 253, &accessKey); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 254, &funcAccess); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 254, &accessKey); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 255, &funcAccess); if (Z_TYPE_P(&haveAccess) == IS_NULL) { - ZEPHIR_CALL_METHOD(&_11$$8, this_ptr, "buildkey", NULL, 227, roleName, componentName, &access_zv); + ZEPHIR_CALL_METHOD(&_11$$8, this_ptr, "buildkey", NULL, 233, roleName, componentName, &access_zv); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 253, &_11$$8); - zephir_read_property_cached(&_12$$8, this_ptr, _zephir_prop_9, 256, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 254, &_11$$8); + zephir_read_property_cached(&_12$$8, this_ptr, _zephir_prop_9, 257, PH_NOISY_CC | PH_READONLY); RETURN_MM_BOOL(ZEPHIR_IS_LONG(&_12$$8, 1)); } if (zephir_is_callable(&funcAccess)) { - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "invokerule", NULL, 228, &funcAccess, &haveAccess, ¶meters, &roleObject, &componentObject, roleName, componentName, &access_zv); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "invokerule", NULL, 234, &funcAccess, &haveAccess, ¶meters, &roleObject, &componentObject, roleName, componentName, &access_zv); zephir_check_call_status(); RETURN_MM(); } @@ -1524,7 +1524,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, isRole) Z_PARAM_STR(roleName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&roleName_zv, roleName); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 248, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 249, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &roleName_zv)); } @@ -1548,7 +1548,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, isComponent) Z_PARAM_STR(componentName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&componentName_zv, componentName); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 245, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 246, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &componentName_zv)); } @@ -1575,7 +1575,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, setNoArgumentsDefaultAction) zephir_fetch_params_without_memory_grow(1, 0, &defaultAccess_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, defaultAccess); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 258, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 259, &_0); } /** @@ -1646,17 +1646,17 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, allowOrDeny) func = &func_sub; func = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 248, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 249, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "Role"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkexists", NULL, 215, &_0, &roleName_zv, &_1); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkexists", NULL, 221, &_0, &roleName_zv, &_1); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 245, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 246, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "Component"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkexists", NULL, 215, &_2, &componentName_zv, &_1); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkexists", NULL, 221, &_2, &componentName_zv, &_1); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 249, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 250, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&accessList, &_3); if (Z_TYPE_P(access) == IS_ARRAY) { zephir_is_iterable(access, 0, "phalcon/Acl/Adapter/Memory.zep", 771); @@ -1665,12 +1665,12 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, allowOrDeny) { ZEPHIR_INIT_NVAR(&accessName); ZVAL_COPY(&accessName, _4$$3); - ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildaccesskey", &_5, 217, &componentName_zv, &accessName); + ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildaccesskey", &_5, 223, &componentName_zv, &accessName); zephir_check_call_status(); if (UNEXPECTED(!(zephir_array_isset_value(&accessList, &accessKey)))) { ZEPHIR_INIT_NVAR(&_6$$5); object_init_ex(&_6$$5, phalcon_acl_exceptions_accessrulenotfound_ce); - ZEPHIR_CALL_METHOD(NULL, &_6$$5, "__construct", &_7, 229, &accessName, &componentName_zv); + ZEPHIR_CALL_METHOD(NULL, &_6$$5, "__construct", &_7, 235, &accessName, &componentName_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_6$$5, "phalcon/Acl/Adapter/Memory.zep", 767); ZEPHIR_MM_RESTORE(); @@ -1695,12 +1695,12 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, allowOrDeny) } ZEPHIR_CALL_METHOD(&accessName, access, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildaccesskey", &_5, 217, &componentName_zv, &accessName); + ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildaccesskey", &_5, 223, &componentName_zv, &accessName); zephir_check_call_status(); if (UNEXPECTED(!(zephir_array_isset_value(&accessList, &accessKey)))) { ZEPHIR_INIT_NVAR(&_10$$7); object_init_ex(&_10$$7, phalcon_acl_exceptions_accessrulenotfound_ce); - ZEPHIR_CALL_METHOD(NULL, &_10$$7, "__construct", &_7, 229, &accessName, &componentName_zv); + ZEPHIR_CALL_METHOD(NULL, &_10$$7, "__construct", &_7, 235, &accessName, &componentName_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_10$$7, "phalcon/Acl/Adapter/Memory.zep", 767); ZEPHIR_MM_RESTORE(); @@ -1715,7 +1715,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, allowOrDeny) { ZEPHIR_INIT_NVAR(&accessName); ZVAL_COPY(&accessName, _11$$3); - ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildkey", &_12, 227, &roleName_zv, &componentName_zv, &accessName); + ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildkey", &_12, 233, &roleName_zv, &componentName_zv, &accessName); zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("access"), &accessKey, action); if (Z_TYPE_P(func) != IS_NULL) { @@ -1740,7 +1740,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, allowOrDeny) } ZEPHIR_CALL_METHOD(&accessName, access, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildkey", &_12, 227, &roleName_zv, &componentName_zv, &accessName); + ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildkey", &_12, 233, &roleName_zv, &componentName_zv, &accessName); zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("access"), &accessKey, action); if (Z_TYPE_P(func) != IS_NULL) { @@ -1751,19 +1751,19 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, allowOrDeny) ZEPHIR_INIT_NVAR(&accessName); } else { if (!ZEPHIR_IS_STRING(access, "*")) { - ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildaccesskey", &_5, 217, &componentName_zv, access); + ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildaccesskey", &_5, 223, &componentName_zv, access); zephir_check_call_status(); if (UNEXPECTED(!(zephir_array_isset_value(&accessList, &accessKey)))) { ZEPHIR_INIT_VAR(&_15$$14); object_init_ex(&_15$$14, phalcon_acl_exceptions_accessrulenotfound_ce); - ZEPHIR_CALL_METHOD(NULL, &_15$$14, "__construct", &_7, 229, access, &componentName_zv); + ZEPHIR_CALL_METHOD(NULL, &_15$$14, "__construct", &_7, 235, access, &componentName_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_15$$14, "phalcon/Acl/Adapter/Memory.zep", 784); ZEPHIR_MM_RESTORE(); return; } } - ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildkey", &_12, 227, &roleName_zv, &componentName_zv, access); + ZEPHIR_CALL_METHOD(&accessKey, this_ptr, "buildkey", &_12, 233, &roleName_zv, &componentName_zv, access); zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("access"), &accessKey, action); if (Z_TYPE_P(func) != IS_NULL) { @@ -1876,7 +1876,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, canAccess) zephir_memory_observe(&access_zv); ZVAL_STR_COPY(&access_zv, access); zephir_memory_observe(&accessList); - zephir_read_property_cached(&accessList, this_ptr, _zephir_prop_0, 243, PH_NOISY_CC); + zephir_read_property_cached(&accessList, this_ptr, _zephir_prop_0, 244, PH_NOISY_CC); ZEPHIR_INIT_VAR(&roleComponentPrefix); ZEPHIR_CONCAT_VSVS(&roleComponentPrefix, &roleName_zv, "!", &componentName_zv, "!"); ZEPHIR_INIT_VAR(&accessKey); @@ -1894,11 +1894,11 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, canAccess) if (zephir_array_isset_value(&accessList, &accessKey)) { RETURN_CTOR(&accessKey); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 248, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, &roleName_zv)) { ZEPHIR_INIT_VAR(&checkRoleToInherits); array_init(&checkRoleToInherits); - zephir_read_property_cached(&_1$$6, this_ptr, _zephir_prop_1, 247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$6, this_ptr, _zephir_prop_1, 248, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_2$$6, &_1$$6, &roleName_zv, PH_NOISY | PH_READONLY, "phalcon/Acl/Adapter/Memory.zep", 869); zephir_is_iterable(&_2$$6, 0, "phalcon/Acl/Adapter/Memory.zep", 873); if (Z_TYPE_P(&_2$$6) == IS_ARRAY) { @@ -1907,7 +1907,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, canAccess) ZEPHIR_INIT_NVAR(&usedRoleToInherit); ZVAL_COPY(&usedRoleToInherit, _3$$6); ZEPHIR_MAKE_REF(&checkRoleToInherits); - ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_4, 219, &checkRoleToInherits, &usedRoleToInherit); + ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_4, 225, &checkRoleToInherits, &usedRoleToInherit); ZEPHIR_UNREF(&checkRoleToInherits); zephir_check_call_status(); } ZEND_HASH_FOREACH_END(); @@ -1930,7 +1930,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, canAccess) ZEPHIR_CALL_METHOD(&usedRoleToInherit, &_2$$6, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_MAKE_REF(&checkRoleToInherits); - ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_4, 219, &checkRoleToInherits, &usedRoleToInherit); + ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_4, 225, &checkRoleToInherits, &usedRoleToInherit); ZEPHIR_UNREF(&checkRoleToInherits); zephir_check_call_status(); } @@ -1969,9 +1969,9 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, canAccess) if (zephir_array_isset_value(&accessList, &accessKey)) { RETURN_CTOR(&accessKey); } - zephir_read_property_cached(&_9$$9, this_ptr, _zephir_prop_1, 247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$9, this_ptr, _zephir_prop_1, 248, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_9$$9, &checkRoleToInherit)) { - zephir_read_property_cached(&_10$$14, this_ptr, _zephir_prop_1, 247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$14, this_ptr, _zephir_prop_1, 248, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_11$$14, &_10$$14, &checkRoleToInherit, PH_NOISY | PH_READONLY, "phalcon/Acl/Adapter/Memory.zep", 925); zephir_is_iterable(&_11$$14, 0, "phalcon/Acl/Adapter/Memory.zep", 928); if (Z_TYPE_P(&_11$$14) == IS_ARRAY) { @@ -1980,7 +1980,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, canAccess) ZEPHIR_INIT_NVAR(&usedRoleToInherit); ZVAL_COPY(&usedRoleToInherit, _12$$14); ZEPHIR_MAKE_REF(&checkRoleToInherits); - ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_4, 219, &checkRoleToInherits, &usedRoleToInherit); + ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_4, 225, &checkRoleToInherits, &usedRoleToInherit); ZEPHIR_UNREF(&checkRoleToInherits); zephir_check_call_status(); } ZEND_HASH_FOREACH_END(); @@ -2003,7 +2003,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, canAccess) ZEPHIR_CALL_METHOD(&usedRoleToInherit, &_11$$14, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_MAKE_REF(&checkRoleToInherits); - ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_4, 219, &checkRoleToInherits, &usedRoleToInherit); + ZEPHIR_CALL_FUNCTION(NULL, "array_push", &_4, 225, &checkRoleToInherits, &usedRoleToInherit); ZEPHIR_UNREF(&checkRoleToInherits); zephir_check_call_status(); } @@ -2176,9 +2176,9 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) hasRole = 0; ZEPHIR_INIT_VAR(&reflectionFunction); object_init_ex(&reflectionFunction, zephir_get_internal_ce(SL("reflectionfunction"))); - ZEPHIR_CALL_METHOD(NULL, &reflectionFunction, "__construct", NULL, 230, funcAccess); + ZEPHIR_CALL_METHOD(NULL, &reflectionFunction, "__construct", NULL, 236, funcAccess); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&reflectionParameters, &reflectionFunction, "getparameters", NULL, 231); + ZEPHIR_CALL_METHOD(&reflectionParameters, &reflectionFunction, "getparameters", NULL, 237); zephir_check_call_status(); ZEPHIR_INIT_VAR(¶meterNumber); ZVAL_LONG(¶meterNumber, zephir_fast_count_int(&reflectionParameters)); @@ -2194,7 +2194,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) } ZEPHIR_INIT_VAR(¶metersForFunction); array_init(¶metersForFunction); - ZEPHIR_CALL_METHOD(&numberOfRequiredParameters, &reflectionFunction, "getnumberofrequiredparameters", NULL, 232); + ZEPHIR_CALL_METHOD(&numberOfRequiredParameters, &reflectionFunction, "getnumberofrequiredparameters", NULL, 238); zephir_check_call_status(); ZEPHIR_CPY_WRT(&userParametersSizeShouldBe, ¶meterNumber); zephir_is_iterable(&reflectionParameters, 0, "phalcon/Acl/Adapter/Memory.zep", 1055); @@ -2216,11 +2216,11 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&reflectionClass); object_init_ex(&reflectionClass, zephir_get_internal_ce(SL("reflectionclass"))); - ZEPHIR_CALL_METHOD(NULL, &reflectionClass, "__construct", &_4, 233, &className); + ZEPHIR_CALL_METHOD(NULL, &reflectionClass, "__construct", &_4, 239, &className); zephir_check_call_status(); _5$$5 = Z_TYPE_P(roleObject) != IS_NULL; if (_5$$5) { - ZEPHIR_CALL_METHOD(&_6$$5, &reflectionClass, "isinstance", &_7, 234, roleObject); + ZEPHIR_CALL_METHOD(&_6$$5, &reflectionClass, "isinstance", &_7, 240, roleObject); zephir_check_call_status(); _5$$5 = zephir_is_true(&_6$$5); } @@ -2237,7 +2237,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) } _9$$5 = Z_TYPE_P(componentObject) != IS_NULL; if (_9$$5) { - ZEPHIR_CALL_METHOD(&_10$$5, &reflectionClass, "isinstance", &_7, 234, componentObject); + ZEPHIR_CALL_METHOD(&_10$$5, &reflectionClass, "isinstance", &_7, 240, componentObject); zephir_check_call_status(); _9$$5 = zephir_is_true(&_10$$5); } @@ -2260,7 +2260,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) _14$$5 = _12$$5; if (_14$$5) { zephir_array_fetch(&_16$$5, parameters, ¶meterToCheck, PH_NOISY | PH_READONLY, "phalcon/Acl/Adapter/Memory.zep", 1032); - ZEPHIR_CALL_METHOD(&_15$$5, &reflectionClass, "isinstance", &_7, 234, &_16$$5); + ZEPHIR_CALL_METHOD(&_15$$5, &reflectionClass, "isinstance", &_7, 240, &_16$$5); zephir_check_call_status(); _14$$5 = !zephir_is_true(&_15$$5); } @@ -2270,7 +2270,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) ZEPHIR_INIT_NVAR(&_18$$8); zephir_array_fetch(&_19$$8, parameters, ¶meterToCheck, PH_NOISY | PH_READONLY, "phalcon/Acl/Adapter/Memory.zep", 1039); zephir_get_class(&_18$$8, &_19$$8, 0); - ZEPHIR_CALL_METHOD(&_20$$8, &reflectionClass, "getname", &_21, 235); + ZEPHIR_CALL_METHOD(&_20$$8, &reflectionClass, "getname", &_21, 241); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_22$$8); ZEPHIR_CONCAT_SSSVSVSVSVSVS(&_22$$8, "Your passed parameter does not have the ", "same class as the parameter in defined function ", "when checking if ", &roleName_zv, " can ", &access_zv, " ", &componentName_zv, ". Class passed: ", &_18$$8, " , Class in defined function: ", &_20$$8, "."); @@ -2317,11 +2317,11 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&reflectionClass); object_init_ex(&reflectionClass, zephir_get_internal_ce(SL("reflectionclass"))); - ZEPHIR_CALL_METHOD(NULL, &reflectionClass, "__construct", &_4, 233, &className); + ZEPHIR_CALL_METHOD(NULL, &reflectionClass, "__construct", &_4, 239, &className); zephir_check_call_status(); _28$$11 = Z_TYPE_P(roleObject) != IS_NULL; if (_28$$11) { - ZEPHIR_CALL_METHOD(&_29$$11, &reflectionClass, "isinstance", &_7, 234, roleObject); + ZEPHIR_CALL_METHOD(&_29$$11, &reflectionClass, "isinstance", &_7, 240, roleObject); zephir_check_call_status(); _28$$11 = zephir_is_true(&_29$$11); } @@ -2338,7 +2338,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) } _31$$11 = Z_TYPE_P(componentObject) != IS_NULL; if (_31$$11) { - ZEPHIR_CALL_METHOD(&_32$$11, &reflectionClass, "isinstance", &_7, 234, componentObject); + ZEPHIR_CALL_METHOD(&_32$$11, &reflectionClass, "isinstance", &_7, 240, componentObject); zephir_check_call_status(); _31$$11 = zephir_is_true(&_32$$11); } @@ -2361,7 +2361,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) _36$$11 = _34$$11; if (_36$$11) { zephir_array_fetch(&_38$$11, parameters, ¶meterToCheck, PH_NOISY | PH_READONLY, "phalcon/Acl/Adapter/Memory.zep", 1032); - ZEPHIR_CALL_METHOD(&_37$$11, &reflectionClass, "isinstance", &_7, 234, &_38$$11); + ZEPHIR_CALL_METHOD(&_37$$11, &reflectionClass, "isinstance", &_7, 240, &_38$$11); zephir_check_call_status(); _36$$11 = !zephir_is_true(&_37$$11); } @@ -2371,7 +2371,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) ZEPHIR_INIT_NVAR(&_40$$14); zephir_array_fetch(&_41$$14, parameters, ¶meterToCheck, PH_NOISY | PH_READONLY, "phalcon/Acl/Adapter/Memory.zep", 1039); zephir_get_class(&_40$$14, &_41$$14, 0); - ZEPHIR_CALL_METHOD(&_42$$14, &reflectionClass, "getname", &_21, 235); + ZEPHIR_CALL_METHOD(&_42$$14, &reflectionClass, "getname", &_21, 241); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_43$$14); ZEPHIR_CONCAT_SSSVSVSVSVSVS(&_43$$14, "Your passed parameter does not have the ", "same class as the parameter in defined function ", "when checking if ", &roleName_zv, " can ", &access_zv, " ", &componentName_zv, ". Class passed: ", &_40$$14, " , Class in defined function: ", &_42$$14, "."); @@ -2389,7 +2389,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) } } ZEPHIR_INIT_NVAR(&reflectionParameter); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 255, &userParametersSizeShouldBe); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 256, &userParametersSizeShouldBe); if (UNEXPECTED(ZEPHIR_LT_LONG(&userParametersSizeShouldBe, zephir_fast_count_int(parameters)))) { ZEPHIR_INIT_VAR(&_45$$16); ZEPHIR_CONCAT_SSVSVSVS(&_45$$16, "Number of parameters in array is higher than ", "the number of parameters in defined function when checking if '", &roleName_zv, "' can '", &access_zv, "' '", &componentName_zv, "'. Extra parameters will be ignored."); @@ -2405,7 +2405,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) zephir_check_call_status(); _48$$18 = haveAccess == 1; if (_48$$18) { - zephir_read_property_cached(&_49$$18, this_ptr, _zephir_prop_1, 258, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_49$$18, this_ptr, _zephir_prop_1, 259, PH_NOISY_CC | PH_READONLY); _48$$18 = ZEPHIR_IS_LONG(&_49$$18, 1); } RETURN_MM_BOOL(_48$$18); @@ -2470,7 +2470,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, toComponentName) } ZEPHIR_INIT_VAR(&_0$$3); object_init_ex(&_0$$3, phalcon_acl_exceptions_invalidcomponentimplementation_ce); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 236); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 242); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$3, "phalcon/Acl/Adapter/Memory.zep", 1113); ZEPHIR_MM_RESTORE(); @@ -2510,7 +2510,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, toRoleName) } ZEPHIR_INIT_VAR(&_0$$3); object_init_ex(&_0$$3, phalcon_acl_exceptions_invalidroleimplementation_ce); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 237); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 243); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$3, "phalcon/Acl/Adapter/Memory.zep", 1133); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/acl/adapter/storage.zep.c b/ext/phalcon/acl/adapter/storage.zep.c index 57ebbb2123..cff5a502f2 100644 --- a/ext/phalcon/acl/adapter/storage.zep.c +++ b/ext/phalcon/acl/adapter/storage.zep.c @@ -103,8 +103,8 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, __construct) zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 361, storage); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 362, &key_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 370, storage); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 371, &key_zv); ZEPHIR_CALL_PARENT(NULL, phalcon_acl_adapter_storage_ce, getThis(), "__construct", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, this_ptr, "load", NULL, 0); @@ -204,12 +204,12 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, load) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 361, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 362, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 370, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 371, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&data, &_0, "get", NULL, 0, &_1); zephir_check_call_status(); if (Z_TYPE_P(&data) == IS_OBJECT) { - ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "normalizetoarray", NULL, 312, &data); + ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "normalizetoarray", NULL, 324, &data); zephir_check_call_status(); ZEPHIR_CPY_WRT(&data, &_2$$3); } @@ -287,7 +287,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, load) ZVAL_COPY(&description, _18); ZEPHIR_INIT_NVAR(&_21$$8); object_init_ex(&_21$$8, phalcon_acl_role_ce); - ZEPHIR_CALL_METHOD(NULL, &_21$$8, "__construct", &_22, 221, &name, &description); + ZEPHIR_CALL_METHOD(NULL, &_21$$8, "__construct", &_22, 227, &name, &description); zephir_check_call_status(); zephir_array_update_zval(&rebuiltRoles, &name, &_21$$8, PH_COPY | PH_SEPARATE); } ZEND_HASH_FOREACH_END(); @@ -313,7 +313,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, load) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_25$$9); object_init_ex(&_25$$9, phalcon_acl_role_ce); - ZEPHIR_CALL_METHOD(NULL, &_25$$9, "__construct", &_22, 221, &name, &description); + ZEPHIR_CALL_METHOD(NULL, &_25$$9, "__construct", &_22, 227, &name, &description); zephir_check_call_status(); zephir_array_update_zval(&rebuiltRoles, &name, &_25$$9, PH_COPY | PH_SEPARATE); } @@ -337,7 +337,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, load) ZVAL_COPY(&description, _27); ZEPHIR_INIT_NVAR(&_30$$10); object_init_ex(&_30$$10, phalcon_acl_component_ce); - ZEPHIR_CALL_METHOD(NULL, &_30$$10, "__construct", &_31, 213, &name, &description); + ZEPHIR_CALL_METHOD(NULL, &_30$$10, "__construct", &_31, 219, &name, &description); zephir_check_call_status(); zephir_array_update_zval(&rebuiltComponents, &name, &_30$$10, PH_COPY | PH_SEPARATE); } ZEND_HASH_FOREACH_END(); @@ -363,7 +363,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, load) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_34$$11); object_init_ex(&_34$$11, phalcon_acl_component_ce); - ZEPHIR_CALL_METHOD(NULL, &_34$$11, "__construct", &_31, 213, &name, &description); + ZEPHIR_CALL_METHOD(NULL, &_34$$11, "__construct", &_31, 219, &name, &description); zephir_check_call_status(); zephir_array_update_zval(&rebuiltComponents, &name, &_34$$11, PH_COPY | PH_SEPARATE); } @@ -371,15 +371,15 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, load) ZEPHIR_INIT_NVAR(&description); ZEPHIR_INIT_NVAR(&name); zephir_array_fetch_string(&_35, &data, SL("access"), PH_NOISY | PH_READONLY, "phalcon/Acl/Adapter/Storage.zep", 119); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 363, &_35); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 372, &_35); zephir_array_fetch_string(&_36, &data, SL("accessList"), PH_NOISY | PH_READONLY, "phalcon/Acl/Adapter/Storage.zep", 120); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 364, &_36); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 365, &rebuiltComponents); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 373, &_36); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 374, &rebuiltComponents); zephir_array_fetch_string(&_37, &data, SL("componentsNames"), PH_NOISY | PH_READONLY, "phalcon/Acl/Adapter/Storage.zep", 122); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 366, &_37); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 367, &rebuiltRoles); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 375, &_37); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 376, &rebuiltRoles); zephir_array_fetch_string(&_38, &data, SL("roleInherits"), PH_NOISY | PH_READONLY, "phalcon/Acl/Adapter/Storage.zep", 124); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 368, &_38); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 377, &_38); ZEPHIR_INIT_VAR(&_39); if (zephir_array_isset_value_string(&data, SL("defaultAccess"))) { ZEPHIR_OBS_NVAR(&_39); @@ -388,7 +388,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, load) ZEPHIR_INIT_NVAR(&_39); ZVAL_LONG(&_39, 0); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 369, &_39); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 378, &_39); ZEPHIR_INIT_VAR(&_40); if (zephir_array_isset_value_string(&data, SL("noArgumentsDefaultAction"))) { ZEPHIR_OBS_NVAR(&_40); @@ -397,7 +397,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, load) ZEPHIR_INIT_NVAR(&_40); ZVAL_LONG(&_40, 0); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 370, &_40); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 379, &_40); RETURN_MM_BOOL(1); } @@ -487,10 +487,10 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, save) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 363, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 372, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&access, &_0); ZEPHIR_INIT_VAR(&_1); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 371, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 380, PH_NOISY_CC | PH_READONLY); zephir_array_keys(&_1, &_0); zephir_is_iterable(&_1, 0, "phalcon/Acl/Adapter/Storage.zep", 146); ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_1), _2) @@ -504,7 +504,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, save) ZEPHIR_INIT_NVAR(&accessKey); ZEPHIR_INIT_VAR(&components); array_init(&components); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 365, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 374, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_4, 0, "phalcon/Acl/Adapter/Storage.zep", 151); if (Z_TYPE_P(&_4) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_4), _6, _7, _5) @@ -550,7 +550,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, save) ZEPHIR_INIT_NVAR(&componentName); ZEPHIR_INIT_VAR(&roles); array_init(&roles); - zephir_read_property_cached(&_12, this_ptr, _zephir_prop_3, 367, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12, this_ptr, _zephir_prop_3, 376, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_12, 0, "phalcon/Acl/Adapter/Storage.zep", 156); if (Z_TYPE_P(&_12) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_12), _14, _15, _13) @@ -594,28 +594,28 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, save) } ZEPHIR_INIT_NVAR(&roleObject); ZEPHIR_INIT_NVAR(&roleName); - zephir_read_property_cached(&_20, this_ptr, _zephir_prop_4, 361, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_21, this_ptr, _zephir_prop_5, 362, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20, this_ptr, _zephir_prop_4, 370, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21, this_ptr, _zephir_prop_5, 371, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_22); zephir_create_array(&_22, 9, 0); add_assoc_long_ex(&_22, SL("version"), 1); zephir_array_update_string(&_22, SL("access"), &access, PH_COPY | PH_SEPARATE); zephir_memory_observe(&_23); - zephir_read_property_cached(&_23, this_ptr, _zephir_prop_6, 364, PH_NOISY_CC); + zephir_read_property_cached(&_23, this_ptr, _zephir_prop_6, 373, PH_NOISY_CC); zephir_array_update_string(&_22, SL("accessList"), &_23, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_22, SL("components"), &components, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_23); - zephir_read_property_cached(&_23, this_ptr, _zephir_prop_7, 366, PH_NOISY_CC); + zephir_read_property_cached(&_23, this_ptr, _zephir_prop_7, 375, PH_NOISY_CC); zephir_array_update_string(&_22, SL("componentsNames"), &_23, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_22, SL("roles"), &roles, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_23); - zephir_read_property_cached(&_23, this_ptr, _zephir_prop_8, 368, PH_NOISY_CC); + zephir_read_property_cached(&_23, this_ptr, _zephir_prop_8, 377, PH_NOISY_CC); zephir_array_update_string(&_22, SL("roleInherits"), &_23, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_23); - zephir_read_property_cached(&_23, this_ptr, _zephir_prop_9, 369, PH_NOISY_CC); + zephir_read_property_cached(&_23, this_ptr, _zephir_prop_9, 378, PH_NOISY_CC); zephir_array_update_string(&_22, SL("defaultAccess"), &_23, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_23); - zephir_read_property_cached(&_23, this_ptr, _zephir_prop_10, 370, PH_NOISY_CC); + zephir_read_property_cached(&_23, this_ptr, _zephir_prop_10, 379, PH_NOISY_CC); zephir_array_update_string(&_22, SL("noArgumentsDefaultAction"), &_23, PH_COPY | PH_SEPARATE); ZEPHIR_RETURN_CALL_METHOD(&_20, "set", NULL, 0, &_21, &_22); zephir_check_call_status(); @@ -654,7 +654,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, normalizeToArray) zephir_fetch_params(1, 1, 0, &value); ZEPHIR_SEPARATE_PARAM(value); if (Z_TYPE_P(value) == IS_OBJECT) { - ZEPHIR_CALL_FUNCTION(&_0$$3, "get_object_vars", NULL, 313, value); + ZEPHIR_CALL_FUNCTION(&_0$$3, "get_object_vars", NULL, 325, value); zephir_check_call_status(); ZEPHIR_CPY_WRT(value, &_0$$3); } @@ -676,7 +676,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, normalizeToArray) } ZEPHIR_INIT_NVAR(&item); ZVAL_COPY(&item, _1); - ZEPHIR_CALL_METHOD(&_4$$5, this_ptr, "normalizetoarray", &_5, 312, &item); + ZEPHIR_CALL_METHOD(&_4$$5, this_ptr, "normalizetoarray", &_5, 324, &item); zephir_check_call_status(); zephir_array_update_zval(&result, &key, &_4$$5, PH_COPY | PH_SEPARATE); } ZEND_HASH_FOREACH_END(); @@ -700,7 +700,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, normalizeToArray) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&item, value, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_8$$6, this_ptr, "normalizetoarray", &_5, 312, &item); + ZEPHIR_CALL_METHOD(&_8$$6, this_ptr, "normalizetoarray", &_5, 324, &item); zephir_check_call_status(); zephir_array_update_zval(&result, &key, &_8$$6, PH_COPY | PH_SEPARATE); } diff --git a/ext/phalcon/acl/component.zep.c b/ext/phalcon/acl/component.zep.c index 9b85a052a2..a12c153823 100644 --- a/ext/phalcon/acl/component.zep.c +++ b/ext/phalcon/acl/component.zep.c @@ -78,8 +78,8 @@ PHP_METHOD(Phalcon_Acl_Component, __construct) ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_acl_exceptions_forbiddenwildcard_ce, "component", "phalcon/Acl/Component.zep", 26); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 372, &name_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 373, &description_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 381, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 382, &description_zv); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/acl/role.zep.c b/ext/phalcon/acl/role.zep.c index 615fb27a4f..891fd63a6f 100644 --- a/ext/phalcon/acl/role.zep.c +++ b/ext/phalcon/acl/role.zep.c @@ -78,8 +78,8 @@ PHP_METHOD(Phalcon_Acl_Role, __construct) ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_acl_exceptions_forbiddenwildcard_ce, "role", "phalcon/Acl/Role.zep", 26); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 374, &name_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 375, &description_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 383, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 384, &description_zv); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/adr/application.zep.c b/ext/phalcon/adr/application.zep.c new file mode 100644 index 0000000000..57754907b8 --- /dev/null +++ b/ext/phalcon/adr/application.zep.c @@ -0,0 +1,292 @@ + +#ifdef HAVE_CONFIG_H +#include "../../ext_config.h" +#endif + +#include +#include "../../php_ext.h" +#include "../../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/object.h" +#include "kernel/memory.h" +#include "kernel/fcall.h" +#include "kernel/operators.h" +#include "kernel/exception.h" + + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ +/** + * Routes the request, writes the matched attributes onto it, dispatches the + * Action and returns the response. A single try/catch routes any error through + * the error responder; if that itself fails, a bare 500 is returned so nothing + * escapes uncaught. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Application) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\ADR, Application, phalcon, adr_application, phalcon_adr_application_method_entry, ZEND_ACC_FINAL_CLASS); + + /** + * @var DispatcherInterface + */ + zend_declare_property_null(phalcon_adr_application_ce, SL("dispatcher"), ZEND_ACC_PROTECTED); + /** + * @var ErrorResponder + */ + zend_declare_property_null(phalcon_adr_application_ce, SL("errorResponder"), ZEND_ACC_PROTECTED); + /** + * @var Manager + */ + zend_declare_property_null(phalcon_adr_application_ce, SL("events"), ZEND_ACC_PROTECTED); + /** + * @var RouterInterface + */ + zend_declare_property_null(phalcon_adr_application_ce, SL("router"), ZEND_ACC_PROTECTED); + zend_class_implements(phalcon_adr_application_ce, 1, phalcon_contracts_adr_application_ce); + return SUCCESS; +} + +PHP_METHOD(Phalcon_ADR_Application, __construct) +{ + zval *router, router_sub, *dispatcher, dispatcher_sub, *errorResponder, errorResponder_sub, *events, events_sub; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&router_sub); + ZVAL_UNDEF(&dispatcher_sub); + ZVAL_UNDEF(&errorResponder_sub); + ZVAL_UNDEF(&events_sub); + static zend_string *_zephir_prop_0 = NULL; + static zend_string *_zephir_prop_1 = NULL; + static zend_string *_zephir_prop_2 = NULL; + static zend_string *_zephir_prop_3 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("router", 6, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("dispatcher", 10, 1); + } + if (UNEXPECTED(!_zephir_prop_2)) { + _zephir_prop_2 = zend_string_init("errorResponder", 14, 1); + } + if (UNEXPECTED(!_zephir_prop_3)) { + _zephir_prop_3 = zend_string_init("events", 6, 1); + } + + ZEND_PARSE_PARAMETERS_START(4, 4) + Z_PARAM_OBJECT_OF_CLASS(router, phalcon_contracts_adr_router_router_ce) + Z_PARAM_OBJECT_OF_CLASS(dispatcher, phalcon_contracts_adr_dispatcher_ce) + Z_PARAM_OBJECT_OF_CLASS(errorResponder, phalcon_adr_errorresponder_ce) + Z_PARAM_OBJECT_OF_CLASS(events, phalcon_contracts_events_manager_ce) + ZEND_PARSE_PARAMETERS_END(); + zephir_fetch_params_without_memory_grow(4, 0, &router, &dispatcher, &errorResponder, &events); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 329, router); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 330, dispatcher); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 331, errorResponder); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 332, events); +} + +PHP_METHOD(Phalcon_ADR_Application, handle) +{ + zend_bool _13$$3; + zend_string *_8$$3; + zend_ulong _7$$3; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zephir_fcall_cache_entry *_10 = NULL, *_11 = NULL, *_15 = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *request, request_sub, match, response, key, value, exception, _0, _1, _26, _27, _2$$3, _5$$3, *_6$$3, _12$$3, _16$$3, _17$$3, _18$$3, _3$$4, _4$$4, _9$$5, _14$$6, _19$$8, _20$$8, _21$$7, _22$$7, _23$$9, _24$$9, _25$$9; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&request_sub); + ZVAL_UNDEF(&match); + ZVAL_UNDEF(&response); + ZVAL_UNDEF(&key); + ZVAL_UNDEF(&value); + ZVAL_UNDEF(&exception); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_26); + ZVAL_UNDEF(&_27); + ZVAL_UNDEF(&_2$$3); + ZVAL_UNDEF(&_5$$3); + ZVAL_UNDEF(&_12$$3); + ZVAL_UNDEF(&_16$$3); + ZVAL_UNDEF(&_17$$3); + ZVAL_UNDEF(&_18$$3); + ZVAL_UNDEF(&_3$$4); + ZVAL_UNDEF(&_4$$4); + ZVAL_UNDEF(&_9$$5); + ZVAL_UNDEF(&_14$$6); + ZVAL_UNDEF(&_19$$8); + ZVAL_UNDEF(&_20$$8); + ZVAL_UNDEF(&_21$$7); + ZVAL_UNDEF(&_22$$7); + ZVAL_UNDEF(&_23$$9); + ZVAL_UNDEF(&_24$$9); + ZVAL_UNDEF(&_25$$9); + static zend_string *_zephir_prop_0 = NULL; + static zend_string *_zephir_prop_1 = NULL; + static zend_string *_zephir_prop_2 = NULL; + static zend_string *_zephir_prop_3 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("events", 6, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("router", 6, 1); + } + if (UNEXPECTED(!_zephir_prop_2)) { + _zephir_prop_2 = zend_string_init("dispatcher", 10, 1); + } + if (UNEXPECTED(!_zephir_prop_3)) { + _zephir_prop_3 = zend_string_init("errorResponder", 14, 1); + } + + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT_OF_CLASS(request, phalcon_contracts_http_attributerequestinterface_ce) + ZEND_PARSE_PARAMETERS_END(); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + zephir_fetch_params(1, 1, 0, &request); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 332, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "application:beforeHandle"); + ZEPHIR_CALL_METHOD(NULL, &_0, "fire", NULL, 0, &_1, this_ptr, request); + zephir_check_call_status(); + + /* try_start_1: */ + + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 329, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(&match, &_2$$3, "match", NULL, 0, request); + zephir_check_call_status_or_jump(try_end_1); + if (Z_TYPE_P(&match) == IS_NULL) { + ZEPHIR_INIT_VAR(&_3$$4); + object_init_ex(&_3$$4, phalcon_adr_router_exceptions_routenotfound_ce); + ZEPHIR_INIT_VAR(&_4$$4); + ZVAL_STRING(&_4$$4, "No route matched the request."); + ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", NULL, 8, &_4$$4); + zephir_check_call_status_or_jump(try_end_1); + zephir_throw_exception_debug(&_3$$4, "phalcon/ADR/Application.zep", 76); + goto try_end_1; + + } + ZEPHIR_CALL_METHOD(&_5$$3, &match, "getattributes", NULL, 0); + zephir_check_call_status_or_jump(try_end_1); + zephir_is_iterable(&_5$$3, 0, "phalcon/ADR/Application.zep", 83); + if (Z_TYPE_P(&_5$$3) == IS_ARRAY) { + ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_5$$3), _7$$3, _8$$3, _6$$3) + { + ZEPHIR_INIT_NVAR(&key); + if (_8$$3 != NULL) { + ZVAL_STR_COPY(&key, _8$$3); + } else { + ZVAL_LONG(&key, _7$$3); + } + ZEPHIR_INIT_NVAR(&value); + ZVAL_COPY(&value, _6$$3); + ZEPHIR_CALL_METHOD(&_9$$5, request, "getattributes", &_10, 0); + zephir_check_call_status_or_jump(try_end_1); + ZEPHIR_CALL_METHOD(NULL, &_9$$5, "set", &_11, 0, &key, &value); + zephir_check_call_status_or_jump(try_end_1); + } ZEND_HASH_FOREACH_END(); + } else { + ZEPHIR_CALL_METHOD(NULL, &_5$$3, "rewind", NULL, 0); + zephir_check_call_status(); + _13$$3 = 1; + while (1) { + if (_13$$3) { + _13$$3 = 0; + } else { + ZEPHIR_CALL_METHOD(NULL, &_5$$3, "next", NULL, 0); + zephir_check_call_status(); + } + ZEPHIR_CALL_METHOD(&_12$$3, &_5$$3, "valid", NULL, 0); + zephir_check_call_status(); + if (!zend_is_true(&_12$$3)) { + break; + } + ZEPHIR_CALL_METHOD(&key, &_5$$3, "key", NULL, 0); + zephir_check_call_status(); + ZEPHIR_CALL_METHOD(&value, &_5$$3, "current", NULL, 0); + zephir_check_call_status(); + ZEPHIR_CALL_METHOD(&_14$$6, request, "getattributes", &_15, 0); + zephir_check_call_status_or_jump(try_end_1); + ZEPHIR_CALL_METHOD(NULL, &_14$$6, "set", &_11, 0, &key, &value); + zephir_check_call_status_or_jump(try_end_1); + } + } + ZEPHIR_INIT_NVAR(&value); + ZEPHIR_INIT_NVAR(&key); + zephir_read_property_cached(&_16$$3, this_ptr, _zephir_prop_2, 330, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(&_17$$3, &match, "getaction", NULL, 0); + zephir_check_call_status_or_jump(try_end_1); + ZEPHIR_CALL_METHOD(&_18$$3, &match, "getmiddleware", NULL, 0); + zephir_check_call_status_or_jump(try_end_1); + ZEPHIR_CALL_METHOD(&response, &_16$$3, "dispatch", NULL, 0, &_17$$3, request, &_18$$3); + zephir_check_call_status_or_jump(try_end_1); + + try_end_1: + + if (EG(exception)) { + ZEPHIR_INIT_NVAR(&_1); + ZVAL_OBJ(&_1, EG(exception)); + Z_ADDREF_P(&_1); + if (zephir_is_instance_of(&_1, SL("Throwable"))) { + zend_clear_exception(); + ZEPHIR_CPY_WRT(&exception, &_1); + + /* try_start_2: */ + + zephir_read_property_cached(&_19$$8, this_ptr, _zephir_prop_3, 331, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_20$$8); + object_init_ex(&_20$$8, phalcon_http_response_ce); + ZEPHIR_CALL_METHOD(NULL, &_20$$8, "__construct", NULL, 300); + zephir_check_call_status_or_jump(try_end_2); + ZEPHIR_CALL_METHOD(&response, &_19$$8, "handle", NULL, 0, request, &_20$$8, &exception); + zephir_check_call_status_or_jump(try_end_2); + + try_end_2: + + if (EG(exception)) { + ZEPHIR_INIT_VAR(&_21$$7); + ZVAL_OBJ(&_21$$7, EG(exception)); + Z_ADDREF_P(&_21$$7); + ZEPHIR_INIT_VAR(&_22$$7); + if (zephir_is_instance_of(&_21$$7, SL("Throwable"))) { + zend_clear_exception(); + ZEPHIR_CPY_WRT(&_22$$7, &_21$$7); + ZEPHIR_INIT_NVAR(&response); + object_init_ex(&response, phalcon_http_response_ce); + ZEPHIR_CALL_METHOD(NULL, &response, "__construct", NULL, 300); + zephir_check_call_status(); + ZVAL_LONG(&_24$$9, 500); + ZEPHIR_CALL_METHOD(&_23$$9, &response, "setstatuscode", NULL, 301, &_24$$9); + zephir_check_call_status(); + ZEPHIR_INIT_VAR(&_25$$9); + ZVAL_STRING(&_25$$9, "Internal Server Error"); + ZEPHIR_CALL_METHOD(NULL, &_23$$9, "setcontent", NULL, 0, &_25$$9); + zephir_check_call_status(); + } + } + } + } + zephir_read_property_cached(&_26, this_ptr, _zephir_prop_0, 332, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_27); + ZVAL_STRING(&_27, "application:afterHandle"); + ZEPHIR_CALL_METHOD(NULL, &_26, "fire", NULL, 0, &_27, this_ptr, &response); + zephir_check_call_status(); + RETURN_CCTOR(&response); +} + diff --git a/ext/phalcon/adr/application.zep.h b/ext/phalcon/adr/application.zep.h new file mode 100644 index 0000000000..f319efbcab --- /dev/null +++ b/ext/phalcon/adr/application.zep.h @@ -0,0 +1,24 @@ + +extern zend_class_entry *phalcon_adr_application_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Application); + +PHP_METHOD(Phalcon_ADR_Application, __construct); +PHP_METHOD(Phalcon_ADR_Application, handle); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_adr_application___construct, 0, 0, 4) + ZEND_ARG_OBJ_INFO(0, router, Phalcon\\Contracts\\ADR\\Router\\Router, 0) + ZEND_ARG_OBJ_INFO(0, dispatcher, Phalcon\\Contracts\\ADR\\Dispatcher, 0) + ZEND_ARG_OBJ_INFO(0, errorResponder, Phalcon\\ADR\\ErrorResponder, 0) + ZEND_ARG_OBJ_INFO(0, events, Phalcon\\Contracts\\Events\\Manager, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_application_handle, 0, 1, Phalcon\\Http\\ResponseInterface, 0) + ZEND_ARG_OBJ_INFO(0, request, Phalcon\\Contracts\\Http\\AttributeRequestInterface, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_adr_application_method_entry) { + PHP_ME(Phalcon_ADR_Application, __construct, arginfo_phalcon_adr_application___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) + PHP_ME(Phalcon_ADR_Application, handle, arginfo_phalcon_adr_application_handle, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/phalcon/adr/container/adrprovider.zep.c b/ext/phalcon/adr/container/adrprovider.zep.c new file mode 100644 index 0000000000..7f4181e387 --- /dev/null +++ b/ext/phalcon/adr/container/adrprovider.zep.c @@ -0,0 +1,162 @@ + +#ifdef HAVE_CONFIG_H +#include "../../../ext_config.h" +#endif + +#include +#include "../../../php_ext.h" +#include "../../../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/fcall.h" +#include "kernel/memory.h" +#include "kernel/object.h" + + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ +/** + * Registers the ADR seams in the container; concretes autowire. + * + * Used instead of `Phalcon\Container\Provider\Web` for ADR applications. It + * shares the short aliases (`request`/`response`/`router`/`eventsManager`) but + * binds the ADR contracts behind them. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Container_AdrProvider) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\ADR\\Container, AdrProvider, phalcon, adr_container_adrprovider, phalcon_adr_container_adrprovider_method_entry, 0); + + zend_class_implements(phalcon_adr_container_adrprovider_ce, 1, phalcon_contracts_container_service_provider_ce); + return SUCCESS; +} + +/** + * @param Collection $services + * + * @return void + */ +PHP_METHOD(Phalcon_ADR_Container_AdrProvider, provide) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *services, services_sub, _0, _1, _2, _3; + + ZVAL_UNDEF(&services_sub); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); + ZVAL_UNDEF(&_3); + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT_OF_CLASS(services, phalcon_contracts_container_service_collection_ce) + ZEND_PARSE_PARAMETERS_END(); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + zephir_fetch_params(1, 1, 0, &services); + ZEPHIR_INIT_VAR(&_0); + ZVAL_STRING(&_0, "Phalcon\\Contracts\\Events\\Manager"); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "Phalcon\\Events\\Manager"); + ZEPHIR_CALL_METHOD(NULL, services, "bind", NULL, 0, &_0, &_1); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_0); + ZVAL_STRING(&_0, "Phalcon\\Contracts\\Events\\Manager"); + ZEPHIR_INIT_NVAR(&_1); + ZVAL_STRING(&_1, "eventsManager"); + ZEPHIR_CALL_METHOD(NULL, services, "setalias", NULL, 0, &_0, &_1); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_0); + ZVAL_STRING(&_0, "Phalcon\\Contracts\\Http\\AttributeRequestInterface"); + ZEPHIR_INIT_NVAR(&_1); + ZVAL_STRING(&_1, "Phalcon\\Http\\Request"); + ZEPHIR_CALL_METHOD(NULL, services, "bind", NULL, 0, &_0, &_1); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_0); + ZVAL_STRING(&_0, "Phalcon\\Contracts\\Http\\AttributeRequestInterface"); + ZEPHIR_INIT_NVAR(&_1); + ZVAL_STRING(&_1, "request"); + ZEPHIR_CALL_METHOD(NULL, services, "setalias", NULL, 0, &_0, &_1); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_0); + ZVAL_STRING(&_0, "Phalcon\\Http\\ResponseInterface"); + ZEPHIR_INIT_NVAR(&_1); + ZVAL_STRING(&_1, "Phalcon\\Http\\Response"); + ZEPHIR_CALL_METHOD(NULL, services, "bind", NULL, 0, &_0, &_1); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_0); + ZVAL_STRING(&_0, "Phalcon\\Http\\ResponseInterface"); + ZEPHIR_INIT_NVAR(&_1); + ZVAL_STRING(&_1, "response"); + ZEPHIR_CALL_METHOD(NULL, services, "setalias", NULL, 0, &_0, &_1); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_0); + ZEPHIR_INIT_NVAR(&_0); + zephir_create_closure_ex(&_0, NULL, phalcon_4__closure_ce, SL("__invoke")); + ZEPHIR_INIT_NVAR(&_1); + ZVAL_STRING(&_1, "Phalcon\\Contracts\\Logger\\Logger"); + ZEPHIR_CALL_METHOD(NULL, services, "set", NULL, 0, &_1, &_0); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_1); + ZVAL_STRING(&_1, "Phalcon\\Contracts\\ADR\\Responder\\Responder"); + ZEPHIR_INIT_VAR(&_2); + ZVAL_STRING(&_2, "Phalcon\\ADR\\Responder\\JsonResponder"); + ZEPHIR_CALL_METHOD(NULL, services, "bind", NULL, 0, &_1, &_2); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_1); + ZVAL_STRING(&_1, "Phalcon\\Contracts\\ADR\\Responder\\Responder"); + ZEPHIR_INIT_NVAR(&_2); + ZVAL_STRING(&_2, "responder"); + ZEPHIR_CALL_METHOD(NULL, services, "setalias", NULL, 0, &_1, &_2); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_1); + ZEPHIR_INIT_NVAR(&_1); + zephir_create_closure_ex(&_1, NULL, phalcon_5__closure_ce, SL("__invoke")); + ZEPHIR_INIT_NVAR(&_2); + ZVAL_STRING(&_2, "Phalcon\\Contracts\\ADR\\Dispatcher"); + ZEPHIR_CALL_METHOD(NULL, services, "set", NULL, 0, &_2, &_1); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_2); + ZVAL_STRING(&_2, "Phalcon\\Contracts\\ADR\\Dispatcher"); + ZEPHIR_INIT_VAR(&_3); + ZVAL_STRING(&_3, "dispatcher"); + ZEPHIR_CALL_METHOD(NULL, services, "setalias", NULL, 0, &_2, &_3); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_2); + ZVAL_STRING(&_2, "Phalcon\\Contracts\\ADR\\Router\\Router"); + ZEPHIR_INIT_NVAR(&_3); + ZVAL_STRING(&_3, "Phalcon\\ADR\\Router\\Router"); + ZEPHIR_CALL_METHOD(NULL, services, "bind", NULL, 0, &_2, &_3); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_2); + ZVAL_STRING(&_2, "Phalcon\\Contracts\\ADR\\Router\\Router"); + ZEPHIR_INIT_NVAR(&_3); + ZVAL_STRING(&_3, "router"); + ZEPHIR_CALL_METHOD(NULL, services, "setalias", NULL, 0, &_2, &_3); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_2); + ZVAL_STRING(&_2, "Phalcon\\Contracts\\ADR\\Emitter\\Emitter"); + ZEPHIR_INIT_NVAR(&_3); + ZVAL_STRING(&_3, "Phalcon\\ADR\\Emitter\\SapiEmitter"); + ZEPHIR_CALL_METHOD(NULL, services, "bind", NULL, 0, &_2, &_3); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_2); + ZVAL_STRING(&_2, "Phalcon\\Contracts\\ADR\\Emitter\\Emitter"); + ZEPHIR_INIT_NVAR(&_3); + ZVAL_STRING(&_3, "emitter"); + ZEPHIR_CALL_METHOD(NULL, services, "setalias", NULL, 0, &_2, &_3); + zephir_check_call_status(); + ZEPHIR_MM_RESTORE(); +} + diff --git a/ext/phalcon/adr/container/adrprovider.zep.h b/ext/phalcon/adr/container/adrprovider.zep.h new file mode 100644 index 0000000000..6e441d6032 --- /dev/null +++ b/ext/phalcon/adr/container/adrprovider.zep.h @@ -0,0 +1,16 @@ + +extern zend_class_entry *phalcon_adr_container_adrprovider_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Container_AdrProvider); + +PHP_METHOD(Phalcon_ADR_Container_AdrProvider, provide); + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_container_adrprovider_provide, 0, 1, IS_VOID, 0) + + ZEND_ARG_OBJ_INFO(0, services, Phalcon\\Contracts\\Container\\Service\\Collection, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_adr_container_adrprovider_method_entry) { + PHP_ME(Phalcon_ADR_Container_AdrProvider, provide, arginfo_phalcon_adr_container_adrprovider_provide, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/phalcon/adr/dispatcher.zep.c b/ext/phalcon/adr/dispatcher.zep.c index 66308e15b8..849b8d5129 100644 --- a/ext/phalcon/adr/dispatcher.zep.c +++ b/ext/phalcon/adr/dispatcher.zep.c @@ -103,9 +103,9 @@ PHP_METHOD(Phalcon_ADR_Dispatcher, __construct) } else { zephir_get_arrval(&globalMiddleware, globalMiddleware_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 328, container); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 329, events); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 330, &globalMiddleware); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 333, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 334, events); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 335, &globalMiddleware); ZEPHIR_MM_RESTORE(); } @@ -165,7 +165,7 @@ PHP_METHOD(Phalcon_ADR_Dispatcher, dispatch) } else { zephir_get_arrval(&routeMiddleware, routeMiddleware_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 328, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 333, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&action, &_0, "getservice", NULL, 0, &actionClass_zv); zephir_check_call_status(); if (!(zephir_instance_of_ev(&action, phalcon_contracts_adr_action_ce))) { @@ -179,29 +179,29 @@ PHP_METHOD(Phalcon_ADR_Dispatcher, dispatch) ZEPHIR_MM_RESTORE(); return; } - ZEPHIR_CALL_METHOD(&_3, this_ptr, "resolveglobal", NULL, 294); + ZEPHIR_CALL_METHOD(&_3, this_ptr, "resolveglobal", NULL, 302); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_4, this_ptr, "resolveall", NULL, 295, &routeMiddleware); + ZEPHIR_CALL_METHOD(&_4, this_ptr, "resolveall", NULL, 303, &routeMiddleware); zephir_check_call_status(); ZEPHIR_INIT_VAR(&middleware); zephir_fast_array_merge(&middleware, &_3, &_4); ZEPHIR_INIT_VAR(&terminal); object_init_ex(&terminal, phalcon_adr_eventfulhandler_ce); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 329, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(NULL, &terminal, "__construct", NULL, 296, &action, &_5); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 334, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(NULL, &terminal, "__construct", NULL, 304, &action, &_5); zephir_check_call_status(); ZEPHIR_INIT_VAR(&pipeline); object_init_ex(&pipeline, phalcon_adr_pipeline_ce); - ZEPHIR_CALL_METHOD(NULL, &pipeline, "__construct", NULL, 297, &middleware, &terminal); + ZEPHIR_CALL_METHOD(NULL, &pipeline, "__construct", NULL, 305, &middleware, &terminal); zephir_check_call_status(); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 329, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 334, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_7); ZVAL_STRING(&_7, "pipeline:beforeDispatch"); ZEPHIR_CALL_METHOD(NULL, &_6, "fire", NULL, 0, &_7, this_ptr, request); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&response, &pipeline, "__invoke", NULL, 298, request); + ZEPHIR_CALL_METHOD(&response, &pipeline, "__invoke", NULL, 306, request); zephir_check_call_status(); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 329, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 334, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_7); ZVAL_STRING(&_7, "pipeline:afterDispatch"); ZEPHIR_CALL_METHOD(NULL, &_8, "fire", NULL, 0, &_7, this_ptr, &response); @@ -246,7 +246,7 @@ PHP_METHOD(Phalcon_ADR_Dispatcher, resolveAll) { ZEPHIR_INIT_NVAR(&className); ZVAL_COPY(&className, _0); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 328, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 333, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2$$3, &_1$$3, "getservice", NULL, 0, &className); zephir_check_call_status(); zephir_array_append(&result, &_2$$3, PH_SEPARATE, "phalcon/ADR/Dispatcher.zep", 91); @@ -269,7 +269,7 @@ PHP_METHOD(Phalcon_ADR_Dispatcher, resolveAll) } ZEPHIR_CALL_METHOD(&className, &classes, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 328, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 333, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_6$$4, &_5$$4, "getservice", NULL, 0, &className); zephir_check_call_status(); zephir_array_append(&result, &_6$$4, PH_SEPARATE, "phalcon/ADR/Dispatcher.zep", 91); @@ -300,12 +300,12 @@ PHP_METHOD(Phalcon_ADR_Dispatcher, resolveGlobal) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 331, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 336, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 330, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "resolveall", NULL, 295, &_2$$3); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 335, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "resolveall", NULL, 303, &_2$$3); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 331, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 336, &_1$$3); } RETURN_MM_MEMBER_TYPED(getThis(), "resolvedGlobal", IS_ARRAY); } diff --git a/ext/phalcon/adr/emitter/exceptions/headersalreadysent.zep.c b/ext/phalcon/adr/emitter/exceptions/headersalreadysent.zep.c new file mode 100644 index 0000000000..3e4ed0bd23 --- /dev/null +++ b/ext/phalcon/adr/emitter/exceptions/headersalreadysent.zep.c @@ -0,0 +1,38 @@ + +#ifdef HAVE_CONFIG_H +#include "../../../../ext_config.h" +#endif + +#include +#include "../../../../php_ext.h" +#include "../../../../ext.h" + +#include +#include +#include + +#include "kernel/main.h" + + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ +/** + * Thrown when the emitter is asked to send a response after headers have + * already been sent. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Emitter_Exceptions_HeadersAlreadySent) +{ + ZEPHIR_REGISTER_CLASS_EX(Phalcon\\ADR\\Emitter\\Exceptions, HeadersAlreadySent, phalcon, adr_emitter_exceptions_headersalreadysent, phalcon_adr_exceptions_exception_ce, NULL, 0); + + return SUCCESS; +} + diff --git a/ext/phalcon/adr/emitter/exceptions/headersalreadysent.zep.h b/ext/phalcon/adr/emitter/exceptions/headersalreadysent.zep.h new file mode 100644 index 0000000000..72aff73e84 --- /dev/null +++ b/ext/phalcon/adr/emitter/exceptions/headersalreadysent.zep.h @@ -0,0 +1,5 @@ + +extern zend_class_entry *phalcon_adr_emitter_exceptions_headersalreadysent_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Emitter_Exceptions_HeadersAlreadySent); + diff --git a/ext/phalcon/adr/emitter/exceptions/outputalreadysent.zep.c b/ext/phalcon/adr/emitter/exceptions/outputalreadysent.zep.c new file mode 100644 index 0000000000..43eb9b4ff2 --- /dev/null +++ b/ext/phalcon/adr/emitter/exceptions/outputalreadysent.zep.c @@ -0,0 +1,38 @@ + +#ifdef HAVE_CONFIG_H +#include "../../../../ext_config.h" +#endif + +#include +#include "../../../../php_ext.h" +#include "../../../../ext.h" + +#include +#include +#include + +#include "kernel/main.h" + + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ +/** + * Thrown when the emitter is asked to send a response after output has already + * been sent. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Emitter_Exceptions_OutputAlreadySent) +{ + ZEPHIR_REGISTER_CLASS_EX(Phalcon\\ADR\\Emitter\\Exceptions, OutputAlreadySent, phalcon, adr_emitter_exceptions_outputalreadysent, phalcon_adr_exceptions_exception_ce, NULL, 0); + + return SUCCESS; +} + diff --git a/ext/phalcon/adr/emitter/exceptions/outputalreadysent.zep.h b/ext/phalcon/adr/emitter/exceptions/outputalreadysent.zep.h new file mode 100644 index 0000000000..3247718dc8 --- /dev/null +++ b/ext/phalcon/adr/emitter/exceptions/outputalreadysent.zep.h @@ -0,0 +1,5 @@ + +extern zend_class_entry *phalcon_adr_emitter_exceptions_outputalreadysent_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Emitter_Exceptions_OutputAlreadySent); + diff --git a/ext/phalcon/adr/emitter/sapiemitter.zep.c b/ext/phalcon/adr/emitter/sapiemitter.zep.c new file mode 100644 index 0000000000..643a910edd --- /dev/null +++ b/ext/phalcon/adr/emitter/sapiemitter.zep.c @@ -0,0 +1,69 @@ + +#ifdef HAVE_CONFIG_H +#include "../../../ext_config.h" +#endif + +#include +#include "../../../php_ext.h" +#include "../../../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/memory.h" +#include "kernel/fcall.h" +#include "kernel/operators.h" +#include "kernel/exception.h" +#include "kernel/object.h" + + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ +/** + * Emits a response through the SAPI (headers + body via `Response::send()`). + * Refuses to emit once headers have already been sent. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Emitter_SapiEmitter) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\ADR\\Emitter, SapiEmitter, phalcon, adr_emitter_sapiemitter, phalcon_adr_emitter_sapiemitter_method_entry, 0); + + zend_class_implements(phalcon_adr_emitter_sapiemitter_ce, 1, phalcon_contracts_adr_emitter_emitter_ce); + return SUCCESS; +} + +PHP_METHOD(Phalcon_ADR_Emitter_SapiEmitter, emit) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *response, response_sub, _0; + + ZVAL_UNDEF(&response_sub); + ZVAL_UNDEF(&_0); + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT_OF_CLASS(response, phalcon_http_responseinterface_ce) + ZEND_PARSE_PARAMETERS_END(); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + zephir_fetch_params(1, 1, 0, &response); + ZEPHIR_CALL_FUNCTION(&_0, "headers_sent", NULL, 215); + zephir_check_call_status(); + if (zephir_is_true(&_0)) { + ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_adr_emitter_exceptions_headersalreadysent_ce, "Headers have already been sent; cannot emit the response.", "phalcon/ADR/Emitter/SapiEmitter.zep", 29); + return; + } + ZEPHIR_CALL_METHOD(NULL, response, "send", NULL, 0); + zephir_check_call_status(); + ZEPHIR_MM_RESTORE(); +} + diff --git a/ext/phalcon/adr/emitter/sapiemitter.zep.h b/ext/phalcon/adr/emitter/sapiemitter.zep.h new file mode 100644 index 0000000000..a27887c032 --- /dev/null +++ b/ext/phalcon/adr/emitter/sapiemitter.zep.h @@ -0,0 +1,16 @@ + +extern zend_class_entry *phalcon_adr_emitter_sapiemitter_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Emitter_SapiEmitter); + +PHP_METHOD(Phalcon_ADR_Emitter_SapiEmitter, emit); + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_emitter_sapiemitter_emit, 0, 1, IS_VOID, 0) + + ZEND_ARG_OBJ_INFO(0, response, Phalcon\\Http\\ResponseInterface, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_adr_emitter_sapiemitter_method_entry) { + PHP_ME(Phalcon_ADR_Emitter_SapiEmitter, emit, arginfo_phalcon_adr_emitter_sapiemitter_emit, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/phalcon/adr/errorresponder.zep.c b/ext/phalcon/adr/errorresponder.zep.c new file mode 100644 index 0000000000..93cf26537c --- /dev/null +++ b/ext/phalcon/adr/errorresponder.zep.c @@ -0,0 +1,369 @@ + +#ifdef HAVE_CONFIG_H +#include "../../ext_config.h" +#endif + +#include +#include "../../php_ext.h" +#include "../../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/object.h" +#include "kernel/memory.h" +#include "kernel/fcall.h" +#include "kernel/operators.h" +#include "kernel/array.h" + + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ +/** + * Turns a thrown exception into a response through the responder chain. + * + * The full diagnostic (class, message, file:line and the exception itself) goes + * to the log with a correlation reference; the client receives only a generic + * message plus that same reference, unless debug mode is on. Exceptions are + * mapped to statuses deterministically: an exact class match first, then the + * ancestor chain, so map ordering never matters. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_ErrorResponder) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\ADR, ErrorResponder, phalcon, adr_errorresponder, phalcon_adr_errorresponder_method_entry, ZEND_ACC_FINAL_CLASS); + + /** + * @var Responder + */ + zend_declare_property_null(phalcon_adr_errorresponder_ce, SL("chain"), ZEND_ACC_PROTECTED); + /** + * @var bool + */ + zend_declare_property_null(phalcon_adr_errorresponder_ce, SL("debug"), ZEND_ACC_PROTECTED); + /** + * @var array + */ + zend_declare_property_null(phalcon_adr_errorresponder_ce, SL("exceptionMap"), ZEND_ACC_PROTECTED); + /** + * @var Logger + */ + zend_declare_property_null(phalcon_adr_errorresponder_ce, SL("logger"), ZEND_ACC_PROTECTED); + return SUCCESS; +} + +PHP_METHOD(Phalcon_ADR_ErrorResponder, __construct) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval exceptionMap; + zend_bool debug; + zval *chain, chain_sub, *logger, logger_sub, *debug_param = NULL, *exceptionMap_param = NULL, __$true, __$false, _0, _1; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&chain_sub); + ZVAL_UNDEF(&logger_sub); + ZVAL_BOOL(&__$true, 1); + ZVAL_BOOL(&__$false, 0); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&exceptionMap); + static zend_string *_zephir_prop_0 = NULL; + static zend_string *_zephir_prop_1 = NULL; + static zend_string *_zephir_prop_2 = NULL; + static zend_string *_zephir_prop_3 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("chain", 5, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("logger", 6, 1); + } + if (UNEXPECTED(!_zephir_prop_2)) { + _zephir_prop_2 = zend_string_init("debug", 5, 1); + } + if (UNEXPECTED(!_zephir_prop_3)) { + _zephir_prop_3 = zend_string_init("exceptionMap", 12, 1); + } + + ZEND_PARSE_PARAMETERS_START(2, 4) + Z_PARAM_OBJECT_OF_CLASS(chain, phalcon_contracts_adr_responder_responder_ce) + Z_PARAM_OBJECT_OF_CLASS(logger, phalcon_contracts_logger_logger_ce) + Z_PARAM_OPTIONAL + Z_PARAM_BOOL(debug) + ZEPHIR_Z_PARAM_ARRAY(exceptionMap, exceptionMap_param) + ZEND_PARSE_PARAMETERS_END(); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + zephir_fetch_params(1, 2, 2, &chain, &logger, &debug_param, &exceptionMap_param); + if (!debug_param) { + debug = 0; + } else { + } + if (!exceptionMap_param) { + ZEPHIR_INIT_VAR(&exceptionMap); + array_init(&exceptionMap); + } else { + zephir_get_arrval(&exceptionMap, exceptionMap_param); + } + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 337, chain); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 338, logger); + if (debug) { + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 339, &__$true); + } else { + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 339, &__$false); + } + ZEPHIR_CALL_METHOD(&_0, this_ptr, "defaultmap", NULL, 307); + zephir_check_call_status(); + ZEPHIR_INIT_VAR(&_1); + zephir_add_function(&_1, &exceptionMap, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 340, &_1); + ZEPHIR_MM_RESTORE(); +} + +PHP_METHOD(Phalcon_ADR_ErrorResponder, handle) +{ + zval _7; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *request, request_sub, *response, response_sub, *exception, exception_sub, status, ref, payload, _0, _1, _2, _3, _4, _5, _6, _8, _9, _10; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&request_sub); + ZVAL_UNDEF(&response_sub); + ZVAL_UNDEF(&exception_sub); + ZVAL_UNDEF(&status); + ZVAL_UNDEF(&ref); + ZVAL_UNDEF(&payload); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); + ZVAL_UNDEF(&_3); + ZVAL_UNDEF(&_4); + ZVAL_UNDEF(&_5); + ZVAL_UNDEF(&_6); + ZVAL_UNDEF(&_8); + ZVAL_UNDEF(&_9); + ZVAL_UNDEF(&_10); + ZVAL_UNDEF(&_7); + static zend_string *_zephir_prop_0 = NULL; + static zend_string *_zephir_prop_1 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("logger", 6, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("chain", 5, 1); + } + + ZEND_PARSE_PARAMETERS_START(3, 3) + Z_PARAM_OBJECT_OF_CLASS(request, phalcon_http_requestinterface_ce) + Z_PARAM_OBJECT_OF_CLASS(response, phalcon_http_responseinterface_ce) + Z_PARAM_OBJECT_OF_CLASS(exception, zend_ce_throwable) + ZEND_PARSE_PARAMETERS_END(); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + zephir_fetch_params(1, 3, 0, &request, &response, &exception); + ZEPHIR_CALL_METHOD(&ref, this_ptr, "correlationid", NULL, 308, request); + zephir_check_call_status(); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 338, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_1); + zephir_get_class(&_1, exception, 0); + ZEPHIR_CALL_METHOD(&_2, exception, "getmessage", NULL, 0); + zephir_check_call_status(); + ZEPHIR_CALL_METHOD(&_3, exception, "getfile", NULL, 0); + zephir_check_call_status(); + ZEPHIR_CALL_METHOD(&_4, exception, "getline", NULL, 0); + zephir_check_call_status(); + ZEPHIR_INIT_VAR(&_5); + ZVAL_STRING(&_5, "%s: %s in %s:%d"); + ZEPHIR_CALL_FUNCTION(&_6, "sprintf", NULL, 145, &_5, &_1, &_2, &_3, &_4); + zephir_check_call_status(); + ZEPHIR_INIT_VAR(&_7); + zephir_create_array(&_7, 2, 0); + zephir_array_update_string(&_7, SL("exception"), exception, PH_COPY | PH_SEPARATE); + zephir_array_update_string(&_7, SL("ref"), &ref, PH_COPY | PH_SEPARATE); + ZEPHIR_CALL_METHOD(NULL, &_0, "error", NULL, 0, &_6, &_7); + zephir_check_call_status(); + ZEPHIR_CALL_METHOD(&status, this_ptr, "resolvestatus", NULL, 309, exception); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_5); + object_init_ex(&_5, phalcon_adr_payload_payload_ce); + if (zephir_has_constructor(&_5)) { + ZEPHIR_CALL_METHOD(NULL, &_5, "__construct", NULL, 0); + zephir_check_call_status(); + } + + ZEPHIR_CALL_METHOD(&_8, &_5, "withstatus", NULL, 310, &status); + zephir_check_call_status(); + ZEPHIR_CALL_METHOD(&_9, this_ptr, "details", NULL, 311, exception, &ref); + zephir_check_call_status(); + ZEPHIR_CALL_METHOD(&payload, &_8, "withresult", NULL, 0, &_9); + zephir_check_call_status(); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_1, 337, PH_NOISY_CC | PH_READONLY); + ZEPHIR_RETURN_CALL_METHOD(&_10, "__invoke", NULL, 0, request, response, &payload); + zephir_check_call_status(); + RETURN_MM(); +} + +PHP_METHOD(Phalcon_ADR_ErrorResponder, correlationId) +{ + zval _3; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *request, request_sub, id, _0, _1$$3, _2$$3; + + ZVAL_UNDEF(&request_sub); + ZVAL_UNDEF(&id); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1$$3); + ZVAL_UNDEF(&_2$$3); + ZVAL_UNDEF(&_3); + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT_OF_CLASS(request, phalcon_http_requestinterface_ce) + ZEND_PARSE_PARAMETERS_END(); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + zephir_fetch_params(1, 1, 0, &request); + ZEPHIR_INIT_VAR(&_0); + ZVAL_STRING(&_0, "X-Request-Id"); + ZEPHIR_CALL_METHOD(&id, request, "getheader", NULL, 0, &_0); + zephir_check_call_status(); + if (ZEPHIR_IS_EMPTY(&id)) { + ZVAL_LONG(&_1$$3, 8); + ZEPHIR_CALL_FUNCTION(&_2$$3, "random_bytes", NULL, 312, &_1$$3); + zephir_check_call_status(); + ZEPHIR_CALL_FUNCTION(&id, "bin2hex", NULL, 313, &_2$$3); + zephir_check_call_status(); + } + zephir_cast_to_string(&_3, &id); + RETURN_CTOR(&_3); +} + +PHP_METHOD(Phalcon_ADR_ErrorResponder, defaultMap) +{ + + zephir_create_array(return_value, 2, 0); + add_assoc_stringl_ex(return_value, SL("Phalcon\\ADR\\Router\\Exceptions\\RouteNotFound"), SL("NOT_FOUND")); + add_assoc_stringl_ex(return_value, SL("Phalcon\\ADR\\Router\\Exceptions\\MethodNotAllowed"), SL("METHOD_NOT_ALLOWED")); + return; +} + +PHP_METHOD(Phalcon_ADR_ErrorResponder, details) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zend_string *ref = NULL; + zval *exception, exception_sub, ref_zv, _0, _1$$3; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&exception_sub); + ZVAL_UNDEF(&ref_zv); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1$$3); + static zend_string *_zephir_prop_0 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("debug", 5, 1); + } + + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_OBJECT_OF_CLASS(exception, zend_ce_throwable) + Z_PARAM_STR(ref) + ZEND_PARSE_PARAMETERS_END(); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + exception = ZEND_CALL_ARG(execute_data, 1); + zephir_memory_observe(&ref_zv); + ZVAL_STR_COPY(&ref_zv, ref); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 339, PH_NOISY_CC | PH_READONLY); + if (zephir_is_true(&_0)) { + zephir_create_array(return_value, 3, 0); + ZEPHIR_CALL_METHOD(&_1$$3, exception, "getmessage", NULL, 0); + zephir_check_call_status(); + zephir_array_update_string(return_value, SL("message"), &_1$$3, PH_COPY | PH_SEPARATE); + ZEPHIR_CALL_METHOD(&_1$$3, exception, "gettraceasstring", NULL, 0); + zephir_check_call_status(); + zephir_array_update_string(return_value, SL("trace"), &_1$$3, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("ref"), &ref_zv, PH_COPY | PH_SEPARATE); + RETURN_MM(); + } + zephir_create_array(return_value, 2, 0); + add_assoc_stringl_ex(return_value, SL("message"), SL("Internal Server Error")); + zephir_array_update_string(return_value, SL("ref"), &ref_zv, PH_COPY | PH_SEPARATE); + RETURN_MM(); +} + +PHP_METHOD(Phalcon_ADR_ErrorResponder, resolveStatus) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *exception, exception_sub, className, ancestor, ancestors, _0, _3, _4, _5, _6, *_7, _1$$3, _2$$3, _8$$4, _9$$5, _10$$5; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&exception_sub); + ZVAL_UNDEF(&className); + ZVAL_UNDEF(&ancestor); + ZVAL_UNDEF(&ancestors); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_3); + ZVAL_UNDEF(&_4); + ZVAL_UNDEF(&_5); + ZVAL_UNDEF(&_6); + ZVAL_UNDEF(&_1$$3); + ZVAL_UNDEF(&_2$$3); + ZVAL_UNDEF(&_8$$4); + ZVAL_UNDEF(&_9$$5); + ZVAL_UNDEF(&_10$$5); + static zend_string *_zephir_prop_0 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("exceptionMap", 12, 1); + } + + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT_OF_CLASS(exception, zend_ce_throwable) + ZEND_PARSE_PARAMETERS_END(); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + zephir_fetch_params(1, 1, 0, &exception); + ZEPHIR_INIT_VAR(&className); + zephir_get_class(&className, exception, 0); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 340, PH_NOISY_CC | PH_READONLY); + if (zephir_array_isset_value(&_0, &className)) { + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 340, PH_NOISY_CC | PH_READONLY); + zephir_array_fetch(&_2$$3, &_1$$3, &className, PH_NOISY | PH_READONLY, "phalcon/ADR/ErrorResponder.zep", 140); + RETURN_CTOR(&_2$$3); + } + ZEPHIR_CALL_FUNCTION(&_3, "class_parents", NULL, 314, exception); + zephir_check_call_status(); + ZEPHIR_CALL_FUNCTION(&_4, "array_values", NULL, 27, &_3); + zephir_check_call_status(); + ZEPHIR_CALL_FUNCTION(&_5, "class_implements", NULL, 315, exception); + zephir_check_call_status(); + ZEPHIR_CALL_FUNCTION(&_6, "array_values", NULL, 27, &_5); + zephir_check_call_status(); + ZEPHIR_INIT_VAR(&ancestors); + zephir_fast_array_merge(&ancestors, &_4, &_6); + zephir_is_iterable(&ancestors, 0, "phalcon/ADR/ErrorResponder.zep", 154); + ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&ancestors), _7) + { + ZEPHIR_INIT_NVAR(&ancestor); + ZVAL_COPY(&ancestor, _7); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 340, PH_NOISY_CC | PH_READONLY); + if (zephir_array_isset_value(&_8$$4, &ancestor)) { + zephir_read_property_cached(&_9$$5, this_ptr, _zephir_prop_0, 340, PH_NOISY_CC | PH_READONLY); + zephir_array_fetch(&_10$$5, &_9$$5, &ancestor, PH_NOISY | PH_READONLY, "phalcon/ADR/ErrorResponder.zep", 150); + RETURN_CTOR(&_10$$5); + } + } ZEND_HASH_FOREACH_END(); + ZEPHIR_INIT_NVAR(&ancestor); + RETURN_MM_STRING("ERROR"); +} + diff --git a/ext/phalcon/adr/errorresponder.zep.h b/ext/phalcon/adr/errorresponder.zep.h new file mode 100644 index 0000000000..6074d89eaf --- /dev/null +++ b/ext/phalcon/adr/errorresponder.zep.h @@ -0,0 +1,50 @@ + +extern zend_class_entry *phalcon_adr_errorresponder_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_ErrorResponder); + +PHP_METHOD(Phalcon_ADR_ErrorResponder, __construct); +PHP_METHOD(Phalcon_ADR_ErrorResponder, handle); +PHP_METHOD(Phalcon_ADR_ErrorResponder, correlationId); +PHP_METHOD(Phalcon_ADR_ErrorResponder, defaultMap); +PHP_METHOD(Phalcon_ADR_ErrorResponder, details); +PHP_METHOD(Phalcon_ADR_ErrorResponder, resolveStatus); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_adr_errorresponder___construct, 0, 0, 2) + ZEND_ARG_OBJ_INFO(0, chain, Phalcon\\Contracts\\ADR\\Responder\\Responder, 0) + ZEND_ARG_OBJ_INFO(0, logger, Phalcon\\Contracts\\Logger\\Logger, 0) + ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, debug, _IS_BOOL, 0, "false") +ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, exceptionMap, IS_ARRAY, 0, "[]") +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_errorresponder_handle, 0, 3, Phalcon\\Http\\ResponseInterface, 0) + ZEND_ARG_OBJ_INFO(0, request, Phalcon\\Http\\RequestInterface, 0) + ZEND_ARG_OBJ_INFO(0, response, Phalcon\\Http\\ResponseInterface, 0) + ZEND_ARG_OBJ_INFO(0, exception, Throwable, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_errorresponder_correlationid, 0, 1, IS_STRING, 0) + ZEND_ARG_OBJ_INFO(0, request, Phalcon\\Http\\RequestInterface, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_errorresponder_defaultmap, 0, 0, IS_ARRAY, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_errorresponder_details, 0, 2, IS_ARRAY, 0) + ZEND_ARG_OBJ_INFO(0, exception, Throwable, 0) + ZEND_ARG_TYPE_INFO(0, ref, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_errorresponder_resolvestatus, 0, 1, IS_STRING, 0) + ZEND_ARG_OBJ_INFO(0, exception, Throwable, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_adr_errorresponder_method_entry) { + PHP_ME(Phalcon_ADR_ErrorResponder, __construct, arginfo_phalcon_adr_errorresponder___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) + PHP_ME(Phalcon_ADR_ErrorResponder, handle, arginfo_phalcon_adr_errorresponder_handle, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_ErrorResponder, correlationId, arginfo_phalcon_adr_errorresponder_correlationid, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_ADR_ErrorResponder, defaultMap, arginfo_phalcon_adr_errorresponder_defaultmap, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_ADR_ErrorResponder, details, arginfo_phalcon_adr_errorresponder_details, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_ADR_ErrorResponder, resolveStatus, arginfo_phalcon_adr_errorresponder_resolvestatus, ZEND_ACC_PRIVATE) + PHP_FE_END +}; diff --git a/ext/phalcon/adr/eventfulhandler.zep.c b/ext/phalcon/adr/eventfulhandler.zep.c index 9d2e3d1129..f51301f1e9 100644 --- a/ext/phalcon/adr/eventfulhandler.zep.c +++ b/ext/phalcon/adr/eventfulhandler.zep.c @@ -69,8 +69,8 @@ PHP_METHOD(Phalcon_ADR_EventfulHandler, __construct) Z_PARAM_OBJECT_OF_CLASS(events, phalcon_contracts_events_manager_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(2, 0, &action, &events); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 332, action); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 333, events); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 341, action); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 342, events); } PHP_METHOD(Phalcon_ADR_EventfulHandler, __invoke) @@ -103,17 +103,17 @@ PHP_METHOD(Phalcon_ADR_EventfulHandler, __invoke) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &request); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 333, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 332, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 342, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 341, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "adr:beforeExecuteAction"); ZEPHIR_CALL_METHOD(NULL, &_0, "fire", NULL, 0, &_2, &_1, request); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 332, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 341, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&response, &_3, "__invoke", NULL, 0, request); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 333, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 332, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 342, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 341, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "adr:afterExecuteAction"); ZEPHIR_CALL_METHOD(NULL, &_4, "fire", NULL, 0, &_2, &_5, &response); diff --git a/ext/phalcon/adr/input/input.zep.c b/ext/phalcon/adr/input/input.zep.c index 5c9f68384f..30ec089a88 100644 --- a/ext/phalcon/adr/input/input.zep.c +++ b/ext/phalcon/adr/input/input.zep.c @@ -76,7 +76,7 @@ PHP_METHOD(Phalcon_ADR_Input_Input, __construct) } else { zephir_get_arrval(&data, data_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 334, &data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 343, &data); ZEPHIR_MM_RESTORE(); } @@ -96,7 +96,7 @@ PHP_METHOD(Phalcon_ADR_Input_Input, fromArray) zephir_fetch_params(1, 1, 0, &data_param); zephir_get_arrval(&data, data_param); object_init_ex(return_value, phalcon_adr_input_input_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 299, &data); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 316, &data); zephir_check_call_status(); RETURN_MM(); } @@ -139,7 +139,7 @@ PHP_METHOD(Phalcon_ADR_Input_Input, fromRequest) zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&_5, "array_merge", NULL, 195, &_1, &_2, &json, &_4); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 299, &_5); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 316, &_5); zephir_check_call_status(); RETURN_MM(); } @@ -180,9 +180,9 @@ PHP_METHOD(Phalcon_ADR_Input_Input, get) defaultValue = &__$null; } ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 334, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 343, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_1, &key_zv)) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 334, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 343, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_0); zephir_array_fetch(&_0, &_2, &key_zv, PH_NOISY, "phalcon/ADR/Input/Input.zep", 64); } else { @@ -208,7 +208,7 @@ PHP_METHOD(Phalcon_ADR_Input_Input, has) Z_PARAM_STR(key) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&key_zv, key); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 334, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 343, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &key_zv)); } diff --git a/ext/phalcon/adr/kernel/abstracthttpkernel.zep.c b/ext/phalcon/adr/kernel/abstracthttpkernel.zep.c new file mode 100644 index 0000000000..b131dbb0fc --- /dev/null +++ b/ext/phalcon/adr/kernel/abstracthttpkernel.zep.c @@ -0,0 +1,210 @@ + +#ifdef HAVE_CONFIG_H +#include "../../../ext_config.h" +#endif + +#include +#include "../../../php_ext.h" +#include "../../../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/object.h" +#include "kernel/fcall.h" +#include "kernel/memory.h" +#include "kernel/operators.h" + + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ +/** + * Boots a container, resolves the Application, handles the request and emits the + * response. Userland kernels override `loadEnvironment()` / `registerProviders()`; + * bootstrap is `exit((new AppKernel(dirname(__DIR__)))->run());`. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Kernel_AbstractHttpKernel) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\ADR\\Kernel, AbstractHttpKernel, phalcon, adr_kernel_abstracthttpkernel, phalcon_adr_kernel_abstracthttpkernel_method_entry, ZEND_ACC_EXPLICIT_ABSTRACT_CLASS); + + zend_declare_property_null(phalcon_adr_kernel_abstracthttpkernel_ce, SL("projectRoot"), ZEND_ACC_PROTECTED); + zend_class_implements(phalcon_adr_kernel_abstracthttpkernel_ce, 1, phalcon_contracts_adr_kernel_kernel_ce); + return SUCCESS; +} + +PHP_METHOD(Phalcon_ADR_Kernel_AbstractHttpKernel, __construct) +{ + zval projectRoot_zv; + zend_string *projectRoot = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&projectRoot_zv); + static zend_string *_zephir_prop_0 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("projectRoot", 11, 1); + } + + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(projectRoot) + ZEND_PARSE_PARAMETERS_END(); + ZVAL_STR(&projectRoot_zv, projectRoot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 243, &projectRoot_zv); +} + +PHP_METHOD(Phalcon_ADR_Kernel_AbstractHttpKernel, run) +{ + zval container, request, application, response, exception, _2, _0$$3, _1$$3; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&container); + ZVAL_UNDEF(&request); + ZVAL_UNDEF(&application); + ZVAL_UNDEF(&response); + ZVAL_UNDEF(&exception); + ZVAL_UNDEF(&_2); + ZVAL_UNDEF(&_0$$3); + ZVAL_UNDEF(&_1$$3); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + /* try_start_1: */ + + ZEPHIR_CALL_METHOD(&container, this_ptr, "buildcontainer", NULL, 0); + zephir_check_call_status_or_jump(try_end_1); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "loadenvironment", NULL, 0, &container); + zephir_check_call_status_or_jump(try_end_1); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "registerproviders", NULL, 0, &container); + zephir_check_call_status_or_jump(try_end_1); + ZEPHIR_INIT_VAR(&_0$$3); + ZVAL_STRING(&_0$$3, "request"); + ZEPHIR_CALL_METHOD(&request, &container, "get", NULL, 0, &_0$$3); + zephir_check_call_status_or_jump(try_end_1); + ZEPHIR_INIT_NVAR(&_0$$3); + ZVAL_STRING(&_0$$3, "Phalcon\\ADR\\Application"); + ZEPHIR_CALL_METHOD(&application, &container, "get", NULL, 0, &_0$$3); + zephir_check_call_status_or_jump(try_end_1); + ZEPHIR_CALL_METHOD(&response, &application, "handle", NULL, 0, &request); + zephir_check_call_status_or_jump(try_end_1); + ZEPHIR_INIT_NVAR(&_0$$3); + ZVAL_STRING(&_0$$3, "Phalcon\\Contracts\\ADR\\Emitter\\Emitter"); + ZEPHIR_CALL_METHOD(&_1$$3, &container, "get", NULL, 0, &_0$$3); + zephir_check_call_status_or_jump(try_end_1); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "emit", NULL, 0, &response); + zephir_check_call_status_or_jump(try_end_1); + RETURN_MM_LONG(0); + + try_end_1: + + if (EG(exception)) { + ZEPHIR_INIT_VAR(&_2); + ZVAL_OBJ(&_2, EG(exception)); + Z_ADDREF_P(&_2); + if (zephir_is_instance_of(&_2, SL("Throwable"))) { + zend_clear_exception(); + ZEPHIR_CPY_WRT(&exception, &_2); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "handlebooterror", NULL, 0, &exception); + zephir_check_call_status(); + RETURN_MM(); + } + } + RETURN_MM_LONG(0); +} + +PHP_METHOD(Phalcon_ADR_Kernel_AbstractHttpKernel, buildContainer) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + + object_init_ex(return_value, phalcon_container_container_ce); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 213); + zephir_check_call_status(); + RETURN_MM(); +} + +PHP_METHOD(Phalcon_ADR_Kernel_AbstractHttpKernel, handleBootError) +{ + zval _0; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *exception, exception_sub, _1, _2$$3, _3$$3; + + ZVAL_UNDEF(&exception_sub); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2$$3); + ZVAL_UNDEF(&_3$$3); + ZVAL_UNDEF(&_0); + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT_OF_CLASS(exception, zend_ce_throwable) + ZEND_PARSE_PARAMETERS_END(); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + zephir_fetch_params(1, 1, 0, &exception); + zephir_cast_to_string(&_0, exception); + ZEPHIR_CALL_FUNCTION(NULL, "error_log", NULL, 214, &_0); + zephir_check_call_status(); + ZEPHIR_CALL_FUNCTION(&_1, "headers_sent", NULL, 215); + zephir_check_call_status(); + if (!(zephir_is_true(&_1))) { + ZVAL_LONG(&_2$$3, 500); + ZEPHIR_CALL_FUNCTION(NULL, "http_response_code", NULL, 216, &_2$$3); + zephir_check_call_status(); + ZEPHIR_INIT_VAR(&_3$$3); + ZVAL_STRING(&_3$$3, "Content-Type: text/plain; charset=utf-8"); + ZEPHIR_CALL_FUNCTION(NULL, "header", NULL, 217, &_3$$3); + zephir_check_call_status(); + php_printf("%s", "Internal Server Error\n"); + } + RETURN_MM_LONG(1); +} + +PHP_METHOD(Phalcon_ADR_Kernel_AbstractHttpKernel, loadEnvironment) +{ + zval *container, container_sub; + + ZVAL_UNDEF(&container_sub); + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT_OF_CLASS(container, phalcon_container_container_ce) + ZEND_PARSE_PARAMETERS_END(); + zephir_fetch_params_without_memory_grow(1, 0, &container); +} + +PHP_METHOD(Phalcon_ADR_Kernel_AbstractHttpKernel, registerProviders) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *container, container_sub, _0; + + ZVAL_UNDEF(&container_sub); + ZVAL_UNDEF(&_0); + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT_OF_CLASS(container, phalcon_container_container_ce) + ZEND_PARSE_PARAMETERS_END(); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + zephir_fetch_params(1, 1, 0, &container); + ZEPHIR_INIT_VAR(&_0); + object_init_ex(&_0, phalcon_adr_container_adrprovider_ce); + if (zephir_has_constructor(&_0)) { + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 0); + zephir_check_call_status(); + } + + ZEPHIR_CALL_METHOD(NULL, &_0, "provide", NULL, 218, container); + zephir_check_call_status(); + ZEPHIR_MM_RESTORE(); +} + diff --git a/ext/phalcon/adr/kernel/abstracthttpkernel.zep.h b/ext/phalcon/adr/kernel/abstracthttpkernel.zep.h new file mode 100644 index 0000000000..adeb29ece7 --- /dev/null +++ b/ext/phalcon/adr/kernel/abstracthttpkernel.zep.h @@ -0,0 +1,45 @@ + +extern zend_class_entry *phalcon_adr_kernel_abstracthttpkernel_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Kernel_AbstractHttpKernel); + +PHP_METHOD(Phalcon_ADR_Kernel_AbstractHttpKernel, __construct); +PHP_METHOD(Phalcon_ADR_Kernel_AbstractHttpKernel, run); +PHP_METHOD(Phalcon_ADR_Kernel_AbstractHttpKernel, buildContainer); +PHP_METHOD(Phalcon_ADR_Kernel_AbstractHttpKernel, handleBootError); +PHP_METHOD(Phalcon_ADR_Kernel_AbstractHttpKernel, loadEnvironment); +PHP_METHOD(Phalcon_ADR_Kernel_AbstractHttpKernel, registerProviders); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_adr_kernel_abstracthttpkernel___construct, 0, 0, 1) + ZEND_ARG_TYPE_INFO(0, projectRoot, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_kernel_abstracthttpkernel_run, 0, 0, IS_LONG, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_kernel_abstracthttpkernel_buildcontainer, 0, 0, Phalcon\\Container\\Container, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_kernel_abstracthttpkernel_handlebooterror, 0, 1, IS_LONG, 0) + ZEND_ARG_OBJ_INFO(0, exception, Throwable, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_kernel_abstracthttpkernel_loadenvironment, 0, 1, IS_VOID, 0) + + ZEND_ARG_OBJ_INFO(0, container, Phalcon\\Container\\Container, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_kernel_abstracthttpkernel_registerproviders, 0, 1, IS_VOID, 0) + + ZEND_ARG_OBJ_INFO(0, container, Phalcon\\Container\\Container, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_adr_kernel_abstracthttpkernel_method_entry) { + PHP_ME(Phalcon_ADR_Kernel_AbstractHttpKernel, __construct, arginfo_phalcon_adr_kernel_abstracthttpkernel___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) + PHP_ME(Phalcon_ADR_Kernel_AbstractHttpKernel, run, arginfo_phalcon_adr_kernel_abstracthttpkernel_run, ZEND_ACC_FINAL|ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Kernel_AbstractHttpKernel, buildContainer, arginfo_phalcon_adr_kernel_abstracthttpkernel_buildcontainer, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_ADR_Kernel_AbstractHttpKernel, handleBootError, arginfo_phalcon_adr_kernel_abstracthttpkernel_handlebooterror, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_ADR_Kernel_AbstractHttpKernel, loadEnvironment, arginfo_phalcon_adr_kernel_abstracthttpkernel_loadenvironment, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_ADR_Kernel_AbstractHttpKernel, registerProviders, arginfo_phalcon_adr_kernel_abstracthttpkernel_registerproviders, ZEND_ACC_PROTECTED) + PHP_FE_END +}; diff --git a/ext/phalcon/adr/kernel/httpkernel.zep.c b/ext/phalcon/adr/kernel/httpkernel.zep.c new file mode 100644 index 0000000000..049aaf82af --- /dev/null +++ b/ext/phalcon/adr/kernel/httpkernel.zep.c @@ -0,0 +1,39 @@ + +#ifdef HAVE_CONFIG_H +#include "../../../ext_config.h" +#endif + +#include +#include "../../../php_ext.h" +#include "../../../ext.h" + +#include +#include +#include + +#include "kernel/main.h" + + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ +/** + * Concrete default HTTP kernel. Boots the ADR provider and runs the application + * with the framework defaults; subclass to override `loadEnvironment()` or + * `registerProviders()`. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Kernel_HttpKernel) +{ + ZEPHIR_REGISTER_CLASS_EX(Phalcon\\ADR\\Kernel, HttpKernel, phalcon, adr_kernel_httpkernel, phalcon_adr_kernel_abstracthttpkernel_ce, NULL, 0); + + return SUCCESS; +} + diff --git a/ext/phalcon/adr/kernel/httpkernel.zep.h b/ext/phalcon/adr/kernel/httpkernel.zep.h new file mode 100644 index 0000000000..f7e70e207c --- /dev/null +++ b/ext/phalcon/adr/kernel/httpkernel.zep.h @@ -0,0 +1,5 @@ + +extern zend_class_entry *phalcon_adr_kernel_httpkernel_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Kernel_HttpKernel); + diff --git a/ext/phalcon/adr/middleware/corsmiddleware.zep.c b/ext/phalcon/adr/middleware/corsmiddleware.zep.c index 3d1f93b62b..1881dc4ae5 100644 --- a/ext/phalcon/adr/middleware/corsmiddleware.zep.c +++ b/ext/phalcon/adr/middleware/corsmiddleware.zep.c @@ -124,7 +124,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, __construct) ZEPHIR_INIT_NVAR(&_0); array_init(&_0); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 335, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 344, &_0); ZEPHIR_INIT_VAR(&_1); if (zephir_array_isset_value_string(&config, SL("methods"))) { ZEPHIR_OBS_NVAR(&_1); @@ -152,7 +152,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, __construct) zephir_array_fast_append(&_2, &_3); ZEPHIR_CPY_WRT(&_1, &_2); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 336, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 345, &_1); ZEPHIR_INIT_VAR(&_4); if (zephir_array_isset_value_string(&config, SL("headers"))) { ZEPHIR_OBS_NVAR(&_4); @@ -168,7 +168,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, __construct) zephir_array_fast_append(&_5, &_3); ZEPHIR_CPY_WRT(&_4, &_5); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 337, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 346, &_4); ZEPHIR_INIT_VAR(&_6); if (zephir_array_isset_value_string(&config, SL("credentials"))) { zephir_memory_observe(&_7); @@ -179,7 +179,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, __construct) ZEPHIR_INIT_NVAR(&_6); ZVAL_BOOL(&_6, 0); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 338, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 347, &_6); ZEPHIR_INIT_VAR(&_8); if (zephir_array_isset_value_string(&config, SL("maxAge"))) { ZEPHIR_OBS_NVAR(&_7); @@ -190,7 +190,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, __construct) ZEPHIR_INIT_NVAR(&_8); ZVAL_LONG(&_8, 0); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 339, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 348, &_8); ZEPHIR_MM_RESTORE(); } @@ -270,27 +270,27 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, __invoke) ZEPHIR_CALL_METHOD(NULL, this_ptr, "applyheaders", NULL, 0, &response, &origin); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_6$$4); - zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 336, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 345, PH_NOISY_CC | PH_READONLY); zephir_fast_join_str(&_6$$4, SL(", "), &_5$$4); ZEPHIR_INIT_VAR(&_7$$4); ZVAL_STRING(&_7$$4, "Access-Control-Allow-Methods"); - ZEPHIR_CALL_METHOD(NULL, &response, "setheader", NULL, 302, &_7$$4, &_6$$4); + ZEPHIR_CALL_METHOD(NULL, &response, "setheader", NULL, 317, &_7$$4, &_6$$4); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_7$$4); - zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_1, 337, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_1, 346, PH_NOISY_CC | PH_READONLY); zephir_fast_join_str(&_7$$4, SL(", "), &_8$$4); ZEPHIR_INIT_VAR(&_9$$4); ZVAL_STRING(&_9$$4, "Access-Control-Allow-Headers"); - ZEPHIR_CALL_METHOD(NULL, &response, "setheader", NULL, 302, &_9$$4, &_7$$4); + ZEPHIR_CALL_METHOD(NULL, &response, "setheader", NULL, 317, &_9$$4, &_7$$4); zephir_check_call_status(); - zephir_read_property_cached(&_10$$4, this_ptr, _zephir_prop_2, 339, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$4, this_ptr, _zephir_prop_2, 348, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_GT_LONG(&_10$$4, 0)) { zephir_memory_observe(&_11$$5); - zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_2, 339, PH_NOISY_CC); + zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_2, 348, PH_NOISY_CC); zephir_cast_to_string(&_12$$5, &_11$$5); ZEPHIR_INIT_VAR(&_13$$5); ZVAL_STRING(&_13$$5, "Access-Control-Max-Age"); - ZEPHIR_CALL_METHOD(NULL, &response, "setheader", NULL, 302, &_13$$5, &_12$$5); + ZEPHIR_CALL_METHOD(NULL, &response, "setheader", NULL, 317, &_13$$5, &_12$$5); zephir_check_call_status(); } RETURN_CCTOR(&response); @@ -334,7 +334,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, applyHeaders) ZVAL_STRING(&_0, "Access-Control-Allow-Origin"); ZEPHIR_CALL_METHOD(NULL, response, "setheader", NULL, 0, &_0, &origin_zv); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 338, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 347, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_1)) { ZEPHIR_INIT_VAR(&_2$$3); ZVAL_STRING(&_2$$3, "Access-Control-Allow-Credentials"); @@ -372,7 +372,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, isAllowed) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&origin_zv); ZVAL_STR_COPY(&origin_zv, origin); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 335, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 344, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "*"); ZEPHIR_CALL_FUNCTION(&_2, "in_array", NULL, 87, &_1, &_0, &__$true); @@ -380,7 +380,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, isAllowed) if (zephir_is_true(&_2)) { RETURN_MM_BOOL(1); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 335, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 344, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_FUNCTION("in_array", NULL, 87, &origin_zv, &_3, &__$true); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/adr/middleware/methodoverridemiddleware.zep.c b/ext/phalcon/adr/middleware/methodoverridemiddleware.zep.c index 92d579e172..3c63a27912 100644 --- a/ext/phalcon/adr/middleware/methodoverridemiddleware.zep.c +++ b/ext/phalcon/adr/middleware/methodoverridemiddleware.zep.c @@ -98,7 +98,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_MethodOverrideMiddleware, __invoke) zephir_cast_to_string(&_4$$3, &_2$$3); ZEPHIR_INIT_VAR(&spoofed); zephir_fast_strtoupper(&spoofed, &_4$$3); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 340, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 349, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_6$$3, "in_array", NULL, 87, &spoofed, &_5$$3, &__$true); zephir_check_call_status(); if (zephir_is_true(&_6$$3)) { diff --git a/ext/phalcon/adr/middleware/requestidmiddleware.zep.c b/ext/phalcon/adr/middleware/requestidmiddleware.zep.c index 61995cb043..2506f984cf 100644 --- a/ext/phalcon/adr/middleware/requestidmiddleware.zep.c +++ b/ext/phalcon/adr/middleware/requestidmiddleware.zep.c @@ -68,9 +68,9 @@ PHP_METHOD(Phalcon_ADR_Middleware_RequestIdMiddleware, __invoke) zephir_check_call_status(); if (ZEPHIR_IS_EMPTY(&id)) { ZVAL_LONG(&_1$$3, 16); - ZEPHIR_CALL_FUNCTION(&_2$$3, "random_bytes", NULL, 303, &_1$$3); + ZEPHIR_CALL_FUNCTION(&_2$$3, "random_bytes", NULL, 312, &_1$$3); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&id, "bin2hex", NULL, 304, &_2$$3); + ZEPHIR_CALL_FUNCTION(&id, "bin2hex", NULL, 313, &_2$$3); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(&_3, request, "getattributes", NULL, 0); diff --git a/ext/phalcon/adr/payload/payload.zep.c b/ext/phalcon/adr/payload/payload.zep.c index 6da0d39f40..1a59c1ac6c 100644 --- a/ext/phalcon/adr/payload/payload.zep.c +++ b/ext/phalcon/adr/payload/payload.zep.c @@ -110,7 +110,7 @@ PHP_METHOD(Phalcon_ADR_Payload_Payload, accepted) ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "ACCEPTED"); - ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 310, &_2); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_1, "withresult", NULL, 0, result); zephir_check_call_status(); @@ -152,7 +152,7 @@ PHP_METHOD(Phalcon_ADR_Payload_Payload, created) ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "CREATED"); - ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 310, &_2); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_1, "withresult", NULL, 0, result); zephir_check_call_status(); @@ -194,7 +194,7 @@ PHP_METHOD(Phalcon_ADR_Payload_Payload, deleted) ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "DELETED"); - ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 310, &_2); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_1, "withresult", NULL, 0, result); zephir_check_call_status(); @@ -236,7 +236,7 @@ PHP_METHOD(Phalcon_ADR_Payload_Payload, error) ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "ERROR"); - ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 310, &_2); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_1, "withmessages", NULL, 0, messages); zephir_check_call_status(); @@ -279,7 +279,7 @@ PHP_METHOD(Phalcon_ADR_Payload_Payload, forbidden) ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "NOT_AUTHORIZED"); - ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 310, &_2); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_1, "withmessages", NULL, 0, messages); zephir_check_call_status(); @@ -321,7 +321,7 @@ PHP_METHOD(Phalcon_ADR_Payload_Payload, found) ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "FOUND"); - ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 310, &_2); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_1, "withresult", NULL, 0, result); zephir_check_call_status(); @@ -417,7 +417,7 @@ PHP_METHOD(Phalcon_ADR_Payload_Payload, invalid) ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "NOT_VALID"); - ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 310, &_2); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_1, "withmessages", NULL, 0, messages); zephir_check_call_status(); @@ -459,7 +459,7 @@ PHP_METHOD(Phalcon_ADR_Payload_Payload, notFound) ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "NOT_FOUND"); - ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 310, &_2); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_1, "withmessages", NULL, 0, messages); zephir_check_call_status(); @@ -501,7 +501,7 @@ PHP_METHOD(Phalcon_ADR_Payload_Payload, processing) ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "PROCESSING"); - ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 310, &_2); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_1, "withresult", NULL, 0, result); zephir_check_call_status(); @@ -543,7 +543,7 @@ PHP_METHOD(Phalcon_ADR_Payload_Payload, success) ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "SUCCESS"); - ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 310, &_2); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_1, "withresult", NULL, 0, result); zephir_check_call_status(); @@ -586,7 +586,7 @@ PHP_METHOD(Phalcon_ADR_Payload_Payload, unauthenticated) ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "NOT_AUTHENTICATED"); - ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 310, &_2); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_1, "withmessages", NULL, 0, messages); zephir_check_call_status(); @@ -628,7 +628,7 @@ PHP_METHOD(Phalcon_ADR_Payload_Payload, updated) ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "UPDATED"); - ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 310, &_2); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_1, "withresult", NULL, 0, result); zephir_check_call_status(); diff --git a/ext/phalcon/adr/pipeline.zep.c b/ext/phalcon/adr/pipeline.zep.c index 37b697a39a..c811111ea1 100644 --- a/ext/phalcon/adr/pipeline.zep.c +++ b/ext/phalcon/adr/pipeline.zep.c @@ -95,11 +95,11 @@ PHP_METHOD(Phalcon_ADR_Pipeline, __construct) index = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 341, &middleware); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 342, terminal); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 350, &middleware); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 351, terminal); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, index); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 343, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 352, &_0); ZEPHIR_MM_RESTORE(); } @@ -141,26 +141,26 @@ PHP_METHOD(Phalcon_ADR_Pipeline, __invoke) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &request); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 343, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 341, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 352, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 350, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_GE_LONG(&_0, zephir_fast_count_int(&_1))) { - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 342, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 351, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_2$$3, "__invoke", NULL, 0, request); zephir_check_call_status(); RETURN_MM(); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 341, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 350, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&mw); zephir_memory_observe(&_4); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 343, PH_NOISY_CC); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 352, PH_NOISY_CC); zephir_array_fetch(&mw, &_3, &_4, PH_NOISY, "phalcon/ADR/Pipeline.zep", 59); ZEPHIR_INIT_VAR(&next); object_init_ex(&next, phalcon_adr_pipeline_ce); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 341, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 342, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 343, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 350, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 351, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 352, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_8, (zephir_get_numberval(&_7) + 1)); - ZEPHIR_CALL_METHOD(NULL, &next, "__construct", NULL, 297, &_5, &_6, &_8); + ZEPHIR_CALL_METHOD(NULL, &next, "__construct", NULL, 305, &_5, &_6, &_8); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&mw, "__invoke", NULL, 0, request, &next); zephir_check_call_status(); diff --git a/ext/phalcon/adr/responder/formatresponder.zep.c b/ext/phalcon/adr/responder/formatresponder.zep.c index 2402ae1e86..cf02f25200 100644 --- a/ext/phalcon/adr/responder/formatresponder.zep.c +++ b/ext/phalcon/adr/responder/formatresponder.zep.c @@ -75,7 +75,7 @@ PHP_METHOD(Phalcon_ADR_Responder_FormatResponder, __construct) } else { zephir_get_arrval(&formatters, formatters_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 344, &formatters); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 353, &formatters); ZEPHIR_MM_RESTORE(); } @@ -119,7 +119,7 @@ PHP_METHOD(Phalcon_ADR_Responder_FormatResponder, __invoke) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 3, 0, &request, &response, &payload); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 344, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 353, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_0)) { RETVAL_ZVAL(response, 1, 0); RETURN_MM(); @@ -132,7 +132,7 @@ PHP_METHOD(Phalcon_ADR_Responder_FormatResponder, __invoke) ZEPHIR_CPY_WRT(&accept, &_3); ZEPHIR_INIT_VAR(&chosen); ZVAL_NULL(&chosen); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 344, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 353, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_4, 0, "phalcon/ADR/Responder/FormatResponder.zep", 58); if (Z_TYPE_P(&_4) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_4), _5) @@ -174,7 +174,7 @@ PHP_METHOD(Phalcon_ADR_Responder_FormatResponder, __invoke) } ZEPHIR_INIT_NVAR(&formatter); if (Z_TYPE_P(&chosen) == IS_NULL) { - zephir_read_property_cached(&_10$$8, this_ptr, _zephir_prop_0, 344, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$8, this_ptr, _zephir_prop_0, 353, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&chosen); zephir_array_fetch_long(&chosen, &_10$$8, 0, PH_NOISY, "phalcon/ADR/Responder/FormatResponder.zep", 59); } diff --git a/ext/phalcon/adr/responder/redirect.zep.c b/ext/phalcon/adr/responder/redirect.zep.c index 40acb1c9ee..6d4ddb6557 100644 --- a/ext/phalcon/adr/responder/redirect.zep.c +++ b/ext/phalcon/adr/responder/redirect.zep.c @@ -79,10 +79,10 @@ PHP_METHOD(Phalcon_ADR_Responder_Redirect, __construct) status = 302; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 345, &url_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 354, &url_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, status); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 346, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 355, &_0); } PHP_METHOD(Phalcon_ADR_Responder_Redirect, permanent) @@ -103,7 +103,7 @@ PHP_METHOD(Phalcon_ADR_Responder_Redirect, permanent) ZVAL_STR_COPY(&url_zv, url); object_init_ex(return_value, phalcon_adr_responder_redirect_ce); ZVAL_LONG(&_0, 301); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 306, &url_zv, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 318, &url_zv, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -126,7 +126,7 @@ PHP_METHOD(Phalcon_ADR_Responder_Redirect, seeOther) ZVAL_STR_COPY(&url_zv, url); object_init_ex(return_value, phalcon_adr_responder_redirect_ce); ZVAL_LONG(&_0, 303); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 306, &url_zv, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 318, &url_zv, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -155,7 +155,7 @@ PHP_METHOD(Phalcon_ADR_Responder_Redirect, temporary) ZVAL_STR_COPY(&url_zv, url); object_init_ex(return_value, phalcon_adr_responder_redirect_ce); ZVAL_LONG(&_0, 302); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 306, &url_zv, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 318, &url_zv, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/adr/responder/statusmapper.zep.c b/ext/phalcon/adr/responder/statusmapper.zep.c index e750d44a96..e4c594f6f9 100644 --- a/ext/phalcon/adr/responder/statusmapper.zep.c +++ b/ext/phalcon/adr/responder/statusmapper.zep.c @@ -100,7 +100,7 @@ PHP_METHOD(Phalcon_ADR_Responder_StatusMapper, __construct) add_assoc_long_ex(&_0, SL("VALID"), 200); ZEPHIR_INIT_VAR(&_1); zephir_add_function(&_1, &overrides, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 347, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 356, &_1); ZEPHIR_MM_RESTORE(); } @@ -133,9 +133,9 @@ PHP_METHOD(Phalcon_ADR_Responder_StatusMapper, toHttpCode) zephir_memory_observe(&status_zv); ZVAL_STR_COPY(&status_zv, status); ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 347, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 356, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_1, &status_zv)) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 347, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 356, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_0); zephir_array_fetch(&_0, &_2, &status_zv, PH_NOISY, "phalcon/ADR/Responder/StatusMapper.zep", 66); } else { diff --git a/ext/phalcon/adr/responder/statusresponder.zep.c b/ext/phalcon/adr/responder/statusresponder.zep.c index 0a00f5d84f..8c1f5a0a4a 100644 --- a/ext/phalcon/adr/responder/statusresponder.zep.c +++ b/ext/phalcon/adr/responder/statusresponder.zep.c @@ -74,11 +74,11 @@ PHP_METHOD(Phalcon_ADR_Responder_StatusResponder, __construct) if (Z_TYPE_P(mapper) == IS_NULL) { ZEPHIR_INIT_VAR(&_0$$3); object_init_ex(&_0$$3, phalcon_adr_responder_statusmapper_ce); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 307); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 319); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 348, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 357, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 348, mapper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 357, mapper); } ZEPHIR_MM_RESTORE(); } @@ -114,7 +114,7 @@ PHP_METHOD(Phalcon_ADR_Responder_StatusResponder, __invoke) ZEPHIR_CALL_METHOD(&status, payload, "getstatus", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(&status) != IS_NULL) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 348, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 357, PH_NOISY_CC | PH_READONLY); zephir_cast_to_string(&_2$$3, &status); ZEPHIR_CALL_METHOD(&_1$$3, &_0$$3, "tohttpcode", NULL, 0, &_2$$3); zephir_check_call_status(); diff --git a/ext/phalcon/adr/router/group.zep.c b/ext/phalcon/adr/router/group.zep.c index 274b989d4c..d6a2bf833a 100644 --- a/ext/phalcon/adr/router/group.zep.c +++ b/ext/phalcon/adr/router/group.zep.c @@ -82,8 +82,8 @@ PHP_METHOD(Phalcon_ADR_Router_Group, __construct) ZEND_PARSE_PARAMETERS_END(); router = ZEND_CALL_ARG(execute_data, 2); ZVAL_STR(&prefix_zv, prefix); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 349, &prefix_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 350, router); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 358, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 359, router); } PHP_METHOD(Phalcon_ADR_Router_Group, add) @@ -137,13 +137,13 @@ PHP_METHOD(Phalcon_ADR_Router_Group, add) } else { zephir_get_arrval(&methods, methods_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 350, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 349, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 359, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 358, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); ZEPHIR_CONCAT_VV(&_2, &_1, &pattern_zv); ZEPHIR_CALL_METHOD(&route, &_0, "add", NULL, 0, &_2, &actionClass_zv, &methods); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 351, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 360, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &route, "pushmiddleware", NULL, 0, &_3); zephir_check_call_status(); RETURN_CCTOR(&route); diff --git a/ext/phalcon/adr/router/route.zep.c b/ext/phalcon/adr/router/route.zep.c index e10e1da8b3..906f86ef23 100644 --- a/ext/phalcon/adr/router/route.zep.c +++ b/ext/phalcon/adr/router/route.zep.c @@ -115,11 +115,11 @@ PHP_METHOD(Phalcon_ADR_Router_Route, __construct) } else { zephir_get_arrval(&methods, methods_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 352, &action_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 353, &methods); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 361, &action_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 362, &methods); ZEPHIR_CALL_METHOD(&_0, this_ptr, "compile", NULL, 0, &pattern_zv); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 354, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 363, &_0); ZEPHIR_MM_RESTORE(); } @@ -149,10 +149,10 @@ PHP_METHOD(Phalcon_ADR_Router_Route, allowsMethod) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&method_zv); ZVAL_STR_COPY(&method_zv, method); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 353, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 362, PH_NOISY_CC | PH_READONLY); _1 = ZEPHIR_IS_EMPTY(&_0); if (!(_1)) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 353, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 362, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_3, "in_array", NULL, 87, &method_zv, &_2, &__$true); zephir_check_call_status(); _1 = zephir_is_true(&_3); @@ -200,7 +200,7 @@ PHP_METHOD(Phalcon_ADR_Router_Route, matches) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&uri_zv); ZVAL_STR_COPY(&uri_zv, uri); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 354, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 363, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_preg_match(&_1, &_0, &uri_zv, &matches, 0, 0 , 0 ); if (!(zephir_is_true(&_1))) { @@ -263,7 +263,7 @@ PHP_METHOD(Phalcon_ADR_Router_Route, withName) Z_PARAM_STR(name) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 355, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 364, &name_zv); RETURN_THISW(); } diff --git a/ext/phalcon/adr/router/router.zep.c b/ext/phalcon/adr/router/router.zep.c index 391b5fe7a5..a5cf656470 100644 --- a/ext/phalcon/adr/router/router.zep.c +++ b/ext/phalcon/adr/router/router.zep.c @@ -88,7 +88,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, add) } ZEPHIR_INIT_VAR(&route); object_init_ex(&route, phalcon_adr_router_route_ce); - ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 308, &pattern_zv, &actionClass_zv, &methods); + ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 320, &pattern_zv, &actionClass_zv, &methods); zephir_check_call_status(); zephir_update_property_array_append(this_ptr, SL("routes"), &route); RETURN_CCTOR(&route); @@ -122,7 +122,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, delete) ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "DELETE"); zephir_array_fast_append(&_0, &_1); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 309, &pattern_zv, &actionClass_zv, &_0); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 321, &pattern_zv, &actionClass_zv, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -155,7 +155,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, get) ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "GET"); zephir_array_fast_append(&_0, &_1); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 309, &pattern_zv, &actionClass_zv, &_0); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 321, &pattern_zv, &actionClass_zv, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -182,7 +182,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, group) ZVAL_STR_COPY(&prefix_zv, prefix); ZEPHIR_INIT_VAR(&group); object_init_ex(&group, phalcon_adr_router_group_ce); - ZEPHIR_CALL_METHOD(NULL, &group, "__construct", NULL, 310, &prefix_zv, this_ptr); + ZEPHIR_CALL_METHOD(NULL, &group, "__construct", NULL, 322, &prefix_zv, this_ptr); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(NULL, "call_user_func", NULL, 80, configure, &group); zephir_check_call_status(); @@ -230,7 +230,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, match) ZEPHIR_CALL_METHOD(&method, request, "getmethod", NULL, 0); zephir_check_call_status(); methodMismatch = 0; - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 356, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 365, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "phalcon/ADR/Router/Router.zep", 90); if (Z_TYPE_P(&_0) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1) @@ -250,7 +250,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, match) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_5$$5, &route, "getname", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", &_6, 311, &_3$$5, ¶ms, &_4$$5, &_5$$5); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", &_6, 323, &_3$$5, ¶ms, &_4$$5, &_5$$5); zephir_check_call_status(); RETURN_MM(); } @@ -288,7 +288,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, match) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_12$$8, &route, "getname", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", &_6, 311, &_10$$8, ¶ms, &_11$$8, &_12$$8); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", &_6, 323, &_10$$8, ¶ms, &_11$$8, &_12$$8); zephir_check_call_status(); RETURN_MM(); } @@ -332,7 +332,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, patch) ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "PATCH"); zephir_array_fast_append(&_0, &_1); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 309, &pattern_zv, &actionClass_zv, &_0); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 321, &pattern_zv, &actionClass_zv, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -365,7 +365,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, post) ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "POST"); zephir_array_fast_append(&_0, &_1); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 309, &pattern_zv, &actionClass_zv, &_0); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 321, &pattern_zv, &actionClass_zv, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -398,7 +398,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, put) ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "PUT"); zephir_array_fast_append(&_0, &_1); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 309, &pattern_zv, &actionClass_zv, &_0); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 321, &pattern_zv, &actionClass_zv, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/adr/router/routermatch.zep.c b/ext/phalcon/adr/router/routermatch.zep.c index 7e2f3f6646..a967593fe5 100644 --- a/ext/phalcon/adr/router/routermatch.zep.c +++ b/ext/phalcon/adr/router/routermatch.zep.c @@ -121,10 +121,10 @@ PHP_METHOD(Phalcon_ADR_Router_RouterMatch, __construct) name = &name_sub; name = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 357, &action_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 358, &attributes); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 359, &middleware); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 360, name); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 366, &action_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 367, &attributes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 368, &middleware); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 369, name); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/annotations/adapter/apcu.zep.c b/ext/phalcon/annotations/adapter/apcu.zep.c index 42ee04fff0..9bb529fa75 100644 --- a/ext/phalcon/annotations/adapter/apcu.zep.c +++ b/ext/phalcon/annotations/adapter/apcu.zep.c @@ -95,11 +95,11 @@ PHP_METHOD(Phalcon_Annotations_Adapter_Apcu, __construct) } zephir_memory_observe(&prefix); if (zephir_array_isset_string_fetch(&prefix, &options, SL("prefix"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 376, &prefix); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 385, &prefix); } zephir_memory_observe(&ttl); if (zephir_array_isset_string_fetch(&ttl, &options, SL("lifetime"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 377, &ttl); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 386, &ttl); } ZEPHIR_MM_RESTORE(); } @@ -132,11 +132,11 @@ PHP_METHOD(Phalcon_Annotations_Adapter_Apcu, read) zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 376, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 385, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); ZEPHIR_CONCAT_SVV(&_2, "_PHAN", &_1, &key_zv); zephir_fast_strtolower(&_0, &_2); - ZEPHIR_RETURN_CALL_FUNCTION("apcu_fetch", NULL, 268, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("apcu_fetch", NULL, 274, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -177,12 +177,12 @@ PHP_METHOD(Phalcon_Annotations_Adapter_Apcu, write) zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 376, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 385, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); ZEPHIR_CONCAT_SVV(&_2, "_PHAN", &_1, &key_zv); zephir_fast_strtolower(&_0, &_2); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 377, PH_NOISY_CC | PH_READONLY); - ZEPHIR_RETURN_CALL_FUNCTION("apcu_store", NULL, 270, &_0, data, &_3); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 386, PH_NOISY_CC | PH_READONLY); + ZEPHIR_RETURN_CALL_FUNCTION("apcu_store", NULL, 276, &_0, data, &_3); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/annotations/adapter/memory.zep.c b/ext/phalcon/annotations/adapter/memory.zep.c index e4ac78232b..dcf8376b26 100644 --- a/ext/phalcon/annotations/adapter/memory.zep.c +++ b/ext/phalcon/annotations/adapter/memory.zep.c @@ -91,7 +91,7 @@ PHP_METHOD(Phalcon_Annotations_Adapter_Memory, read) zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); zephir_memory_observe(&data); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 378, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 387, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_fast_strtolower(&_1, &key_zv); if (!(zephir_array_isset_fetch(&data, &_0, &_1, 0))) { diff --git a/ext/phalcon/annotations/adapter/stream.zep.c b/ext/phalcon/annotations/adapter/stream.zep.c index 10c52dc69a..739e217e0c 100644 --- a/ext/phalcon/annotations/adapter/stream.zep.c +++ b/ext/phalcon/annotations/adapter/stream.zep.c @@ -90,7 +90,7 @@ PHP_METHOD(Phalcon_Annotations_Adapter_Stream, __construct) } zephir_memory_observe(&annotationsDir); if (zephir_array_isset_string_fetch(&annotationsDir, &options, SL("annotationsDir"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 379, &annotationsDir); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 388, &annotationsDir); } ZEPHIR_MM_RESTORE(); } @@ -132,7 +132,7 @@ PHP_METHOD(Phalcon_Annotations_Adapter_Stream, read) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 379, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 388, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "_"); @@ -153,19 +153,19 @@ PHP_METHOD(Phalcon_Annotations_Adapter_Stream, read) ZEPHIR_GLOBAL(warning).enable = zend_is_true(&__$false); ZEPHIR_INIT_VAR(&_5); ZEPHIR_INIT_NVAR(&_5); - zephir_create_closure_ex(&_5, NULL, phalcon_4__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_5, NULL, phalcon_6__closure_ce, SL("__invoke")); ZVAL_LONG(&_6, 2); - ZEPHIR_CALL_FUNCTION(NULL, "set_error_handler", NULL, 286, &_5, &_6); + ZEPHIR_CALL_FUNCTION(NULL, "set_error_handler", NULL, 292, &_5, &_6); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&_7, "unserialize", NULL, 26, &contents); zephir_check_call_status(); ZEPHIR_CPY_WRT(&contents, &_7); - ZEPHIR_CALL_FUNCTION(NULL, "restore_error_handler", NULL, 287); + ZEPHIR_CALL_FUNCTION(NULL, "restore_error_handler", NULL, 293); zephir_check_call_status(); if (UNEXPECTED(ZEPHIR_GLOBAL(warning).enable)) { ZEPHIR_INIT_VAR(&_8$$5); object_init_ex(&_8$$5, phalcon_annotations_exceptions_cannotreadannotationdata_ce); - ZEPHIR_CALL_METHOD(NULL, &_8$$5, "__construct", NULL, 314); + ZEPHIR_CALL_METHOD(NULL, &_8$$5, "__construct", NULL, 326); zephir_check_call_status(); zephir_throw_exception_debug(&_8$$5, "phalcon/Annotations/Adapter/Stream.zep", 94); ZEPHIR_MM_RESTORE(); @@ -210,7 +210,7 @@ PHP_METHOD(Phalcon_Annotations_Adapter_Stream, write) data = ZEND_CALL_ARG(execute_data, 2); zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 379, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 388, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "_"); @@ -225,7 +225,7 @@ PHP_METHOD(Phalcon_Annotations_Adapter_Stream, write) if (UNEXPECTED(ZEPHIR_IS_FALSE_IDENTICAL(&_4))) { ZEPHIR_INIT_VAR(&_5$$3); object_init_ex(&_5$$3, phalcon_annotations_exceptions_annotationsdirectorynotwritable_ce); - ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 315); + ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 327); zephir_check_call_status(); zephir_throw_exception_debug(&_5$$3, "phalcon/Annotations/Adapter/Stream.zep", 115); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/annotations/annotation.zep.c b/ext/phalcon/annotations/annotation.zep.c index cc4b0b96bd..6777518243 100644 --- a/ext/phalcon/annotations/annotation.zep.c +++ b/ext/phalcon/annotations/annotation.zep.c @@ -104,7 +104,7 @@ PHP_METHOD(Phalcon_Annotations_Annotation, __construct) zephir_memory_observe(&name); if (zephir_array_isset_string_fetch(&name, &reflectionData, SL("name"), 0)) { zephir_array_fetch_string(&_0$$3, &reflectionData, SL("name"), PH_NOISY | PH_READONLY, "phalcon/Annotations/Annotation.zep", 50); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 380, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 389, &_0$$3); } zephir_memory_observe(&exprArguments); if (zephir_array_isset_string_fetch(&exprArguments, &reflectionData, SL("arguments"), 0)) { @@ -156,8 +156,8 @@ PHP_METHOD(Phalcon_Annotations_Annotation, __construct) } } ZEPHIR_INIT_NVAR(&argument); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 381, &arguments); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 382, &exprArguments); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 390, &arguments); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 391, &exprArguments); } ZEPHIR_MM_RESTORE(); } @@ -186,7 +186,7 @@ PHP_METHOD(Phalcon_Annotations_Annotation, getArgument) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &position); zephir_memory_observe(&argument); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 381, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 390, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&argument, &_0, position, 0)) { RETURN_CCTOR(&argument); } @@ -277,7 +277,7 @@ PHP_METHOD(Phalcon_Annotations_Annotation, getExpression) ZEPHIR_INIT_NVAR(&item); ZVAL_COPY(&item, _1$$7); zephir_array_fetch_string(&_2$$8, &item, SL("expr"), PH_NOISY | PH_READONLY, "phalcon/Annotations/Annotation.zep", 141); - ZEPHIR_CALL_METHOD(&resolvedItem, this_ptr, "getexpression", &_3, 316, &_2$$8); + ZEPHIR_CALL_METHOD(&resolvedItem, this_ptr, "getexpression", &_3, 328, &_2$$8); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&name); if (zephir_array_isset_string_fetch(&name, &item, SL("name"), 0)) { @@ -305,7 +305,7 @@ PHP_METHOD(Phalcon_Annotations_Annotation, getExpression) ZEPHIR_CALL_METHOD(&item, &_0$$7, "current", NULL, 0); zephir_check_call_status(); zephir_array_fetch_string(&_6$$11, &item, SL("expr"), PH_NOISY | PH_READONLY, "phalcon/Annotations/Annotation.zep", 141); - ZEPHIR_CALL_METHOD(&resolvedItem, this_ptr, "getexpression", &_3, 316, &_6$$11); + ZEPHIR_CALL_METHOD(&resolvedItem, this_ptr, "getexpression", &_3, 328, &_6$$11); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&name); if (zephir_array_isset_string_fetch(&name, &item, SL("name"), 0)) { @@ -320,13 +320,13 @@ PHP_METHOD(Phalcon_Annotations_Annotation, getExpression) } if (ZEPHIR_IS_LONG(&type, 300)) { object_init_ex(return_value, phalcon_annotations_annotation_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 317, &expr); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 329, &expr); zephir_check_call_status(); RETURN_MM(); } ZEPHIR_INIT_VAR(&_7$$15); object_init_ex(&_7$$15, phalcon_annotations_exceptions_unknownannotationexpression_ce); - ZEPHIR_CALL_METHOD(NULL, &_7$$15, "__construct", NULL, 318, &type); + ZEPHIR_CALL_METHOD(NULL, &_7$$15, "__construct", NULL, 330, &type); zephir_check_call_status(); zephir_throw_exception_debug(&_7$$15, "phalcon/Annotations/Annotation.zep", 156); ZEPHIR_MM_RESTORE(); @@ -371,7 +371,7 @@ PHP_METHOD(Phalcon_Annotations_Annotation, getNamedArgument) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); zephir_memory_observe(&argument); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 381, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 390, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&argument, &_0, &name_zv, 0)) { RETURN_CCTOR(&argument); } @@ -421,7 +421,7 @@ PHP_METHOD(Phalcon_Annotations_Annotation, hasArgument) Z_PARAM_ZVAL(position) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &position); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 381, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 390, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, position)); } @@ -438,7 +438,7 @@ PHP_METHOD(Phalcon_Annotations_Annotation, numberArguments) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("arguments", 9, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 381, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 390, PH_NOISY_CC | PH_READONLY); RETURN_LONG(zephir_fast_count_int(&_0)); } diff --git a/ext/phalcon/annotations/collection.zep.c b/ext/phalcon/annotations/collection.zep.c index e00d3dbbd4..c197e6efc3 100644 --- a/ext/phalcon/annotations/collection.zep.c +++ b/ext/phalcon/annotations/collection.zep.c @@ -109,7 +109,7 @@ PHP_METHOD(Phalcon_Annotations_Collection, __construct) ZVAL_COPY(&annotationData, _0); ZEPHIR_INIT_NVAR(&_1$$3); object_init_ex(&_1$$3, phalcon_annotations_annotation_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", &_2, 317, &annotationData); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", &_2, 329, &annotationData); zephir_check_call_status(); zephir_array_append(&annotations, &_1$$3, PH_SEPARATE, "phalcon/Annotations/Collection.zep", 56); } ZEND_HASH_FOREACH_END(); @@ -133,13 +133,13 @@ PHP_METHOD(Phalcon_Annotations_Collection, __construct) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_5$$4); object_init_ex(&_5$$4, phalcon_annotations_annotation_ce); - ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", &_2, 317, &annotationData); + ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", &_2, 329, &annotationData); zephir_check_call_status(); zephir_array_append(&annotations, &_5$$4, PH_SEPARATE, "phalcon/Annotations/Collection.zep", 56); } } ZEPHIR_INIT_NVAR(&annotationData); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 383, &annotations); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 392, &annotations); ZEPHIR_MM_RESTORE(); } @@ -156,7 +156,7 @@ PHP_METHOD(Phalcon_Annotations_Collection, count) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("annotations", 11, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 383, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 392, PH_NOISY_CC | PH_READONLY); RETURN_LONG(zephir_fast_count_int(&_0)); } @@ -184,8 +184,8 @@ PHP_METHOD(Phalcon_Annotations_Collection, current) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&annotation); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 383, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 384, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 392, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 393, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&annotation, &_0, &_1, 0))) { RETURN_MM_BOOL(0); } @@ -224,7 +224,7 @@ PHP_METHOD(Phalcon_Annotations_Collection, get) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 383, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 392, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&annotations, &_0); zephir_is_iterable(&annotations, 0, "phalcon/Annotations/Collection.zep", 99); if (Z_TYPE_P(&annotations) == IS_ARRAY) { @@ -266,7 +266,7 @@ PHP_METHOD(Phalcon_Annotations_Collection, get) ZEPHIR_INIT_NVAR(&annotation); ZEPHIR_INIT_VAR(&_6); object_init_ex(&_6, phalcon_annotations_exceptions_annotationnotfound_ce); - ZEPHIR_CALL_METHOD(NULL, &_6, "__construct", NULL, 319, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_6, "__construct", NULL, 331, &name_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_6, "phalcon/Annotations/Collection.zep", 99); ZEPHIR_MM_RESTORE(); @@ -308,7 +308,7 @@ PHP_METHOD(Phalcon_Annotations_Collection, getAll) ZVAL_STR_COPY(&name_zv, name); ZEPHIR_INIT_VAR(&found); array_init(&found); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 383, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 392, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&annotations, &_0); zephir_is_iterable(&annotations, 0, "phalcon/Annotations/Collection.zep", 119); if (Z_TYPE_P(&annotations) == IS_ARRAY) { @@ -391,7 +391,7 @@ PHP_METHOD(Phalcon_Annotations_Collection, has) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 383, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 392, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&annotations, &_0); zephir_is_iterable(&annotations, 0, "phalcon/Annotations/Collection.zep", 145); if (Z_TYPE_P(&annotations) == IS_ARRAY) { @@ -467,7 +467,7 @@ PHP_METHOD(Phalcon_Annotations_Collection, rewind) } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 384, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 393, &_0); } /** @@ -488,8 +488,8 @@ PHP_METHOD(Phalcon_Annotations_Collection, valid) if (UNEXPECTED(!_zephir_prop_1)) { _zephir_prop_1 = zend_string_init("position", 8, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 383, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 384, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 392, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 393, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &_1)); } diff --git a/ext/phalcon/annotations/reader.zep.c b/ext/phalcon/annotations/reader.zep.c index a297eb8852..ffcb1ad4ca 100644 --- a/ext/phalcon/annotations/reader.zep.c +++ b/ext/phalcon/annotations/reader.zep.c @@ -106,15 +106,15 @@ PHP_METHOD(Phalcon_Annotations_Reader, parse) array_init(&annotations); ZEPHIR_INIT_VAR(&reflection); object_init_ex(&reflection, zephir_get_internal_ce(SL("reflectionclass"))); - ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 233, &className_zv); + ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 239, &className_zv); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&comment, &reflection, "getdoccomment", NULL, 320); + ZEPHIR_CALL_METHOD(&comment, &reflection, "getdoccomment", NULL, 332); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&comment)) { ZEPHIR_INIT_VAR(&classAnnotations); - ZEPHIR_CALL_METHOD(&_0$$3, &reflection, "getfilename", NULL, 321); + ZEPHIR_CALL_METHOD(&_0$$3, &reflection, "getfilename", NULL, 333); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_1$$3, &reflection, "getstartline", NULL, 322); + ZEPHIR_CALL_METHOD(&_1$$3, &reflection, "getstartline", NULL, 334); zephir_check_call_status(); ZEPHIR_LAST_CALL_STATUS = phannot_parse_annotations(&classAnnotations, &comment, &_0$$3, &_1$$3); zephir_check_call_status(); @@ -122,7 +122,7 @@ PHP_METHOD(Phalcon_Annotations_Reader, parse) zephir_array_update_string(&annotations, SL("class"), &classAnnotations, PH_COPY | PH_SEPARATE); } } - ZEPHIR_CALL_METHOD(&constants, &reflection, "getconstants", NULL, 323); + ZEPHIR_CALL_METHOD(&constants, &reflection, "getconstants", NULL, 335); zephir_check_call_status(); if (zephir_fast_count_int(&constants)) { line = 1; @@ -135,13 +135,13 @@ PHP_METHOD(Phalcon_Annotations_Reader, parse) { ZEPHIR_INIT_NVAR(&constant); ZVAL_COPY(&constant, _2$$5); - ZEPHIR_CALL_METHOD(&constantReflection, &reflection, "getreflectionconstant", &_3, 324, &constant); + ZEPHIR_CALL_METHOD(&constantReflection, &reflection, "getreflectionconstant", &_3, 336, &constant); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&comment, &constantReflection, "getdoccomment", NULL, 0); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&comment)) { ZEPHIR_INIT_NVAR(&constantAnnotations); - ZEPHIR_CALL_METHOD(&_4$$7, &reflection, "getfilename", NULL, 321); + ZEPHIR_CALL_METHOD(&_4$$7, &reflection, "getfilename", NULL, 333); zephir_check_call_status(); ZVAL_LONG(&_5$$7, line); ZEPHIR_LAST_CALL_STATUS = phannot_parse_annotations(&constantAnnotations, &comment, &_4$$7, &_5$$7); @@ -156,7 +156,7 @@ PHP_METHOD(Phalcon_Annotations_Reader, parse) zephir_array_update_string(&annotations, SL("constants"), &anotationsConstants, PH_COPY | PH_SEPARATE); } } - ZEPHIR_CALL_METHOD(&properties, &reflection, "getproperties", NULL, 325); + ZEPHIR_CALL_METHOD(&properties, &reflection, "getproperties", NULL, 337); zephir_check_call_status(); if (zephir_fast_count_int(&properties)) { line = 1; @@ -172,7 +172,7 @@ PHP_METHOD(Phalcon_Annotations_Reader, parse) zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&comment)) { ZEPHIR_INIT_NVAR(&propertyAnnotations); - ZEPHIR_CALL_METHOD(&_7$$12, &reflection, "getfilename", NULL, 321); + ZEPHIR_CALL_METHOD(&_7$$12, &reflection, "getfilename", NULL, 333); zephir_check_call_status(); ZVAL_LONG(&_8$$12, line); ZEPHIR_LAST_CALL_STATUS = phannot_parse_annotations(&propertyAnnotations, &comment, &_7$$12, &_8$$12); @@ -206,7 +206,7 @@ PHP_METHOD(Phalcon_Annotations_Reader, parse) zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&comment)) { ZEPHIR_INIT_NVAR(&propertyAnnotations); - ZEPHIR_CALL_METHOD(&_12$$15, &reflection, "getfilename", NULL, 321); + ZEPHIR_CALL_METHOD(&_12$$15, &reflection, "getfilename", NULL, 333); zephir_check_call_status(); ZVAL_LONG(&_13$$15, line); ZEPHIR_LAST_CALL_STATUS = phannot_parse_annotations(&propertyAnnotations, &comment, &_12$$15, &_13$$15); @@ -224,7 +224,7 @@ PHP_METHOD(Phalcon_Annotations_Reader, parse) zephir_array_update_string(&annotations, SL("properties"), &annotationsProperties, PH_COPY | PH_SEPARATE); } } - ZEPHIR_CALL_METHOD(&methods, &reflection, "getmethods", NULL, 326); + ZEPHIR_CALL_METHOD(&methods, &reflection, "getmethods", NULL, 338); zephir_check_call_status(); if (0 == ZEPHIR_IS_EMPTY(&methods)) { ZEPHIR_INIT_VAR(&annotationsMethods); diff --git a/ext/phalcon/annotations/reflection.zep.c b/ext/phalcon/annotations/reflection.zep.c index 73104d820e..45b83ce3a2 100644 --- a/ext/phalcon/annotations/reflection.zep.c +++ b/ext/phalcon/annotations/reflection.zep.c @@ -100,7 +100,7 @@ PHP_METHOD(Phalcon_Annotations_Reflection, __construct) } else { zephir_get_arrval(&reflectionData, reflectionData_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 385, &reflectionData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 394, &reflectionData); ZEPHIR_MM_RESTORE(); } @@ -131,16 +131,16 @@ PHP_METHOD(Phalcon_Annotations_Reflection, getClassAnnotations) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 386, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 395, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { zephir_memory_observe(&reflectionClass); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 385, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 394, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_string_fetch(&reflectionClass, &_1$$3, SL("class"), 0)) { ZEPHIR_INIT_VAR(&_2$$4); object_init_ex(&_2$$4, phalcon_annotations_collection_ce); ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 84, &reflectionClass); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 386, &_2$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 395, &_2$$4); } } RETURN_MM_MEMBER(getThis(), "classAnnotations"); @@ -177,7 +177,7 @@ PHP_METHOD(Phalcon_Annotations_Reflection, getConstantsAnnotations) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&reflectionConstants); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 385, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 394, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_string_fetch(&reflectionConstants, &_0, SL("constants"), 0)) { _1$$3 = Z_TYPE_P(&reflectionConstants) == IS_ARRAY; if (_1$$3) { @@ -267,7 +267,7 @@ PHP_METHOD(Phalcon_Annotations_Reflection, getPropertiesAnnotations) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&reflectionProperties); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 385, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 394, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_string_fetch(&reflectionProperties, &_0, SL("properties"), 0)) { _1$$3 = Z_TYPE_P(&reflectionProperties) == IS_ARRAY; if (_1$$3) { @@ -357,7 +357,7 @@ PHP_METHOD(Phalcon_Annotations_Reflection, getMethodsAnnotations) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&reflectionMethods); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 385, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 394, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_string_fetch(&reflectionMethods, &_0, SL("methods"), 0)) { _1$$3 = Z_TYPE_P(&reflectionMethods) == IS_ARRAY; if (_1$$3) { diff --git a/ext/phalcon/assets/collection.zep.c b/ext/phalcon/assets/collection.zep.c index 40b1569b43..836b026611 100644 --- a/ext/phalcon/assets/collection.zep.c +++ b/ext/phalcon/assets/collection.zep.c @@ -117,7 +117,7 @@ PHP_METHOD(Phalcon_Assets_Collection, add) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &asset); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "addasset", NULL, 327, asset); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "addasset", NULL, 339, asset); zephir_check_call_status(); RETURN_THIS(); } @@ -212,7 +212,7 @@ PHP_METHOD(Phalcon_Assets_Collection, addCss) } else { ZVAL_BOOL(&_2, 0); } - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processadd", NULL, 328, &_0, &path_zv, isLocal, &_1, &attributes, &version_zv, &_2); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processadd", NULL, 340, &_0, &path_zv, isLocal, &_1, &attributes, &version_zv, &_2); zephir_check_call_status(); RETURN_MM(); } @@ -255,7 +255,7 @@ PHP_METHOD(Phalcon_Assets_Collection, addInline) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &code); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "addasset", NULL, 327, code); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "addasset", NULL, 339, code); zephir_check_call_status(); RETURN_THIS(); } @@ -314,7 +314,7 @@ PHP_METHOD(Phalcon_Assets_Collection, addInlineCss) } else { ZVAL_BOOL(&_1, 0); } - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processaddinline", NULL, 329, &_0, &content_zv, &_1, &attributes); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processaddinline", NULL, 341, &_0, &content_zv, &_1, &attributes); zephir_check_call_status(); RETURN_MM(); } @@ -373,7 +373,7 @@ PHP_METHOD(Phalcon_Assets_Collection, addInlineJs) } else { ZVAL_BOOL(&_1, 0); } - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processaddinline", NULL, 329, &_0, &content_zv, &_1, &attributes); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processaddinline", NULL, 341, &_0, &content_zv, &_1, &attributes); zephir_check_call_status(); RETURN_MM(); } @@ -468,7 +468,7 @@ PHP_METHOD(Phalcon_Assets_Collection, addJs) } else { ZVAL_BOOL(&_2, 0); } - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processadd", NULL, 328, &_0, &path_zv, isLocal, &_1, &attributes, &version_zv, &_2); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processadd", NULL, 340, &_0, &path_zv, isLocal, &_1, &attributes, &version_zv, &_2); zephir_check_call_status(); RETURN_MM(); } @@ -490,7 +490,7 @@ PHP_METHOD(Phalcon_Assets_Collection, count) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("assets", 6, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 387, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 396, PH_NOISY_CC | PH_READONLY); RETURN_LONG(zephir_fast_count_int(&_0)); } @@ -542,7 +542,7 @@ PHP_METHOD(Phalcon_Assets_Collection, getIterator) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); object_init_ex(return_value, spl_ce_ArrayIterator); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 387, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 396, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 18, &_0); zephir_check_call_status(); RETURN_MM(); @@ -598,7 +598,7 @@ PHP_METHOD(Phalcon_Assets_Collection, getRealTargetPath) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&basePath_zv); ZVAL_STR_COPY(&basePath_zv, basePath); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 388, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 397, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&completePath); ZEPHIR_CONCAT_VV(&completePath, &basePath_zv, &_0); ZEPHIR_CALL_METHOD(&_1, this_ptr, "phpfileexists", NULL, 0, &completePath); @@ -671,7 +671,7 @@ PHP_METHOD(Phalcon_Assets_Collection, has) zephir_fetch_params(1, 1, 0, &asset); ZEPHIR_CALL_METHOD(&key, asset, "getassetkey", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 387, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 396, PH_NOISY_CC | PH_READONLY); RETURN_MM_BOOL(zephir_array_isset_value(&_0, &key)); } @@ -712,9 +712,9 @@ PHP_METHOD(Phalcon_Assets_Collection, join) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &flag_param); if (flag) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 389, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 398, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 389, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 398, &__$false); } RETURN_THISW(); } @@ -744,7 +744,7 @@ PHP_METHOD(Phalcon_Assets_Collection, setAttributes) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &attributes_param); zephir_get_arrval(&attributes, attributes_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 390, &attributes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 399, &attributes); RETURN_THIS(); } @@ -769,9 +769,9 @@ PHP_METHOD(Phalcon_Assets_Collection, setAutoVersion) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &flag_param); if (flag) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 391, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 400, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 391, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 400, &__$false); } RETURN_THISW(); } @@ -801,7 +801,7 @@ PHP_METHOD(Phalcon_Assets_Collection, setFilters) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &filters_param); zephir_get_arrval(&filters, filters_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 392, &filters); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 401, &filters); RETURN_THIS(); } @@ -826,7 +826,7 @@ PHP_METHOD(Phalcon_Assets_Collection, setPrefix) Z_PARAM_STR(prefix) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&prefix_zv, prefix); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 393, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 402, &prefix_zv); RETURN_THISW(); } @@ -853,9 +853,9 @@ PHP_METHOD(Phalcon_Assets_Collection, setTargetIsLocal) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &flag_param); if (flag) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 394, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 403, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 394, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 403, &__$false); } RETURN_THISW(); } @@ -881,7 +881,7 @@ PHP_METHOD(Phalcon_Assets_Collection, setVersion) Z_PARAM_STR(version) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&version_zv, version); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 395, &version_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 404, &version_zv); RETURN_THISW(); } @@ -1014,8 +1014,8 @@ PHP_METHOD(Phalcon_Assets_Collection, processAdd) ZEPHIR_CONCAT_SV(&_0, "Phalcon\\Assets\\Asset\\", &className_zv); ZEPHIR_CPY_WRT(&name, &_0); zephir_memory_observe(&flag); - zephir_read_property_cached(&flag, this_ptr, _zephir_prop_0, 396, PH_NOISY_CC); - ZEPHIR_CALL_METHOD(&attrs, this_ptr, "processattributes", NULL, 330, &attributes); + zephir_read_property_cached(&flag, this_ptr, _zephir_prop_0, 405, PH_NOISY_CC); + ZEPHIR_CALL_METHOD(&attrs, this_ptr, "processattributes", NULL, 342, &attributes); zephir_check_call_status(); if (Z_TYPE_P(isLocal) != IS_NULL) { ZEPHIR_INIT_NVAR(&flag); @@ -1107,7 +1107,7 @@ PHP_METHOD(Phalcon_Assets_Collection, processAddInline) ZEPHIR_INIT_VAR(&_0); ZEPHIR_CONCAT_SV(&_0, "Phalcon\\Assets\\Inline\\", &className_zv); ZEPHIR_CPY_WRT(&name, &_0); - ZEPHIR_CALL_METHOD(&attrs, this_ptr, "processattributes", NULL, 330, &attributes); + ZEPHIR_CALL_METHOD(&attrs, this_ptr, "processattributes", NULL, 342, &attributes); zephir_check_call_status(); ZEPHIR_INIT_VAR(&asset); zephir_fetch_safe_class(&_1, &name); @@ -1167,7 +1167,7 @@ PHP_METHOD(Phalcon_Assets_Collection, processAttributes) ZEPHIR_CPY_WRT(&_0, &attributes); } else { zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 390, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 399, PH_NOISY_CC); zephir_get_arrval(&_2, &_1); ZEPHIR_CPY_WRT(&_0, &_2); } @@ -1196,7 +1196,7 @@ PHP_METHOD(Phalcon_Assets_Collection, getAttributes) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 390, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 399, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } @@ -1704,9 +1704,9 @@ PHP_METHOD(Phalcon_Assets_Collection, setIsLocal) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &flag_param); if (flag) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 396, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 405, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 396, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 405, &__$false); } RETURN_THISW(); } @@ -1734,7 +1734,7 @@ PHP_METHOD(Phalcon_Assets_Collection, setSourcePath) Z_PARAM_STR(sourcePath) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&sourcePath_zv, sourcePath); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 397, &sourcePath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 406, &sourcePath_zv); RETURN_THISW(); } @@ -1761,7 +1761,7 @@ PHP_METHOD(Phalcon_Assets_Collection, setTargetPath) Z_PARAM_STR(targetPath) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&targetPath_zv, targetPath); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 388, &targetPath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 397, &targetPath_zv); RETURN_THISW(); } @@ -1788,7 +1788,7 @@ PHP_METHOD(Phalcon_Assets_Collection, setTargetUri) Z_PARAM_STR(targetUri) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&targetUri_zv, targetUri); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 398, &targetUri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 407, &targetUri_zv); RETURN_THISW(); } diff --git a/ext/phalcon/assets/manager.zep.c b/ext/phalcon/assets/manager.zep.c index dd5b38a1b9..354b56a312 100644 --- a/ext/phalcon/assets/manager.zep.c +++ b/ext/phalcon/assets/manager.zep.c @@ -97,8 +97,8 @@ PHP_METHOD(Phalcon_Assets_Manager, __construct) } else { zephir_get_arrval(&options, options_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 399, tagFactory); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 400, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 408, tagFactory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 409, &options); ZEPHIR_MM_RESTORE(); } @@ -155,7 +155,7 @@ PHP_METHOD(Phalcon_Assets_Manager, addAssetByType) asset = ZEND_CALL_ARG(execute_data, 2); zephir_memory_observe(&type_zv); ZVAL_STR_COPY(&type_zv, type); - ZEPHIR_CALL_METHOD(&collection, this_ptr, "checkandcreatecollection", NULL, 331, &type_zv); + ZEPHIR_CALL_METHOD(&collection, this_ptr, "checkandcreatecollection", NULL, 343, &type_zv); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &collection, "add", NULL, 0, asset); zephir_check_call_status(); @@ -257,7 +257,7 @@ PHP_METHOD(Phalcon_Assets_Manager, addCss) } else { ZVAL_BOOL(&_3, 0); } - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 332, &path_zv, &_1, &_2, &attributes, &version_zv, &_3); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 344, &path_zv, &_1, &_2, &attributes, &version_zv, &_3); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_4); ZVAL_STRING(&_4, "css"); @@ -319,7 +319,7 @@ PHP_METHOD(Phalcon_Assets_Manager, addInlineCodeByType) code = ZEND_CALL_ARG(execute_data, 2); zephir_memory_observe(&type_zv); ZVAL_STR_COPY(&type_zv, type); - ZEPHIR_CALL_METHOD(&collection, this_ptr, "checkandcreatecollection", NULL, 331, &type_zv); + ZEPHIR_CALL_METHOD(&collection, this_ptr, "checkandcreatecollection", NULL, 343, &type_zv); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &collection, "addinline", NULL, 0, code); zephir_check_call_status(); @@ -381,7 +381,7 @@ PHP_METHOD(Phalcon_Assets_Manager, addInlineCss) } else { ZVAL_BOOL(&_1, 0); } - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 333, &content_zv, &_1, &attributes); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 345, &content_zv, &_1, &attributes); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "css"); @@ -445,7 +445,7 @@ PHP_METHOD(Phalcon_Assets_Manager, addInlineJs) } else { ZVAL_BOOL(&_1, 0); } - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 334, &content_zv, &_1, &attributes); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 346, &content_zv, &_1, &attributes); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "js"); @@ -554,7 +554,7 @@ PHP_METHOD(Phalcon_Assets_Manager, addJs) } else { ZVAL_BOOL(&_3, 0); } - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 335, &path_zv, &_1, &_2, &attributes, &version_zv, &_3); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 347, &path_zv, &_1, &_2, &attributes, &version_zv, &_3); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_4); ZVAL_STRING(&_4, "js"); @@ -584,7 +584,7 @@ PHP_METHOD(Phalcon_Assets_Manager, collection) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "checkandcreatecollection", NULL, 331, &name_zv); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "checkandcreatecollection", NULL, 343, &name_zv); zephir_check_call_status(); RETURN_MM(); } @@ -743,17 +743,17 @@ PHP_METHOD(Phalcon_Assets_Manager, get) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 401, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 410, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(1 != zephir_array_isset_value(&_0, &name_zv))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_assets_exceptions_collectionnotfound_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 336, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 348, &name_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Assets/Manager.zep", 299); ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 401, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 410, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_3, &_2, &name_zv, PH_NOISY | PH_READONLY, "phalcon/Assets/Manager.zep", 302); RETURN_CTOR(&_3); } @@ -787,7 +787,7 @@ PHP_METHOD(Phalcon_Assets_Manager, getCss) ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "css"); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "checkandcreatecollection", NULL, 331, &_0); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "checkandcreatecollection", NULL, 343, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -810,7 +810,7 @@ PHP_METHOD(Phalcon_Assets_Manager, getJs) ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "js"); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "checkandcreatecollection", NULL, 331, &_0); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "checkandcreatecollection", NULL, 343, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -853,7 +853,7 @@ PHP_METHOD(Phalcon_Assets_Manager, has) Z_PARAM_STR(name) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 401, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 410, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &name_zv)); } @@ -985,7 +985,7 @@ PHP_METHOD(Phalcon_Assets_Manager, output) ZVAL_STRING(&output, ""); ZEPHIR_INIT_VAR(&outputParts); array_init(&outputParts); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 400, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 409, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "css"); @@ -1039,18 +1039,18 @@ PHP_METHOD(Phalcon_Assets_Manager, output) if (1 == ZEPHIR_IS_EMPTY(&completeTargetPath)) { ZEPHIR_INIT_VAR(&_3$$9); object_init_ex(&_3$$9, phalcon_assets_exceptions_invalidtargetpath_ce); - ZEPHIR_CALL_METHOD(NULL, &_3$$9, "__construct", NULL, 337, &completeTargetPath); + ZEPHIR_CALL_METHOD(NULL, &_3$$9, "__construct", NULL, 349, &completeTargetPath); zephir_check_call_status(); zephir_throw_exception_debug(&_3$$9, "phalcon/Assets/Manager.zep", 467); ZEPHIR_MM_RESTORE(); return; } - ZEPHIR_CALL_FUNCTION(&_4$$8, "is_dir", NULL, 288, &completeTargetPath); + ZEPHIR_CALL_FUNCTION(&_4$$8, "is_dir", NULL, 294, &completeTargetPath); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_4$$8)) { ZEPHIR_INIT_VAR(&_5$$10); object_init_ex(&_5$$10, phalcon_assets_exceptions_targetpathisdirectory_ce); - ZEPHIR_CALL_METHOD(NULL, &_5$$10, "__construct", NULL, 338, &completeTargetPath); + ZEPHIR_CALL_METHOD(NULL, &_5$$10, "__construct", NULL, 350, &completeTargetPath); zephir_check_call_status(); zephir_throw_exception_debug(&_5$$10, "phalcon/Assets/Manager.zep", 471); ZEPHIR_MM_RESTORE(); @@ -1079,7 +1079,7 @@ PHP_METHOD(Phalcon_Assets_Manager, output) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_8$$14); object_init_ex(&_8$$14, phalcon_assets_exceptions_invalidassetsourcepath_ce); - ZEPHIR_CALL_METHOD(NULL, &_8$$14, "__construct", &_9, 339, &sourcePath); + ZEPHIR_CALL_METHOD(NULL, &_8$$14, "__construct", &_9, 351, &sourcePath); zephir_check_call_status(); zephir_throw_exception_debug(&_8$$14, "phalcon/Assets/Manager.zep", 499); ZEPHIR_MM_RESTORE(); @@ -1093,7 +1093,7 @@ PHP_METHOD(Phalcon_Assets_Manager, output) object_init_ex(&_10$$15, phalcon_assets_exceptions_invalidassettargetpath_ce); ZEPHIR_CALL_METHOD(&_11$$15, &asset, "getpath", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &_10$$15, "__construct", &_12, 340, &_11$$15); + ZEPHIR_CALL_METHOD(NULL, &_10$$15, "__construct", &_12, 352, &_11$$15); zephir_check_call_status(); zephir_throw_exception_debug(&_10$$15, "phalcon/Assets/Manager.zep", 513); ZEPHIR_MM_RESTORE(); @@ -1105,7 +1105,7 @@ PHP_METHOD(Phalcon_Assets_Manager, output) if (ZEPHIR_IS_IDENTICAL(&targetPath, &sourcePath)) { ZEPHIR_INIT_NVAR(&_14$$17); object_init_ex(&_14$$17, phalcon_assets_exceptions_assetsourcetargetcollision_ce); - ZEPHIR_CALL_METHOD(NULL, &_14$$17, "__construct", &_15, 341, &targetPath); + ZEPHIR_CALL_METHOD(NULL, &_14$$17, "__construct", &_15, 353, &targetPath); zephir_check_call_status(); zephir_throw_exception_debug(&_14$$17, "phalcon/Assets/Manager.zep", 521); ZEPHIR_MM_RESTORE(); @@ -1130,15 +1130,15 @@ PHP_METHOD(Phalcon_Assets_Manager, output) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_21$$21, &asset, "getrealsourcepath", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&prefixedPath, this_ptr, "calculateprefixedpath", &_22, 342, collection, &_20$$21, &_21$$21); + ZEPHIR_CALL_METHOD(&prefixedPath, this_ptr, "calculateprefixedpath", &_22, 354, collection, &_20$$21, &_21$$21); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_23$$21, &asset, "getattributes", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_24$$21, &asset, "islocal", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&html, this_ptr, "docallback", &_25, 343, &callback, &_23$$21, &prefixedPath, &_24$$21); + ZEPHIR_CALL_METHOD(&html, this_ptr, "docallback", &_25, 355, &callback, &_23$$21, &prefixedPath, &_24$$21); zephir_check_call_status(); - zephir_read_property_cached(&_26$$21, this_ptr, _zephir_prop_1, 402, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_26$$21, this_ptr, _zephir_prop_1, 411, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_26$$21)) { zend_print_zval(&html, 0); } else { @@ -1151,7 +1151,7 @@ PHP_METHOD(Phalcon_Assets_Manager, output) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&mustFilter, &asset, "getfilter", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&filteredContent, this_ptr, "applyfilters", &_27, 344, &content, &filters, &mustFilter); + ZEPHIR_CALL_METHOD(&filteredContent, this_ptr, "applyfilters", &_27, 356, &content, &filters, &mustFilter); zephir_check_call_status(); if (zephir_is_true(&join)) { zephir_concat_self(&filteredJoinedContent, &filteredContent); @@ -1175,14 +1175,14 @@ PHP_METHOD(Phalcon_Assets_Manager, output) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_32$$28, &asset, "getrealsourcepath", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&prefixedPath, this_ptr, "calculateprefixedpath", &_22, 342, collection, &_31$$28, &_32$$28); + ZEPHIR_CALL_METHOD(&prefixedPath, this_ptr, "calculateprefixedpath", &_22, 354, collection, &_31$$28, &_32$$28); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_33$$28, collection, "getattributes", &_34, 0); zephir_check_call_status(); ZVAL_BOOL(&_35$$28, 1); - ZEPHIR_CALL_METHOD(&html, this_ptr, "docallback", &_25, 343, &callback, &_33$$28, &prefixedPath, &_35$$28); + ZEPHIR_CALL_METHOD(&html, this_ptr, "docallback", &_25, 355, &callback, &_33$$28, &prefixedPath, &_35$$28); zephir_check_call_status(); - zephir_read_property_cached(&_35$$28, this_ptr, _zephir_prop_1, 402, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_35$$28, this_ptr, _zephir_prop_1, 411, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_35$$28)) { zend_print_zval(&html, 0); } else { @@ -1223,7 +1223,7 @@ PHP_METHOD(Phalcon_Assets_Manager, output) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_39$$34); object_init_ex(&_39$$34, phalcon_assets_exceptions_invalidassetsourcepath_ce); - ZEPHIR_CALL_METHOD(NULL, &_39$$34, "__construct", &_9, 339, &sourcePath); + ZEPHIR_CALL_METHOD(NULL, &_39$$34, "__construct", &_9, 351, &sourcePath); zephir_check_call_status(); zephir_throw_exception_debug(&_39$$34, "phalcon/Assets/Manager.zep", 499); ZEPHIR_MM_RESTORE(); @@ -1237,7 +1237,7 @@ PHP_METHOD(Phalcon_Assets_Manager, output) object_init_ex(&_40$$35, phalcon_assets_exceptions_invalidassettargetpath_ce); ZEPHIR_CALL_METHOD(&_41$$35, &asset, "getpath", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &_40$$35, "__construct", &_12, 340, &_41$$35); + ZEPHIR_CALL_METHOD(NULL, &_40$$35, "__construct", &_12, 352, &_41$$35); zephir_check_call_status(); zephir_throw_exception_debug(&_40$$35, "phalcon/Assets/Manager.zep", 513); ZEPHIR_MM_RESTORE(); @@ -1249,7 +1249,7 @@ PHP_METHOD(Phalcon_Assets_Manager, output) if (ZEPHIR_IS_IDENTICAL(&targetPath, &sourcePath)) { ZEPHIR_INIT_NVAR(&_43$$37); object_init_ex(&_43$$37, phalcon_assets_exceptions_assetsourcetargetcollision_ce); - ZEPHIR_CALL_METHOD(NULL, &_43$$37, "__construct", &_15, 341, &targetPath); + ZEPHIR_CALL_METHOD(NULL, &_43$$37, "__construct", &_15, 353, &targetPath); zephir_check_call_status(); zephir_throw_exception_debug(&_43$$37, "phalcon/Assets/Manager.zep", 521); ZEPHIR_MM_RESTORE(); @@ -1274,15 +1274,15 @@ PHP_METHOD(Phalcon_Assets_Manager, output) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_48$$41, &asset, "getrealsourcepath", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&prefixedPath, this_ptr, "calculateprefixedpath", &_22, 342, collection, &_47$$41, &_48$$41); + ZEPHIR_CALL_METHOD(&prefixedPath, this_ptr, "calculateprefixedpath", &_22, 354, collection, &_47$$41, &_48$$41); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_49$$41, &asset, "getattributes", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_50$$41, &asset, "islocal", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&html, this_ptr, "docallback", &_25, 343, &callback, &_49$$41, &prefixedPath, &_50$$41); + ZEPHIR_CALL_METHOD(&html, this_ptr, "docallback", &_25, 355, &callback, &_49$$41, &prefixedPath, &_50$$41); zephir_check_call_status(); - zephir_read_property_cached(&_51$$41, this_ptr, _zephir_prop_1, 402, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_51$$41, this_ptr, _zephir_prop_1, 411, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_51$$41)) { zend_print_zval(&html, 0); } else { @@ -1295,7 +1295,7 @@ PHP_METHOD(Phalcon_Assets_Manager, output) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&mustFilter, &asset, "getfilter", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&filteredContent, this_ptr, "applyfilters", &_27, 344, &content, &filters, &mustFilter); + ZEPHIR_CALL_METHOD(&filteredContent, this_ptr, "applyfilters", &_27, 356, &content, &filters, &mustFilter); zephir_check_call_status(); if (zephir_is_true(&join)) { zephir_concat_self(&filteredJoinedContent, &filteredContent); @@ -1319,14 +1319,14 @@ PHP_METHOD(Phalcon_Assets_Manager, output) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_55$$48, &asset, "getrealsourcepath", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&prefixedPath, this_ptr, "calculateprefixedpath", &_22, 342, collection, &_54$$48, &_55$$48); + ZEPHIR_CALL_METHOD(&prefixedPath, this_ptr, "calculateprefixedpath", &_22, 354, collection, &_54$$48, &_55$$48); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_56$$48, collection, "getattributes", &_34, 0); zephir_check_call_status(); ZVAL_BOOL(&_57$$48, 1); - ZEPHIR_CALL_METHOD(&html, this_ptr, "docallback", &_25, 343, &callback, &_56$$48, &prefixedPath, &_57$$48); + ZEPHIR_CALL_METHOD(&html, this_ptr, "docallback", &_25, 355, &callback, &_56$$48, &prefixedPath, &_57$$48); zephir_check_call_status(); - zephir_read_property_cached(&_57$$48, this_ptr, _zephir_prop_1, 402, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_57$$48, this_ptr, _zephir_prop_1, 411, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_57$$48)) { zend_print_zval(&html, 0); } else { @@ -1345,15 +1345,15 @@ PHP_METHOD(Phalcon_Assets_Manager, output) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_59$$51, collection, "gettargeturi", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&prefixedPath, this_ptr, "calculateprefixedpath", &_22, 342, collection, &_59$$51, &completeTargetPath); + ZEPHIR_CALL_METHOD(&prefixedPath, this_ptr, "calculateprefixedpath", &_22, 354, collection, &_59$$51, &completeTargetPath); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_60$$51, collection, "getattributes", &_34, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_61$$51, collection, "gettargetislocal", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&html, this_ptr, "docallback", &_25, 343, &callback, &_60$$51, &prefixedPath, &_61$$51); + ZEPHIR_CALL_METHOD(&html, this_ptr, "docallback", &_25, 355, &callback, &_60$$51, &prefixedPath, &_61$$51); zephir_check_call_status(); - zephir_read_property_cached(&_62$$51, this_ptr, _zephir_prop_1, 402, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_62$$51, this_ptr, _zephir_prop_1, 411, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_62$$51)) { zend_print_zval(&html, 0); } else { @@ -1501,13 +1501,13 @@ PHP_METHOD(Phalcon_Assets_Manager, outputInline) ZEPHIR_CALL_METHOD(&content, &code, "getcontent", NULL, 0); zephir_check_call_status(); ZVAL_BOOL(&_2$$4, 1); - ZEPHIR_CALL_METHOD(&_1$$4, this_ptr, "applyfilters", &_3, 344, &content, &filters, &_2$$4); + ZEPHIR_CALL_METHOD(&_1$$4, this_ptr, "applyfilters", &_3, 356, &content, &filters, &_2$$4); zephir_check_call_status(); ZEPHIR_CPY_WRT(&content, &_1$$4); if (ZEPHIR_IS_TRUE_IDENTICAL(&join)) { zephir_concat_self(&joinedContent, &content); } else { - zephir_read_property_cached(&_4$$6, this_ptr, _zephir_prop_0, 399, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$6, this_ptr, _zephir_prop_0, 408, PH_NOISY_CC | PH_READONLY); ZVAL_BOOL(&_6$$6, 1); ZEPHIR_CALL_METHOD(&_5$$6, &_4$$6, "element", NULL, 0, type, &content, &attributes, &_6$$6); zephir_check_call_status(); @@ -1541,13 +1541,13 @@ PHP_METHOD(Phalcon_Assets_Manager, outputInline) ZEPHIR_CALL_METHOD(&content, &code, "getcontent", NULL, 0); zephir_check_call_status(); ZVAL_BOOL(&_12$$7, 1); - ZEPHIR_CALL_METHOD(&_11$$7, this_ptr, "applyfilters", &_3, 344, &content, &filters, &_12$$7); + ZEPHIR_CALL_METHOD(&_11$$7, this_ptr, "applyfilters", &_3, 356, &content, &filters, &_12$$7); zephir_check_call_status(); ZEPHIR_CPY_WRT(&content, &_11$$7); if (ZEPHIR_IS_TRUE_IDENTICAL(&join)) { zephir_concat_self(&joinedContent, &content); } else { - zephir_read_property_cached(&_13$$9, this_ptr, _zephir_prop_0, 399, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$9, this_ptr, _zephir_prop_0, 408, PH_NOISY_CC | PH_READONLY); ZVAL_BOOL(&_15$$9, 1); ZEPHIR_CALL_METHOD(&_14$$9, &_13$$9, "element", NULL, 0, type, &content, &attributes, &_15$$9); zephir_check_call_status(); @@ -1561,7 +1561,7 @@ PHP_METHOD(Phalcon_Assets_Manager, outputInline) } ZEPHIR_INIT_NVAR(&code); if (ZEPHIR_IS_TRUE_IDENTICAL(&join)) { - zephir_read_property_cached(&_18$$10, this_ptr, _zephir_prop_0, 399, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$10, this_ptr, _zephir_prop_0, 408, PH_NOISY_CC | PH_READONLY); ZVAL_BOOL(&_20$$10, 1); ZEPHIR_CALL_METHOD(&_19$$10, &_18$$10, "element", NULL, 0, type, &joinedContent, &attributes, &_20$$10); zephir_check_call_status(); @@ -1571,7 +1571,7 @@ PHP_METHOD(Phalcon_Assets_Manager, outputInline) ZEPHIR_CONCAT_VV(&_22$$10, &_19$$10, &_21$$10); zephir_concat_self(&html, &_22$$10); } - zephir_read_property_cached(&_23$$3, this_ptr, _zephir_prop_1, 402, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$3, this_ptr, _zephir_prop_1, 411, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_23$$3)) { zend_print_zval(&html, 0); } else { @@ -1767,7 +1767,7 @@ PHP_METHOD(Phalcon_Assets_Manager, setOptions) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &options_param); zephir_get_arrval(&options, options_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 400, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 409, &options); RETURN_THIS(); } @@ -1794,9 +1794,9 @@ PHP_METHOD(Phalcon_Assets_Manager, useImplicitOutput) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &implicitOutput_param); if (implicitOutput) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 402, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 411, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 402, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 411, &__$false); } RETURN_THISW(); } @@ -1862,7 +1862,7 @@ PHP_METHOD(Phalcon_Assets_Manager, applyFilters) if (UNEXPECTED(_1$$4)) { ZEPHIR_INIT_NVAR(&_2$$5); object_init_ex(&_2$$5, phalcon_assets_exceptions_invalidfilter_ce); - ZEPHIR_CALL_METHOD(NULL, &_2$$5, "__construct", &_3, 345); + ZEPHIR_CALL_METHOD(NULL, &_2$$5, "__construct", &_3, 357); zephir_check_call_status(); zephir_throw_exception_debug(&_2$$5, "phalcon/Assets/Manager.zep", 880); ZEPHIR_MM_RESTORE(); @@ -1897,7 +1897,7 @@ PHP_METHOD(Phalcon_Assets_Manager, applyFilters) if (UNEXPECTED(_7$$6)) { ZEPHIR_INIT_NVAR(&_8$$7); object_init_ex(&_8$$7, phalcon_assets_exceptions_invalidfilter_ce); - ZEPHIR_CALL_METHOD(NULL, &_8$$7, "__construct", &_3, 345); + ZEPHIR_CALL_METHOD(NULL, &_8$$7, "__construct", &_3, 357); zephir_check_call_status(); zephir_throw_exception_debug(&_8$$7, "phalcon/Assets/Manager.zep", 880); ZEPHIR_MM_RESTORE(); @@ -2014,7 +2014,7 @@ PHP_METHOD(Phalcon_Assets_Manager, checkAndCreateCollection) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&type_zv); ZVAL_STR_COPY(&type_zv, type); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 401, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 410, PH_NOISY_CC | PH_READONLY); if (1 != zephir_array_isset_value(&_0, &type_zv)) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_assets_collection_ce); @@ -2025,7 +2025,7 @@ PHP_METHOD(Phalcon_Assets_Manager, checkAndCreateCollection) zephir_update_property_array(this_ptr, SL("collections"), &type_zv, &_1$$3); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 401, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 410, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_3, &_2, &type_zv, PH_NOISY | PH_READONLY, "phalcon/Assets/Manager.zep", 936); RETURN_CTOR(&_3); } @@ -2080,7 +2080,7 @@ PHP_METHOD(Phalcon_Assets_Manager, cssLink) ZVAL_STRING(&_2, "text/css"); ZEPHIR_INIT_VAR(&_3); ZVAL_STRING(&_3, "href"); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processparameters", NULL, 346, parameters, &_0, &_1, &_2, &_3); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processparameters", NULL, 358, parameters, &_0, &_1, &_2, &_3); zephir_check_call_status(); RETURN_MM(); } @@ -2189,7 +2189,7 @@ PHP_METHOD(Phalcon_Assets_Manager, jsLink) ZVAL_STRING(&_2, "application/javascript"); ZEPHIR_INIT_VAR(&_3); ZVAL_STRING(&_3, "src"); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processparameters", NULL, 346, parameters, &_0, &_1, &_2, &_3); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processparameters", NULL, 358, parameters, &_0, &_1, &_2, &_3); zephir_check_call_status(); RETURN_MM(); } @@ -2310,10 +2310,10 @@ PHP_METHOD(Phalcon_Assets_Manager, processParameters) zephir_array_fetch(&tag, ¶ms, &name_zv, PH_NOISY, "phalcon/Assets/Manager.zep", 1057); zephir_array_unset(¶ms, &name_zv, PH_SEPARATE); if (local) { - zephir_read_property_cached(&_8$$11, this_ptr, _zephir_prop_0, 403, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$11, this_ptr, _zephir_prop_0, 412, PH_NOISY_CC | PH_READONLY); _9$$11 = Z_TYPE_P(&_8$$11) != IS_NULL; if (_9$$11) { - zephir_read_property_cached(&_10$$11, this_ptr, _zephir_prop_0, 403, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$11, this_ptr, _zephir_prop_0, 412, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_12$$11); ZVAL_STRING(&_12$$11, "url"); ZEPHIR_CALL_METHOD(&_11$$11, &_10$$11, "has", NULL, 0, &_12$$11); @@ -2321,7 +2321,7 @@ PHP_METHOD(Phalcon_Assets_Manager, processParameters) _9$$11 = zephir_is_true(&_11$$11); } if (_9$$11) { - zephir_read_property_cached(&_13$$12, this_ptr, _zephir_prop_0, 403, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$12, this_ptr, _zephir_prop_0, 412, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_15$$12); ZVAL_STRING(&_15$$12, "url"); ZEPHIR_CALL_METHOD(&_14$$12, &_13$$12, "get", NULL, 0, &_15$$12); @@ -2339,7 +2339,7 @@ PHP_METHOD(Phalcon_Assets_Manager, processParameters) ZEPHIR_CPY_WRT(&tag, &_19$$13); } } - zephir_read_property_cached(&_20, this_ptr, _zephir_prop_1, 399, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20, this_ptr, _zephir_prop_1, 408, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&helper, &_20, "newinstance", NULL, 0, &helperClass_zv); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_21); diff --git a/ext/phalcon/assets/traits/attributestrait.zep.c b/ext/phalcon/assets/traits/attributestrait.zep.c index 14f1ed8462..a3c3ec3d21 100644 --- a/ext/phalcon/assets/traits/attributestrait.zep.c +++ b/ext/phalcon/assets/traits/attributestrait.zep.c @@ -65,7 +65,7 @@ PHP_METHOD(Phalcon_Assets_Traits_AttributesTrait, getAttributes) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 404, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 413, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } diff --git a/ext/phalcon/assets/traits/sourcetargettrait.zep.c b/ext/phalcon/assets/traits/sourcetargettrait.zep.c index 0628b58aa5..9d9bb208a9 100644 --- a/ext/phalcon/assets/traits/sourcetargettrait.zep.c +++ b/ext/phalcon/assets/traits/sourcetargettrait.zep.c @@ -115,9 +115,9 @@ PHP_METHOD(Phalcon_Assets_Traits_SourceTargetTrait, setIsLocal) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &flag_param); if (flag) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 405, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 414, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 405, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 414, &__$false); } RETURN_THISW(); } @@ -145,7 +145,7 @@ PHP_METHOD(Phalcon_Assets_Traits_SourceTargetTrait, setSourcePath) Z_PARAM_STR(sourcePath) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&sourcePath_zv, sourcePath); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 406, &sourcePath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 415, &sourcePath_zv); RETURN_THISW(); } @@ -172,7 +172,7 @@ PHP_METHOD(Phalcon_Assets_Traits_SourceTargetTrait, setTargetPath) Z_PARAM_STR(targetPath) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&targetPath_zv, targetPath); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 407, &targetPath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 416, &targetPath_zv); RETURN_THISW(); } @@ -199,7 +199,7 @@ PHP_METHOD(Phalcon_Assets_Traits_SourceTargetTrait, setTargetUri) Z_PARAM_STR(targetUri) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&targetUri_zv, targetUri); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 408, &targetUri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 417, &targetUri_zv); RETURN_THISW(); } diff --git a/ext/phalcon/auth/access/accesslocator.zep.c b/ext/phalcon/auth/access/accesslocator.zep.c index ad7ee43aec..892f089368 100644 --- a/ext/phalcon/auth/access/accesslocator.zep.c +++ b/ext/phalcon/auth/access/accesslocator.zep.c @@ -81,7 +81,7 @@ PHP_METHOD(Phalcon_Auth_Access_AccessLocator, newInstance) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 409, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 418, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, this_ptr, "getservice", NULL, 0, &name_zv); zephir_check_call_status(); ZEPHIR_CALL_CE_STATIC(&_0, phalcon_auth_internal_containerresolver_ce, "resolvefresh", NULL, 0, &_1, &_2); diff --git a/ext/phalcon/auth/access/acl.zep.c b/ext/phalcon/auth/access/acl.zep.c index 61d0810d61..f601552827 100644 --- a/ext/phalcon/auth/access/acl.zep.c +++ b/ext/phalcon/auth/access/acl.zep.c @@ -108,16 +108,16 @@ PHP_METHOD(Phalcon_Auth_Access_Acl, __construct) } else { zephir_get_arrval(&options, options_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 410, acl); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 419, acl); zephir_memory_observe(&value); if (zephir_array_isset_string_fetch(&value, &options, SL("guestRole"), 0)) { zephir_cast_to_string(&_0$$3, &value); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 411, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 420, &_0$$3); } ZEPHIR_OBS_NVAR(&value); if (zephir_array_isset_string_fetch(&value, &options, SL("moduleSeparator"), 0)) { zephir_cast_to_string(&_1$$4, &value); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 412, &_1$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 421, &_1$$4); } ZEPHIR_MM_RESTORE(); } @@ -191,17 +191,17 @@ PHP_METHOD(Phalcon_Auth_Access_Acl, isAllowed) } else { zephir_get_arrval(&context, context_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 413, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 422, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_1, "in_array", NULL, 87, &actionName_zv, &_0, &__$true); zephir_check_call_status(); if (zephir_is_true(&_1)) { RETURN_MM_BOOL(1); } zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 414, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 423, PH_NOISY_CC); _3 = !(ZEPHIR_IS_EMPTY(&_2)); if (_3) { - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 414, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 423, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_5, "in_array", NULL, 87, &actionName_zv, &_4, &__$true); zephir_check_call_status(); _3 = !zephir_is_true(&_5); @@ -218,7 +218,7 @@ PHP_METHOD(Phalcon_Auth_Access_Acl, isAllowed) if (_6) { ZEPHIR_INIT_VAR(&_7$$5); object_init_ex(&_7$$5, phalcon_auth_exceptions_missinghandlercontext_ce); - ZEPHIR_CALL_METHOD(NULL, &_7$$5, "__construct", NULL, 347); + ZEPHIR_CALL_METHOD(NULL, &_7$$5, "__construct", NULL, 359); zephir_check_call_status(); zephir_throw_exception_debug(&_7$$5, "phalcon/Auth/Access/Acl.zep", 93); ZEPHIR_MM_RESTORE(); @@ -232,7 +232,7 @@ PHP_METHOD(Phalcon_Auth_Access_Acl, isAllowed) _8 = !ZEPHIR_IS_STRING_IDENTICAL(&module, ""); } if (_8) { - zephir_read_property_cached(&_9$$6, this_ptr, _zephir_prop_2, 412, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$6, this_ptr, _zephir_prop_2, 421, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&component); ZEPHIR_CONCAT_VVV(&component, &module, &_9$$6, &handler); } @@ -244,7 +244,7 @@ PHP_METHOD(Phalcon_Auth_Access_Acl, isAllowed) ZEPHIR_INIT_NVAR(¶ms); ZVAL_NULL(¶ms); } - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_3, 410, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_3, 419, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_11, this_ptr, "resolverole", NULL, 0, guard); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_10, "isallowed", NULL, 0, &_11, &component, &actionName_zv, ¶ms); @@ -304,7 +304,7 @@ PHP_METHOD(Phalcon_Auth_Access_Acl, resolveRole) ZVAL_STRING(&_1, "Authenticated user"); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "Phalcon\\Acl\\RoleAwareInterface"); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 348, &_1, &_2); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 360, &_1, &_2); zephir_check_call_status(); zephir_throw_exception_debug(&_0, "phalcon/Auth/Access/Acl.zep", 147); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/auth/adapter/config/memoryadapterconfig.zep.c b/ext/phalcon/auth/adapter/config/memoryadapterconfig.zep.c index 290acb7683..d979369c13 100644 --- a/ext/phalcon/auth/adapter/config/memoryadapterconfig.zep.c +++ b/ext/phalcon/auth/adapter/config/memoryadapterconfig.zep.c @@ -87,7 +87,7 @@ PHP_METHOD(Phalcon_Auth_Adapter_Config_MemoryAdapterConfig, __construct) zephir_memory_observe(&model_zv); ZVAL_STR_COPY(&model_zv, model); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 415, &users); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 424, &users); ZEPHIR_CALL_PARENT(NULL, phalcon_auth_adapter_config_memoryadapterconfig_ce, getThis(), "__construct", NULL, 0, &model_zv); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/auth/adapter/config/modeladapterconfig.zep.c b/ext/phalcon/auth/adapter/config/modeladapterconfig.zep.c index 58105e0a64..89e2d13218 100644 --- a/ext/phalcon/auth/adapter/config/modeladapterconfig.zep.c +++ b/ext/phalcon/auth/adapter/config/modeladapterconfig.zep.c @@ -92,7 +92,7 @@ PHP_METHOD(Phalcon_Auth_Adapter_Config_ModelAdapterConfig, __construct) ZVAL_STRING(&_2$$3, "model"); ZEPHIR_INIT_VAR(&_3$$3); ZVAL_STRING(&_3$$3, " class name"); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 349, &_1$$3, &_2$$3, &_3$$3); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 361, &_1$$3, &_2$$3, &_3$$3); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$3, "phalcon/Auth/Adapter/Config/ModelAdapterConfig.zep", 36); ZEPHIR_MM_RESTORE(); @@ -105,13 +105,13 @@ PHP_METHOD(Phalcon_Auth_Adapter_Config_ModelAdapterConfig, __construct) ZVAL_STRING(&_5$$4, "Model adapter"); ZEPHIR_INIT_VAR(&_6$$4); ZVAL_STRING(&_6$$4, "idColumn"); - ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 349, &_5$$4, &_6$$4); + ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 361, &_5$$4, &_6$$4); zephir_check_call_status(); zephir_throw_exception_debug(&_4$$4, "phalcon/Auth/Adapter/Config/ModelAdapterConfig.zep", 43); ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 416, &idColumn_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 425, &idColumn_zv); ZEPHIR_CALL_PARENT(NULL, phalcon_auth_adapter_config_modeladapterconfig_ce, getThis(), "__construct", NULL, 0, &model_zv); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/auth/adapter/config/streamadapterconfig.zep.c b/ext/phalcon/auth/adapter/config/streamadapterconfig.zep.c index 6e3bd784a4..f7116349a2 100644 --- a/ext/phalcon/auth/adapter/config/streamadapterconfig.zep.c +++ b/ext/phalcon/auth/adapter/config/streamadapterconfig.zep.c @@ -88,13 +88,13 @@ PHP_METHOD(Phalcon_Auth_Adapter_Config_StreamAdapterConfig, __construct) ZVAL_STRING(&_2$$3, "file"); ZEPHIR_INIT_VAR(&_3$$3); ZVAL_STRING(&_3$$3, " path"); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 349, &_1$$3, &_2$$3, &_3$$3); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 361, &_1$$3, &_2$$3, &_3$$3); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$3, "phalcon/Auth/Adapter/Config/StreamAdapterConfig.zep", 36); ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 417, &file_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 426, &file_zv); ZEPHIR_CALL_PARENT(NULL, phalcon_auth_adapter_config_streamadapterconfig_ce, getThis(), "__construct", NULL, 0, &model_zv); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/auth/adapter/memory.zep.c b/ext/phalcon/auth/adapter/memory.zep.c index 5fd5cf1ce4..3f50c2c5ea 100644 --- a/ext/phalcon/auth/adapter/memory.zep.c +++ b/ext/phalcon/auth/adapter/memory.zep.c @@ -156,9 +156,9 @@ PHP_METHOD(Phalcon_Auth_Adapter_Memory, fromOptions) ZVAL_STRING(&_3, "model"); ZEPHIR_CALL_CE_STATIC(&_4, phalcon_auth_internal_options_ce, "stringornull", NULL, 0, &options, &_3); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 350, &_1, &_4); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 362, &_1, &_4); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 351, hasher, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 363, hasher, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -197,11 +197,11 @@ PHP_METHOD(Phalcon_Auth_Adapter_Memory, retrieveById) ZEPHIR_THROW_EXCEPTION_DEBUG_STR(zend_ce_type_error, "The parameter must be 'int' or 'string'", "phalcon/Auth/Adapter/Memory.zep", 68); return; } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 418, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 427, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_1, id))) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 418, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 427, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_3, &_2, id, PH_NOISY | PH_READONLY, "phalcon/Auth/Adapter/Memory.zep", 75); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "hydrate", NULL, 0, &_3); zephir_check_call_status(); @@ -226,7 +226,7 @@ PHP_METHOD(Phalcon_Auth_Adapter_Memory, loadUsers) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 419, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 428, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getusers", NULL, 0); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/auth/adapter/model.zep.c b/ext/phalcon/auth/adapter/model.zep.c index de408cf81f..101ce0a9c0 100644 --- a/ext/phalcon/auth/adapter/model.zep.c +++ b/ext/phalcon/auth/adapter/model.zep.c @@ -111,9 +111,9 @@ PHP_METHOD(Phalcon_Auth_Adapter_Model, fromOptions) ZEPHIR_INIT_NVAR(&_4); ZVAL_STRING(&_4, "id"); } - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 352, &_1, &_4); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 364, &_1, &_4); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 353, hasher, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 365, hasher, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -151,9 +151,9 @@ PHP_METHOD(Phalcon_Auth_Adapter_Model, createRememberToken) ZEPHIR_CALL_CE_STATIC(NULL, phalcon_auth_exceptions_doesnotimplement_ce, "assert", NULL, 0, user, &_0, &_1, &_2); zephir_check_call_status(); ZVAL_LONG(&_3, 30); - ZEPHIR_CALL_FUNCTION(&_4, "random_bytes", NULL, 303, &_3); + ZEPHIR_CALL_FUNCTION(&_4, "random_bytes", NULL, 312, &_3); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&_5, "bin2hex", NULL, 304, &_4); + ZEPHIR_CALL_FUNCTION(&_5, "bin2hex", NULL, 313, &_4); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(user, "createremembertoken", NULL, 0, &_5); zephir_check_call_status(); @@ -258,7 +258,7 @@ PHP_METHOD(Phalcon_Auth_Adapter_Model, retrieveByCredentials) zephir_fast_join_str(&_8, SL(" AND "), &conditions); zephir_array_update_string(&_7, SL("conditions"), &_8, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_7, SL("bind"), &bind, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(&found, this_ptr, "findfirstasauthuser", NULL, 354, &_7); + ZEPHIR_CALL_METHOD(&found, this_ptr, "findfirstasauthuser", NULL, 366, &_7); zephir_check_call_status(); if (Z_TYPE_P(&found) == IS_NULL) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "burnhash", NULL, 0); @@ -303,7 +303,7 @@ PHP_METHOD(Phalcon_Auth_Adapter_Model, retrieveById) } ZEPHIR_INIT_VAR(&_1); zephir_create_array(&_1, 2, 0); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 420, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 429, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_3, &_2, "getidcolumn", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_4); @@ -313,7 +313,7 @@ PHP_METHOD(Phalcon_Auth_Adapter_Model, retrieveById) zephir_create_array(&_5, 1, 0); zephir_array_update_string(&_5, SL("id"), id, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_1, SL("bind"), &_5, PH_COPY | PH_SEPARATE); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "findfirstasauthuser", NULL, 354, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "findfirstasauthuser", NULL, 366, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -416,7 +416,7 @@ PHP_METHOD(Phalcon_Auth_Adapter_Model, findFirstAsAuthUser) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, ¶meters_param); zephir_get_arrval(¶meters, parameters_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 420, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 429, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&modelClass, &_0, "getmodel", NULL, 0); zephir_check_call_status(); _1 = zephir_fetch_class(&modelClass); diff --git a/ext/phalcon/auth/adapter/stream.zep.c b/ext/phalcon/auth/adapter/stream.zep.c index 4d8e32ee70..dccc154804 100644 --- a/ext/phalcon/auth/adapter/stream.zep.c +++ b/ext/phalcon/auth/adapter/stream.zep.c @@ -104,9 +104,9 @@ PHP_METHOD(Phalcon_Auth_Adapter_Stream, fromOptions) ZVAL_STRING(&_2, "model"); ZEPHIR_CALL_CE_STATIC(&_4, phalcon_auth_internal_options_ce, "stringornull", NULL, 0, &options, &_2); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 355, &_1, &_4); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 367, &_1, &_4); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 356, hasher, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 368, hasher, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -147,7 +147,7 @@ PHP_METHOD(Phalcon_Auth_Adapter_Stream, loadUsers) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 421, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 430, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&path, &_0, "getfile", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_1, this_ptr, "phpfileexists", NULL, 0, &path); @@ -155,7 +155,7 @@ PHP_METHOD(Phalcon_Auth_Adapter_Stream, loadUsers) if (!zephir_is_true(&_1)) { ZEPHIR_INIT_VAR(&_2$$3); object_init_ex(&_2$$3, phalcon_auth_exceptions_filedoesnotexist_ce); - ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 357, &path); + ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 369, &path); zephir_check_call_status(); zephir_throw_exception_debug(&_2$$3, "phalcon/Auth/Adapter/Stream.zep", 73); ZEPHIR_MM_RESTORE(); @@ -166,7 +166,7 @@ PHP_METHOD(Phalcon_Auth_Adapter_Stream, loadUsers) if (ZEPHIR_IS_FALSE_IDENTICAL(&contents)) { ZEPHIR_INIT_VAR(&_3$$4); object_init_ex(&_3$$4, phalcon_auth_exceptions_filecannotread_ce); - ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", NULL, 358, &path); + ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", NULL, 370, &path); zephir_check_call_status(); zephir_throw_exception_debug(&_3$$4, "phalcon/Auth/Adapter/Stream.zep", 79); ZEPHIR_MM_RESTORE(); @@ -183,7 +183,7 @@ PHP_METHOD(Phalcon_Auth_Adapter_Stream, loadUsers) } ZVAL_BOOL(&_5$$5, 1); - ZEPHIR_CALL_METHOD(&data, &_4$$5, "__invoke", NULL, 359, &contents, &_5$$5); + ZEPHIR_CALL_METHOD(&data, &_4$$5, "__invoke", NULL, 371, &contents, &_5$$5); zephir_check_call_status_or_jump(try_end_1); try_end_1: @@ -197,7 +197,7 @@ PHP_METHOD(Phalcon_Auth_Adapter_Stream, loadUsers) ZEPHIR_CPY_WRT(&ex, &_6); ZEPHIR_INIT_VAR(&_7$$6); object_init_ex(&_7$$6, phalcon_auth_exceptions_filenotvalidjson_ce); - ZEPHIR_CALL_METHOD(NULL, &_7$$6, "__construct", NULL, 360, &path, &ex); + ZEPHIR_CALL_METHOD(NULL, &_7$$6, "__construct", NULL, 372, &path, &ex); zephir_check_call_status(); zephir_throw_exception_debug(&_7$$6, "phalcon/Auth/Adapter/Stream.zep", 85); ZEPHIR_MM_RESTORE(); @@ -207,7 +207,7 @@ PHP_METHOD(Phalcon_Auth_Adapter_Stream, loadUsers) if (Z_TYPE_P(&data) != IS_ARRAY) { ZEPHIR_INIT_VAR(&_8$$7); object_init_ex(&_8$$7, phalcon_auth_exceptions_filedoesnotcontainjson_ce); - ZEPHIR_CALL_METHOD(NULL, &_8$$7, "__construct", NULL, 361, &path); + ZEPHIR_CALL_METHOD(NULL, &_8$$7, "__construct", NULL, 373, &path); zephir_check_call_status(); zephir_throw_exception_debug(&_8$$7, "phalcon/Auth/Adapter/Stream.zep", 89); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/auth/authuser.zep.c b/ext/phalcon/auth/authuser.zep.c index 153eeff3ec..4ca07aa5a6 100644 --- a/ext/phalcon/auth/authuser.zep.c +++ b/ext/phalcon/auth/authuser.zep.c @@ -93,13 +93,13 @@ PHP_METHOD(Phalcon_Auth_AuthUser, __construct) if (_0) { ZEPHIR_INIT_VAR(&_4$$3); object_init_ex(&_4$$3, phalcon_auth_exceptions_datamustcontainidkey_ce); - ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 362); + ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 374); zephir_check_call_status(); zephir_throw_exception_debug(&_4$$3, "phalcon/Auth/AuthUser.zep", 39); ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 422, &data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 431, &data); ZEPHIR_MM_RESTORE(); } @@ -118,7 +118,7 @@ PHP_METHOD(Phalcon_Auth_AuthUser, getAuthIdentifier) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 422, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 431, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&id); zephir_array_fetch_string(&id, &_0, SL("id"), PH_NOISY, "phalcon/Auth/AuthUser.zep", 50); RETURN_CCTOR(&id); @@ -141,7 +141,7 @@ PHP_METHOD(Phalcon_Auth_AuthUser, getAuthPassword) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&password); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 422, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 431, PH_NOISY_CC | PH_READONLY); zephir_array_isset_string_fetch(&password, &_0, SL("password"), 0); ZEPHIR_INIT_VAR(&_1); if (Z_TYPE_P(&password) == IS_STRING) { diff --git a/ext/phalcon/auth/exceptions/configrequiresnonemptyvalue.zep.c b/ext/phalcon/auth/exceptions/configrequiresnonemptyvalue.zep.c index f21e799510..b6b6bb38e9 100644 --- a/ext/phalcon/auth/exceptions/configrequiresnonemptyvalue.zep.c +++ b/ext/phalcon/auth/exceptions/configrequiresnonemptyvalue.zep.c @@ -125,7 +125,7 @@ PHP_METHOD(Phalcon_Auth_Exceptions_ConfigRequiresNonEmptyValue, assert) if (ZEPHIR_IS_STRING_IDENTICAL(value, "")) { ZEPHIR_INIT_VAR(&_0$$3); object_init_ex(&_0$$3, phalcon_auth_exceptions_configrequiresnonemptyvalue_ce); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 349, &configName_zv, &configKey_zv, &suffix_zv); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 361, &configName_zv, &configKey_zv, &suffix_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$3, "phalcon/Auth/Exceptions/ConfigRequiresNonEmptyValue.zep", 49); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/auth/exceptions/doesnotimplement.zep.c b/ext/phalcon/auth/exceptions/doesnotimplement.zep.c index ea6603bd7d..9c4993f289 100644 --- a/ext/phalcon/auth/exceptions/doesnotimplement.zep.c +++ b/ext/phalcon/auth/exceptions/doesnotimplement.zep.c @@ -109,7 +109,7 @@ PHP_METHOD(Phalcon_Auth_Exceptions_DoesNotImplement, assert) if (_0) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_auth_exceptions_doesnotimplement_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 348, &type_zv, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 360, &type_zv, &name_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Auth/Exceptions/DoesNotImplement.zep", 40); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/auth/guard/config/sessionguardconfig.zep.c b/ext/phalcon/auth/guard/config/sessionguardconfig.zep.c index 4994452307..e58e6e6500 100644 --- a/ext/phalcon/auth/guard/config/sessionguardconfig.zep.c +++ b/ext/phalcon/auth/guard/config/sessionguardconfig.zep.c @@ -138,15 +138,15 @@ PHP_METHOD(Phalcon_Auth_Guard_Config_SessionGuardConfig, __construct) } ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "suffix"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "validatenonempty", NULL, 363, &_0, &suffix_zv); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "validatenonempty", NULL, 375, &_0, &suffix_zv); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "name"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "validatenonempty", NULL, 363, &_0, &name_zv); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "validatenonempty", NULL, 375, &_0, &name_zv); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "rememberName"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "validatenonempty", NULL, 363, &_0, &rememberName_zv); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "validatenonempty", NULL, 375, &_0, &rememberName_zv); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_1); if (Z_TYPE_P(&name_zv) != IS_NULL) { @@ -154,20 +154,20 @@ PHP_METHOD(Phalcon_Auth_Guard_Config_SessionGuardConfig, __construct) } else { ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "auth"); - ZEPHIR_CALL_METHOD(&_1, this_ptr, "derive", NULL, 364, &_0, &suffix_zv); + ZEPHIR_CALL_METHOD(&_1, this_ptr, "derive", NULL, 376, &_0, &suffix_zv); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 423, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 432, &_1); ZEPHIR_INIT_VAR(&_2); if (Z_TYPE_P(&rememberName_zv) != IS_NULL) { ZEPHIR_CPY_WRT(&_2, &rememberName_zv); } else { ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "remember"); - ZEPHIR_CALL_METHOD(&_2, this_ptr, "derive", NULL, 364, &_0, &suffix_zv); + ZEPHIR_CALL_METHOD(&_2, this_ptr, "derive", NULL, 376, &_0, &suffix_zv); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 424, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 433, &_2); ZEPHIR_INIT_VAR(&_3); if (Z_TYPE_P(rememberTtl) != IS_NULL) { ZEPHIR_INIT_NVAR(&_3); @@ -176,13 +176,13 @@ PHP_METHOD(Phalcon_Auth_Guard_Config_SessionGuardConfig, __construct) ZEPHIR_INIT_NVAR(&_3); ZVAL_LONG(&_3, 31536000); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 425, &_3); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 423, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 424, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 434, &_3); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 432, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 433, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_IDENTICAL(&_4, &_5)) { ZEPHIR_INIT_VAR(&_6$$3); object_init_ex(&_6$$3, phalcon_auth_exceptions_sessionnamesmustdiffer_ce); - ZEPHIR_CALL_METHOD(NULL, &_6$$3, "__construct", NULL, 365); + ZEPHIR_CALL_METHOD(NULL, &_6$$3, "__construct", NULL, 377); zephir_check_call_status(); zephir_throw_exception_debug(&_6$$3, "phalcon/Auth/Guard/Config/SessionGuardConfig.zep", 68); ZEPHIR_MM_RESTORE(); @@ -285,7 +285,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Config_SessionGuardConfig, validateNonEmpty) object_init_ex(&_0$$4, phalcon_auth_exceptions_configrequiresnonemptyvalue_ce); ZEPHIR_INIT_VAR(&_1$$4); ZVAL_STRING(&_1$$4, "Session guard"); - ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 349, &_1$$4, ¶m_zv); + ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 361, &_1$$4, ¶m_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$4, "phalcon/Auth/Guard/Config/SessionGuardConfig.zep", 102); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/auth/guard/config/tokenguardconfig.zep.c b/ext/phalcon/auth/guard/config/tokenguardconfig.zep.c index 97833c05f7..e29aa9efd8 100644 --- a/ext/phalcon/auth/guard/config/tokenguardconfig.zep.c +++ b/ext/phalcon/auth/guard/config/tokenguardconfig.zep.c @@ -90,7 +90,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Config_TokenGuardConfig, __construct) ZVAL_STRING(&_1$$3, "Token guard"); ZEPHIR_INIT_VAR(&_2$$3); ZVAL_STRING(&_2$$3, "inputKey"); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 349, &_1$$3, &_2$$3); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 361, &_1$$3, &_2$$3); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$3, "phalcon/Auth/Guard/Config/TokenGuardConfig.zep", 38); ZEPHIR_MM_RESTORE(); @@ -103,14 +103,14 @@ PHP_METHOD(Phalcon_Auth_Guard_Config_TokenGuardConfig, __construct) ZVAL_STRING(&_4$$4, "Token guard"); ZEPHIR_INIT_VAR(&_5$$4); ZVAL_STRING(&_5$$4, "storageKey"); - ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", NULL, 349, &_4$$4, &_5$$4); + ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", NULL, 361, &_4$$4, &_5$$4); zephir_check_call_status(); zephir_throw_exception_debug(&_3$$4, "phalcon/Auth/Guard/Config/TokenGuardConfig.zep", 45); ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 426, &inputKey_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 427, &storageKey_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 435, &inputKey_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 436, &storageKey_zv); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/auth/guard/session.zep.c b/ext/phalcon/auth/guard/session.zep.c index ab970651a4..6d8f7e3ce7 100644 --- a/ext/phalcon/auth/guard/session.zep.c +++ b/ext/phalcon/auth/guard/session.zep.c @@ -121,20 +121,20 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, __construct) } else { ZEPHIR_SEPARATE_PARAM(clock); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 428, request); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 429, cookies); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 430, session); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 437, request); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 438, cookies); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 439, session); if (Z_TYPE_P(config) == IS_NULL) { ZEPHIR_INIT_NVAR(config); object_init_ex(config, phalcon_auth_guard_config_sessionguardconfig_ce); - ZEPHIR_CALL_METHOD(NULL, config, "__construct", NULL, 366); + ZEPHIR_CALL_METHOD(NULL, config, "__construct", NULL, 378); zephir_check_call_status(); } if (Z_TYPE_P(clock) == IS_NULL) { ZEPHIR_CALL_CE_STATIC(clock, phalcon_time_clock_systemclock_ce, "fromutc", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 431, clock); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 440, clock); ZEPHIR_CALL_PARENT(NULL, phalcon_auth_guard_session_ce, getThis(), "__construct", NULL, 0, adapter, config); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -193,7 +193,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, fromOptions) ZEPHIR_INIT_NVAR(&_4); ZVAL_NULL(&_4); } - ZEPHIR_CALL_METHOD(NULL, &config, "__construct", NULL, 366, &_0, &_2, &_3, &_4); + ZEPHIR_CALL_METHOD(NULL, &config, "__construct", NULL, 378, &_0, &_2, &_3, &_4); zephir_check_call_status(); object_init_ex(return_value, zend_get_called_scope(execute_data)); ZEPHIR_INIT_NVAR(&_1); @@ -226,7 +226,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, fromOptions) ZVAL_STRING(&_8, "Session guard"); ZEPHIR_CALL_CE_STATIC(&_10, phalcon_auth_internal_containerresolver_ce, "resolvecandidate", NULL, 0, container, &options, &_1, &_6, &_7, &_8); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 367, adapter, &_5, &_9, &_10, &config); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 379, adapter, &_5, &_9, &_10, &config); zephir_check_call_status(); RETURN_MM(); } @@ -277,7 +277,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, attempt) if (!zephir_is_true(&_0)) { RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 432, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 441, PH_NOISY_CC | PH_READONLY); if (remember) { ZVAL_BOOL(&_2, 1); } else { @@ -354,7 +354,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, getName) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 433, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 442, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getname", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -375,7 +375,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, getRememberName) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 433, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 442, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getremembername", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -430,7 +430,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, login) ZVAL_BOOL(&_2, 0); ZEPHIR_CALL_METHOD(NULL, this_ptr, "firemanagerevent", NULL, 0, &_0, &_1, &_2); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 430, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 439, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_3, this_ptr, "getname", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_4, user, "getauthidentifier", NULL, 0); @@ -438,7 +438,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, login) ZEPHIR_CALL_METHOD(NULL, &_1, "set", NULL, 0, &_3, &_4); zephir_check_call_status(); if (remember) { - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 434, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 443, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_6$$3); ZVAL_STRING(&_6$$3, "Phalcon\\Contracts\\Auth\\Adapter\\RememberAdapter"); ZEPHIR_INIT_VAR(&_7$$3); @@ -501,7 +501,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, loginById) ZEPHIR_THROW_EXCEPTION_DEBUG_STR(zend_ce_type_error, "The parameter must be 'int' or 'string'", "phalcon/Auth/Guard/Session.zep", 203); return; } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 434, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 443, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&resolved, &_1, "retrievebyid", NULL, 0, id); zephir_check_call_status(); if (Z_TYPE_P(&resolved) == IS_NULL) { @@ -574,7 +574,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, logout) _3 = zephir_instance_of_ev(¤t, phalcon_contracts_auth_authremember_ce); } if (_3) { - ZEPHIR_CALL_METHOD(&token, &recaller, "gettoken", NULL, 368); + ZEPHIR_CALL_METHOD(&token, &recaller, "gettoken", NULL, 380); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&tokenRow, ¤t, "getremembertoken", NULL, 0, &token); zephir_check_call_status(); @@ -582,20 +582,20 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, logout) ZEPHIR_CALL_METHOD(NULL, &tokenRow, "delete", NULL, 0); zephir_check_call_status(); } - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 429, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 438, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_6$$3, this_ptr, "getremembername", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_5$$3, &_4$$3, "has", NULL, 0, &_6$$3); zephir_check_call_status(); if (zephir_is_true(&_5$$3)) { - zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_0, 429, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_0, 438, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_8$$5, this_ptr, "getremembername", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_7$$5, "delete", NULL, 0, &_8$$5); zephir_check_call_status(); } } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 430, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 439, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_9, this_ptr, "getname", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_2, "remove", NULL, 0, &_9); @@ -608,7 +608,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, logout) ZVAL_BOOL(&_11, 0); ZEPHIR_CALL_METHOD(NULL, this_ptr, "firemanagerevent", NULL, 0, &_1, &_10, &_11); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 435, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 444, &__$null); ZEPHIR_MM_RESTORE(); } @@ -659,7 +659,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, once) ZEPHIR_CALL_METHOD(&_3, this_ptr, "validate", NULL, 0, &credentials); zephir_check_call_status(); if (zephir_is_true(&_3)) { - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 432, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 441, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, this_ptr, "setuser", NULL, 0, &_4$$3); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_5$$3); @@ -731,7 +731,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, onceBasic) ZEPHIR_CALL_METHOD(&_0, this_ptr, "once", NULL, 0, &_1); zephir_check_call_status(); if (zephir_is_true(&_0)) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 435, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 444, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&user, &_2$$4); RETURN_CCTOR(&user); } @@ -773,11 +773,11 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, user) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 435, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 444, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { RETURN_MM_MEMBER(getThis(), "user"); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 430, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 439, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, this_ptr, "getname", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&id, &_1, "get", NULL, 0, &_2); @@ -787,14 +787,14 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, user) _3 = Z_TYPE_P(&id) == IS_STRING; } if (_3) { - zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_2, 434, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_2, 443, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5$$4, &_4$$4, "retrievebyid", NULL, 0, &id); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 435, &_5$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 444, &_5$$4); } ZEPHIR_CALL_METHOD(&recaller, this_ptr, "recaller", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 435, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 444, PH_NOISY_CC | PH_READONLY); _7 = Z_TYPE_P(&_6) == IS_NULL; if (_7) { _7 = Z_TYPE_P(&recaller) != IS_NULL; @@ -803,8 +803,8 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, user) ZEPHIR_CALL_METHOD(&fromRecaller, this_ptr, "userfromrecaller", NULL, 0, &recaller); zephir_check_call_status(); if (Z_TYPE_P(&fromRecaller) != IS_NULL) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 435, &fromRecaller); - zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_1, 430, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 444, &fromRecaller); + zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_1, 439, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_9$$6, this_ptr, "getname", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_10$$6, &fromRecaller, "getauthidentifier", NULL, 0); @@ -854,10 +854,10 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, validate) } else { zephir_get_arrval(&credentials, credentials_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 434, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 443, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&resolved, &_0, "retrievebycredentials", NULL, 0, &credentials); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 432, &resolved); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 441, &resolved); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "hasvalidcredentials", NULL, 0, &resolved, &credentials); zephir_check_call_status(); RETURN_MM(); @@ -944,7 +944,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, basicCredentials) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&field_zv); ZVAL_STR_COPY(&field_zv, field); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 428, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 437, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&basic, &_0, "getbasicauth", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(&basic) == IS_NULL) { @@ -981,7 +981,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, createRememberToken) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &user); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 434, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 443, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&adapter, &_0); ZEPHIR_RETURN_CALL_METHOD(&adapter, "createremembertoken", NULL, 0, user); zephir_check_call_status(); @@ -1009,7 +1009,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, recaller) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 429, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 438, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, this_ptr, "getremembername", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_1, &_0, "has", NULL, 0, &_2); @@ -1017,7 +1017,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, recaller) if (!zephir_is_true(&_1)) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 429, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 438, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5, this_ptr, "getremembername", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_4, &_3, "get", NULL, 0, &_5); @@ -1029,7 +1029,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, recaller) } if (Z_TYPE_P(&raw) == IS_STRING) { object_init_ex(return_value, phalcon_auth_guard_userremember_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 369, &raw); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 381, &raw); zephir_check_call_status(); RETURN_MM(); } @@ -1037,7 +1037,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, recaller) RETURN_MM_NULL(); } object_init_ex(return_value, phalcon_auth_guard_userremember_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 369, &raw); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 381, &raw); zephir_check_call_status(); RETURN_MM(); } @@ -1093,7 +1093,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, rememberUser) zephir_fetch_params(1, 1, 0, &user); ZEPHIR_CALL_METHOD(&token, this_ptr, "createremembertoken", NULL, 0, user); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 428, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 437, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "getuseragent", NULL, 0); zephir_check_call_status(); zephir_cast_to_string(&_2, &_1); @@ -1117,15 +1117,15 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, rememberUser) ZVAL_LONG(&_6, 4194304); ZEPHIR_CALL_METHOD(&payload, &_3, "__invoke", NULL, 25, &_4, &_6); zephir_check_call_status(); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 429, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 438, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5, this_ptr, "getremembername", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 431, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 440, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_8, &_7, "now", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_9, &_8, "gettimestamp", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_3, 433, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_3, 442, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_11, &_10, "getrememberttl", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_12); @@ -1167,26 +1167,26 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, userFromRecaller) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &recaller); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 434, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 443, PH_NOISY_CC); if (!(zephir_instance_of_ev(&_0, phalcon_contracts_auth_adapter_rememberadapter_ce))) { RETURN_MM_NULL(); } - ZEPHIR_CALL_METHOD(&id, recaller, "getid", NULL, 370); + ZEPHIR_CALL_METHOD(&id, recaller, "getid", NULL, 382); zephir_check_call_status(); if (Z_TYPE_P(&id) == IS_NULL) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 434, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(&_2, recaller, "gettoken", NULL, 368); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 443, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(&_2, recaller, "gettoken", NULL, 380); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_3, recaller, "getuseragent", NULL, 371); + ZEPHIR_CALL_METHOD(&_3, recaller, "getuseragent", NULL, 383); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&resolved, &_1, "retrievebytoken", NULL, 0, &id, &_2, &_3); zephir_check_call_status(); if (Z_TYPE_P(&resolved) != IS_NULL) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 436, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 445, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 436, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 445, &__$false); } RETURN_CCTOR(&resolved); } diff --git a/ext/phalcon/auth/guard/token.zep.c b/ext/phalcon/auth/guard/token.zep.c index 3530d39f7d..a985723ba8 100644 --- a/ext/phalcon/auth/guard/token.zep.c +++ b/ext/phalcon/auth/guard/token.zep.c @@ -70,7 +70,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Token, __construct) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 3, 0, &adapter, &request, &config); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 437, request); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 446, request); ZEPHIR_CALL_PARENT(NULL, phalcon_auth_guard_token_ce, getThis(), "__construct", NULL, 0, adapter, config); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -127,9 +127,9 @@ PHP_METHOD(Phalcon_Auth_Guard_Token, fromOptions) ZVAL_STRING(&_3, "token guard"); ZEPHIR_CALL_CE_STATIC(&_6, phalcon_auth_internal_options_ce, "requirestring", NULL, 0, &options, &_2, &_3); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 372, &_5, &_6); + ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 384, &_5, &_6); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 373, adapter, &_0, &_1); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 385, adapter, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -168,8 +168,8 @@ PHP_METHOD(Phalcon_Auth_Guard_Token, getTokenForRequest) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 437, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 438, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 446, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 447, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "getinputkey", NULL, 0); zephir_check_call_status(); ZVAL_NULL(&_3); @@ -183,7 +183,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Token, getTokenForRequest) if (_5) { RETURN_CCTOR(&token); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 437, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 446, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_7); ZVAL_STRING(&_7, "Authorization"); ZEPHIR_CALL_METHOD(&_6, &_3, "getheader", NULL, 0, &_7); @@ -198,7 +198,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Token, getTokenForRequest) ZVAL_LONG(&_10$$4, 7); ZEPHIR_INIT_VAR(&_11$$4); ZVAL_STRING(&_11$$4, "UTF-8"); - ZEPHIR_CALL_FUNCTION(&bearer, "mb_substr", NULL, 290, &header, &_10$$4, &__$null, &_11$$4); + ZEPHIR_CALL_FUNCTION(&bearer, "mb_substr", NULL, 296, &header, &_10$$4, &__$null, &_11$$4); zephir_check_call_status(); if (!ZEPHIR_IS_STRING_IDENTICAL(&bearer, "")) { RETURN_CCTOR(&bearer); @@ -222,7 +222,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Token, setRequest) Z_PARAM_OBJECT_OF_CLASS(request, phalcon_http_requestinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &request); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 437, request); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 446, request); RETURN_THISW(); } @@ -256,7 +256,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Token, user) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 439, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 448, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { RETURN_MM_MEMBER(getThis(), "user"); } @@ -265,17 +265,17 @@ PHP_METHOD(Phalcon_Auth_Guard_Token, user) if (Z_TYPE_P(&token) == IS_NULL) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 440, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 449, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); zephir_create_array(&_2, 1, 0); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 438, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 447, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_4, &_3, "getstoragekey", NULL, 0); zephir_check_call_status(); zephir_array_update_zval(&_2, &_4, &token, PH_COPY); ZEPHIR_CALL_METHOD(&found, &_1, "retrievebycredentials", NULL, 0, &_2); zephir_check_call_status(); if (Z_TYPE_P(&found) != IS_NULL) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 439, &found); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 448, &found); } RETURN_MM_MEMBER(getThis(), "user"); } @@ -322,7 +322,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Token, validate) } else { zephir_get_arrval(&credentials, credentials_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 438, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 447, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&inputKey, &_0, "getinputkey", NULL, 0); zephir_check_call_status(); if (!(zephir_array_isset_value(&credentials, &inputKey))) { @@ -330,10 +330,10 @@ PHP_METHOD(Phalcon_Auth_Guard_Token, validate) } zephir_memory_observe(&token); zephir_array_fetch(&token, &credentials, &inputKey, PH_NOISY, "phalcon/Auth/Guard/Token.zep", 134); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 440, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 449, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_3); zephir_create_array(&_3, 1, 0); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 438, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 447, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5, &_4, "getstoragekey", NULL, 0); zephir_check_call_status(); zephir_array_update_zval(&_3, &_5, &token, PH_COPY); diff --git a/ext/phalcon/auth/guard/userremember.zep.c b/ext/phalcon/auth/guard/userremember.zep.c index 5a5d21f410..05728b7231 100644 --- a/ext/phalcon/auth/guard/userremember.zep.c +++ b/ext/phalcon/auth/guard/userremember.zep.c @@ -125,7 +125,7 @@ PHP_METHOD(Phalcon_Auth_Guard_UserRemember, __construct) } ZVAL_BOOL(&_2$$4, 1); - ZEPHIR_CALL_METHOD(&data, &_1$$4, "__invoke", NULL, 359, payload, &_2$$4); + ZEPHIR_CALL_METHOD(&data, &_1$$4, "__invoke", NULL, 371, payload, &_2$$4); zephir_check_call_status_or_jump(try_end_1); } else { ZEPHIR_CPY_WRT(&data, payload); @@ -167,7 +167,7 @@ PHP_METHOD(Phalcon_Auth_Guard_UserRemember, __construct) ZEPHIR_INIT_NVAR(&_5); ZVAL_NULL(&_5); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 441, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 450, &_5); ZEPHIR_INIT_VAR(&_7); if (zephir_array_isset_value_string(&data, SL("token"))) { zephir_memory_observe(&_8); @@ -178,7 +178,7 @@ PHP_METHOD(Phalcon_Auth_Guard_UserRemember, __construct) ZEPHIR_INIT_NVAR(&_7); ZVAL_STRING(&_7, ""); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 442, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 451, &_7); ZEPHIR_INIT_VAR(&_10); if (zephir_array_isset_value_string(&data, SL("user_agent"))) { zephir_memory_observe(&_11); @@ -189,7 +189,7 @@ PHP_METHOD(Phalcon_Auth_Guard_UserRemember, __construct) ZEPHIR_INIT_NVAR(&_10); ZVAL_STRING(&_10, ""); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 443, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 452, &_10); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/auth/internal/containerresolver.zep.c b/ext/phalcon/auth/internal/containerresolver.zep.c index dd4c1307c2..143241ab66 100644 --- a/ext/phalcon/auth/internal/containerresolver.zep.c +++ b/ext/phalcon/auth/internal/containerresolver.zep.c @@ -234,7 +234,7 @@ PHP_METHOD(Phalcon_Auth_Internal_ContainerResolver, requireService) ZEPHIR_CALL_METHOD(&_1$$3, container, "has", NULL, 0, &name); zephir_check_call_status(); if (zephir_is_true(&_1$$3)) { - ZEPHIR_RETURN_CALL_SELF("resolveshared", &_2, 374, container, &name); + ZEPHIR_RETURN_CALL_SELF("resolveshared", &_2, 386, container, &name); zephir_check_call_status(); RETURN_MM(); } @@ -260,7 +260,7 @@ PHP_METHOD(Phalcon_Auth_Internal_ContainerResolver, requireService) ZEPHIR_CALL_METHOD(&_5$$5, container, "has", NULL, 0, &name); zephir_check_call_status(); if (zephir_is_true(&_5$$5)) { - ZEPHIR_RETURN_CALL_SELF("resolveshared", &_2, 374, container, &name); + ZEPHIR_RETURN_CALL_SELF("resolveshared", &_2, 386, container, &name); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/auth/internal/options.zep.c b/ext/phalcon/auth/internal/options.zep.c index b15c9dc4ba..0554a945f3 100644 --- a/ext/phalcon/auth/internal/options.zep.c +++ b/ext/phalcon/auth/internal/options.zep.c @@ -129,7 +129,7 @@ PHP_METHOD(Phalcon_Auth_Internal_Options, requireArray) if (_0) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_auth_exceptions_optionrequiresarray_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 375, &context_zv, &key_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 387, &context_zv, &key_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Auth/Internal/Options.zep", 59); ZEPHIR_MM_RESTORE(); @@ -179,7 +179,7 @@ PHP_METHOD(Phalcon_Auth_Internal_Options, requireString) if (_0) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_auth_exceptions_optionrequiresstring_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 376, &context_zv, &key_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 388, &context_zv, &key_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Auth/Internal/Options.zep", 77); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/auth/manager.zep.c b/ext/phalcon/auth/manager.zep.c index aa0982858d..4528e2974f 100644 --- a/ext/phalcon/auth/manager.zep.c +++ b/ext/phalcon/auth/manager.zep.c @@ -81,7 +81,7 @@ PHP_METHOD(Phalcon_Auth_Manager, __construct) Z_PARAM_OBJECT_OF_CLASS(accessFactory, phalcon_auth_access_accesslocator_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &accessFactory); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 444, accessFactory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 453, accessFactory); } /** @@ -117,22 +117,22 @@ PHP_METHOD(Phalcon_Auth_Manager, access) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&accessName_zv); ZVAL_STR_COPY(&accessName_zv, accessName); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 444, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 453, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "has", NULL, 0, &accessName_zv); zephir_check_call_status(); if (!zephir_is_true(&_1)) { ZEPHIR_INIT_VAR(&_2$$3); object_init_ex(&_2$$3, phalcon_auth_exceptions_accessnotregistered_ce); - ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 377, &accessName_zv); + ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 389, &accessName_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_2$$3, "phalcon/Auth/Manager.zep", 68); ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 444, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 453, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_4, &_3, "newinstance", NULL, 0, &accessName_zv); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 445, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 454, &_4); RETURN_THIS(); } @@ -180,7 +180,7 @@ PHP_METHOD(Phalcon_Auth_Manager, addAccessList) } ZEPHIR_INIT_NVAR(&className); ZVAL_COPY(&className, _0); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 444, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 453, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_3$$3, "register", NULL, 0, &name, &className); zephir_check_call_status(); } ZEND_HASH_FOREACH_END(); @@ -204,7 +204,7 @@ PHP_METHOD(Phalcon_Auth_Manager, addAccessList) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&className, &accessList, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_0, 444, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_0, 453, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_6$$4, "register", NULL, 0, &name, &className); zephir_check_call_status(); } @@ -245,7 +245,7 @@ PHP_METHOD(Phalcon_Auth_Manager, addGuard) } zephir_update_property_array(this_ptr, SL("guards"), &nameGuard_zv, guard); if (isDefault) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 446, guard); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 455, guard); } RETURN_THISW(); } @@ -285,7 +285,7 @@ PHP_METHOD(Phalcon_Auth_Manager, attempt) remember = 0; } else { } - ZEPHIR_CALL_METHOD(&_0, this_ptr, "requirestatefulguard", NULL, 378); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "requirestatefulguard", NULL, 390); zephir_check_call_status(); if (remember) { ZVAL_BOOL(&_1, 1); @@ -334,7 +334,7 @@ PHP_METHOD(Phalcon_Auth_Manager, except) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); ZEPHIR_INIT_VAR(&actions); zephir_get_args_from(&actions, 0); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "requireactiveaccess", NULL, 379); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "requireactiveaccess", NULL, 391); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&_1, "array_values", NULL, 27, &actions); zephir_check_call_status(); @@ -367,7 +367,7 @@ PHP_METHOD(Phalcon_Auth_Manager, getAccessList) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 444, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 453, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getall", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -429,11 +429,11 @@ PHP_METHOD(Phalcon_Auth_Manager, guard) ZVAL_STR_COPY(&name_zv, name); } if (ZEPHIR_IS_NULL(&name_zv)) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 446, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 455, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0$$3) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$4); object_init_ex(&_1$$4, phalcon_auth_exceptions_defaultguardnotregistered_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 380); + ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 392); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$4, "phalcon/Auth/Manager.zep", 162); ZEPHIR_MM_RESTORE(); @@ -441,17 +441,17 @@ PHP_METHOD(Phalcon_Auth_Manager, guard) } RETURN_MM_MEMBER(getThis(), "defaultGuard"); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 447, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 456, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_2, &name_zv))) { ZEPHIR_INIT_VAR(&_3$$5); object_init_ex(&_3$$5, phalcon_auth_exceptions_guardnotdefined_ce); - ZEPHIR_CALL_METHOD(NULL, &_3$$5, "__construct", NULL, 381, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_3$$5, "__construct", NULL, 393, &name_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_3$$5, "phalcon/Auth/Manager.zep", 169); ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 447, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 456, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_5, &_4, &name_zv, PH_NOISY | PH_READONLY, "phalcon/Auth/Manager.zep", 172); RETURN_CTOR(&_5); } @@ -485,7 +485,7 @@ PHP_METHOD(Phalcon_Auth_Manager, logout) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "requirestatefulguard", NULL, 378); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "requirestatefulguard", NULL, 390); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_0, "logout", NULL, 0); zephir_check_call_status(); @@ -511,7 +511,7 @@ PHP_METHOD(Phalcon_Auth_Manager, only) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); ZEPHIR_INIT_VAR(&actions); zephir_get_args_from(&actions, 0); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "requireactiveaccess", NULL, 379); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "requireactiveaccess", NULL, 391); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&_1, "array_values", NULL, 27, &actions); zephir_check_call_status(); @@ -535,7 +535,7 @@ PHP_METHOD(Phalcon_Auth_Manager, setAccess) Z_PARAM_OBJECT_OF_CLASS(access, phalcon_contracts_auth_access_access_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &access); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 445, access); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 454, access); RETURN_THISW(); } @@ -554,7 +554,7 @@ PHP_METHOD(Phalcon_Auth_Manager, setDefaultGuard) Z_PARAM_OBJECT_OF_CLASS(guard, phalcon_contracts_auth_guard_guard_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &guard); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 446, guard); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 455, guard); RETURN_THISW(); } @@ -628,11 +628,11 @@ PHP_METHOD(Phalcon_Auth_Manager, requireActiveAccess) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 445, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 454, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_auth_exceptions_activeaccessrequired_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 382); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 394); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Auth/Manager.zep", 228); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/auth/managerfactory.zep.c b/ext/phalcon/auth/managerfactory.zep.c index b3977e04e2..af3c6e787c 100644 --- a/ext/phalcon/auth/managerfactory.zep.c +++ b/ext/phalcon/auth/managerfactory.zep.c @@ -174,38 +174,38 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, __construct) } ZEPHIR_CALL_CE_STATIC(NULL, phalcon_auth_internal_containerresolver_ce, "ensurecontainer", NULL, 0, container); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 448, container); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 449, hasher); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 457, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 458, hasher); ZEPHIR_INIT_VAR(&_0); if (Z_TYPE_P(adapterLocator) != IS_NULL) { ZEPHIR_CPY_WRT(&_0, adapterLocator); } else { ZEPHIR_INIT_NVAR(&_0); object_init_ex(&_0, phalcon_auth_adapter_adapterlocator_ce); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 383, container); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 395, container); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 450, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 459, &_0); ZEPHIR_INIT_VAR(&_1); if (Z_TYPE_P(guardLocator) != IS_NULL) { ZEPHIR_CPY_WRT(&_1, guardLocator); } else { ZEPHIR_INIT_NVAR(&_1); object_init_ex(&_1, phalcon_auth_guard_guardlocator_ce); - ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 383, container); + ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 395, container); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 451, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 460, &_1); ZEPHIR_INIT_VAR(&_2); if (Z_TYPE_P(accessLocator) != IS_NULL) { ZEPHIR_CPY_WRT(&_2, accessLocator); } else { ZEPHIR_INIT_NVAR(&_2); object_init_ex(&_2, phalcon_auth_access_accesslocator_ce); - ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 383, container); + ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 395, container); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 452, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 461, &_2); ZEPHIR_MM_RESTORE(); } @@ -298,8 +298,8 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, load) } ZEPHIR_INIT_VAR(&manager); object_init_ex(&manager, phalcon_auth_manager_ce); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 452, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(NULL, &manager, "__construct", NULL, 384, &_3); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 461, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(NULL, &manager, "__construct", NULL, 396, &_3); zephir_check_call_status(); if (zephir_array_isset_value_string(config, SL("guards"))) { zephir_memory_observe(&guards); @@ -320,7 +320,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, load) } ZEPHIR_INIT_NVAR(&gconf); ZVAL_COPY(&gconf, _4); - zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_1, 450, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_1, 459, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_10$$5); ZEPHIR_CONCAT_SVS(&_10$$5, "guard '", &name, "'"); ZEPHIR_INIT_NVAR(&_11$$5); @@ -329,7 +329,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, load) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&adapter, this_ptr, "buildadapter", &_12, 0, &_7$$5, &_8$$5); zephir_check_call_status(); - zephir_read_property_cached(&_13$$5, this_ptr, _zephir_prop_2, 451, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$5, this_ptr, _zephir_prop_2, 460, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_16$$5); ZEPHIR_CONCAT_SVS(&_16$$5, "guard '", &name, "'"); ZEPHIR_INIT_NVAR(&_11$$5); @@ -356,7 +356,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, load) ZVAL_BOOL(&_20$$5, 0); } ZVAL_BOOL(&_21$$5, zephir_get_boolval(&_20$$5)); - ZEPHIR_CALL_METHOD(NULL, &manager, "addguard", &_22, 385, &_19$$5, &guard, &_21$$5); + ZEPHIR_CALL_METHOD(NULL, &manager, "addguard", &_22, 397, &_19$$5, &guard, &_21$$5); zephir_check_call_status(); } ZEND_HASH_FOREACH_END(); } else { @@ -379,7 +379,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, load) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&gconf, &guards, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_25$$6, this_ptr, _zephir_prop_1, 450, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$6, this_ptr, _zephir_prop_1, 459, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_27$$6); ZEPHIR_CONCAT_SVS(&_27$$6, "guard '", &name, "'"); ZEPHIR_INIT_NVAR(&_28$$6); @@ -388,7 +388,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, load) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&adapter, this_ptr, "buildadapter", &_12, 0, &_25$$6, &_26$$6); zephir_check_call_status(); - zephir_read_property_cached(&_29$$6, this_ptr, _zephir_prop_2, 451, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$6, this_ptr, _zephir_prop_2, 460, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_31$$6); ZEPHIR_CONCAT_SVS(&_31$$6, "guard '", &name, "'"); ZEPHIR_INIT_NVAR(&_28$$6); @@ -415,7 +415,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, load) ZVAL_BOOL(&_34$$6, 0); } ZVAL_BOOL(&_35$$6, zephir_get_boolval(&_34$$6)); - ZEPHIR_CALL_METHOD(NULL, &manager, "addguard", &_22, 385, &_33$$6, &guard, &_35$$6); + ZEPHIR_CALL_METHOD(NULL, &manager, "addguard", &_22, 397, &_33$$6, &guard, &_35$$6); zephir_check_call_status(); } } @@ -429,7 +429,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, load) array_init(&accessList); } if (!(ZEPHIR_IS_EMPTY(&accessList))) { - ZEPHIR_CALL_METHOD(NULL, &manager, "addaccesslist", NULL, 386, &accessList); + ZEPHIR_CALL_METHOD(NULL, &manager, "addaccesslist", NULL, 398, &accessList); zephir_check_call_status(); } RETURN_CCTOR(&manager); @@ -483,7 +483,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, buildAdapter) if (!zephir_is_true(&_2)) { ZEPHIR_INIT_VAR(&_3$$3); object_init_ex(&_3$$3, phalcon_auth_exceptions_unknownadapter_ce); - ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 387, &name); + ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 399, &name); zephir_check_call_status(); zephir_throw_exception_debug(&_3$$3, "phalcon/Auth/ManagerFactory.zep", 184); ZEPHIR_MM_RESTORE(); @@ -491,7 +491,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, buildAdapter) } ZEPHIR_CALL_METHOD(&className, locator, "getclass", NULL, 0, &name); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 449, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 458, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_5); if (zephir_array_isset_value_string(&cfg, SL("options"))) { ZEPHIR_OBS_NVAR(&_5); @@ -553,7 +553,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, buildGuard) if (!zephir_is_true(&_0)) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_auth_exceptions_unknownguard_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 388, &type_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 400, &type_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Auth/ManagerFactory.zep", 209); ZEPHIR_MM_RESTORE(); @@ -561,7 +561,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, buildGuard) } ZEPHIR_CALL_METHOD(&className, locator, "getclass", NULL, 0, &type_zv); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 448, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 457, PH_NOISY_CC | PH_READONLY); _3 = zephir_fetch_class(&className); ZEPHIR_RETURN_CALL_CE_STATIC(_3, "fromoptions", NULL, 0, adapter, &_2, &options); zephir_check_call_status(); diff --git a/ext/phalcon/auth/micro/authmicrolistener.zep.c b/ext/phalcon/auth/micro/authmicrolistener.zep.c index 3a76f16a20..1dc3e6fdd7 100644 --- a/ext/phalcon/auth/micro/authmicrolistener.zep.c +++ b/ext/phalcon/auth/micro/authmicrolistener.zep.c @@ -85,7 +85,7 @@ PHP_METHOD(Phalcon_Auth_Micro_AuthMicroListener, __construct) } ZEPHIR_CALL_PARENT(NULL, phalcon_auth_micro_authmicrolistener_ce, getThis(), "__construct", NULL, 0, manager); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 453, &componentName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 462, &componentName_zv); ZEPHIR_MM_RESTORE(); } @@ -144,7 +144,7 @@ PHP_METHOD(Phalcon_Auth_Micro_AuthMicroListener, beforeExecuteRoute) ZEPHIR_INIT_VAR(&_2); zephir_create_array(&_2, 2, 0); zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 453, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 462, PH_NOISY_CC); zephir_array_update_string(&_2, SL("handler"), &_3, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(&_4, &router, "getparams", NULL, 0); zephir_check_call_status(); diff --git a/ext/phalcon/auth/mvc/authdispatcherlistener.zep.c b/ext/phalcon/auth/mvc/authdispatcherlistener.zep.c index 70b04d07c3..ccf1030995 100644 --- a/ext/phalcon/auth/mvc/authdispatcherlistener.zep.c +++ b/ext/phalcon/auth/mvc/authdispatcherlistener.zep.c @@ -87,8 +87,8 @@ PHP_METHOD(Phalcon_Auth_Mvc_AuthDispatcherListener, beforeExecuteRoute) zephir_array_update_string(&_2, SL("params"), &_3, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_VAR(&_4); ZEPHIR_INIT_NVAR(&_4); - zephir_create_closure_ex(&_4, NULL, phalcon_5__closure_ce, SL("__invoke")); - zephir_update_static_property_ce(phalcon_5__closure_ce, ZEND_STRL("dispatcher"), dispatcher); + zephir_create_closure_ex(&_4, NULL, phalcon_7__closure_ce, SL("__invoke")); + zephir_update_static_property_ce(phalcon_7__closure_ce, ZEND_STRL("dispatcher"), dispatcher); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "enforce", NULL, 0, &_1, &_2, &_4); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/autoload/loader.zep.c b/ext/phalcon/autoload/loader.zep.c index ac6309057b..75919b426f 100644 --- a/ext/phalcon/autoload/loader.zep.c +++ b/ext/phalcon/autoload/loader.zep.c @@ -129,9 +129,9 @@ PHP_METHOD(Phalcon_Autoload_Loader, __construct) ZVAL_STRING(&_1, "php"); zephir_update_property_array(this_ptr, SL("extensions"), &_0, &_1); if (isDebug) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 454, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 463, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 454, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 463, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -294,10 +294,10 @@ PHP_METHOD(Phalcon_Autoload_Loader, addNamespace) ZEPHIR_INIT_VAR(&_1); ZEPHIR_CONCAT_VV(&_1, &_0, &nsSeparator); ZEPHIR_CPY_WRT(&nsName, &_1); - ZEPHIR_CALL_METHOD(&_2, this_ptr, "checkdirectories", NULL, 389, directories, &dirSeparator, &name_zv); + ZEPHIR_CALL_METHOD(&_2, this_ptr, "checkdirectories", NULL, 401, directories, &dirSeparator, &name_zv); zephir_check_call_status(); ZEPHIR_CPY_WRT(directories, &_2); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 455, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 464, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_3, &nsName))) { ZEPHIR_INIT_VAR(&_4$$3); array_init(&_4$$3); @@ -306,12 +306,12 @@ PHP_METHOD(Phalcon_Autoload_Loader, addNamespace) if (prepend) { ZEPHIR_CPY_WRT(&source, directories); } else { - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 455, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 464, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&source); zephir_array_fetch(&source, &_5, &nsName, PH_NOISY, "phalcon/Autoload/Loader.zep", 176); } if (prepend) { - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 455, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 464, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&target); zephir_array_fetch(&target, &_6, &nsName, PH_NOISY, "phalcon/Autoload/Loader.zep", 177); } else { @@ -319,7 +319,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, addNamespace) } ZEPHIR_INIT_VAR(&_7); zephir_fast_array_merge(&_7, &source, &target); - ZEPHIR_CALL_FUNCTION(&_2, "array_unique", NULL, 390, &_7); + ZEPHIR_CALL_FUNCTION(&_2, "array_unique", NULL, 402, &_7); zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("namespaces"), &nsName, &_2); RETURN_THIS(); @@ -379,47 +379,47 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoload) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&className_zv); ZVAL_STR_COPY(&className_zv, className); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 456, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 465, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_LONG_IDENTICAL(&_0, 0)) { ZEPHIR_INIT_VAR(&_1$$3); array_init(&_1$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 457, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 466, &_1$$3); } result = 1; - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 456, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 465, PH_NOISY_CC | PH_READONLY); ZVAL_UNDEF(&_3); ZVAL_LONG(&_3, (zephir_get_numberval(&_2) + 1)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 456, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 465, &_3); ZEPHIR_INIT_VAR(&_4); ZEPHIR_CONCAT_SV(&_4, "Loading: ", &className_zv); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 391, &_4); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 403, &_4); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_5); ZVAL_STRING(&_5, "loader:beforeCheckClass"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "firemanagerevent", NULL, 0, &_5, &className_zv); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_6, this_ptr, "autoloadcheckclasses", NULL, 392, &className_zv); + ZEPHIR_CALL_METHOD(&_6, this_ptr, "autoloadcheckclasses", NULL, 404, &className_zv); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_6)) { ZEPHIR_INIT_VAR(&_7$$4); ZEPHIR_CONCAT_SV(&_7$$4, "Class: 404: ", &className_zv); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 391, &_7$$4); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 403, &_7$$4); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_8$$4, this_ptr, "autoloadchecknamespaces", NULL, 393, &className_zv); + ZEPHIR_CALL_METHOD(&_8$$4, this_ptr, "autoloadchecknamespaces", NULL, 405, &className_zv); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_8$$4)) { ZEPHIR_INIT_VAR(&_9$$5); ZEPHIR_CONCAT_SV(&_9$$5, "Namespace: 404: ", &className_zv); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 391, &_9$$5); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 403, &_9$$5); zephir_check_call_status(); - zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_2, 458, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_2, 467, PH_NOISY_CC | PH_READONLY); ZVAL_BOOL(&_12$$5, 1); - ZEPHIR_CALL_METHOD(&_10$$5, this_ptr, "autoloadcheckdirectories", NULL, 394, &_11$$5, &className_zv, &_12$$5); + ZEPHIR_CALL_METHOD(&_10$$5, this_ptr, "autoloadcheckdirectories", NULL, 406, &_11$$5, &className_zv, &_12$$5); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_10$$5)) { ZEPHIR_INIT_VAR(&_13$$6); ZEPHIR_CONCAT_SV(&_13$$6, "Directories: 404: ", &className_zv); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 391, &_13$$6); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 403, &_13$$6); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_14$$6); ZVAL_STRING(&_14$$6, "loader:afterCheckClass"); @@ -429,10 +429,10 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoload) } } } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 456, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 465, PH_NOISY_CC | PH_READONLY); ZVAL_UNDEF(&_15); ZVAL_LONG(&_15, (zephir_get_numberval(&_3) - 1)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 456, &_15); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 465, &_15); RETURN_MM_BOOL(result); } @@ -549,7 +549,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, loadFiles) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 459, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 468, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&files, &_0); zephir_is_iterable(&files, 0, "phalcon/Autoload/Loader.zep", 336); if (Z_TYPE_P(&files) == IS_ARRAY) { @@ -628,7 +628,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, register) prepend = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 460, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 469, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "loadfiles", NULL, 0); zephir_check_call_status(); @@ -639,12 +639,12 @@ PHP_METHOD(Phalcon_Autoload_Loader, register) ZVAL_STRING(&_2$$3, "autoload"); zephir_array_fast_append(&_1$$3, &_2$$3); ZVAL_BOOL(&_3$$3, (prepend ? 1 : 0)); - ZEPHIR_CALL_FUNCTION(NULL, "spl_autoload_register", NULL, 395, &_1$$3, &__$true, &_3$$3); + ZEPHIR_CALL_FUNCTION(NULL, "spl_autoload_register", NULL, 407, &_1$$3, &__$true, &_3$$3); zephir_check_call_status(); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 460, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 469, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 460, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 469, &__$false); } } RETURN_THIS(); @@ -696,7 +696,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, setClasses) if (!merge) { ZEPHIR_INIT_VAR(&_0$$3); array_init(&_0$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 461, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 470, &_0$$3); } zephir_is_iterable(&classes, 0, "phalcon/Autoload/Loader.zep", 378); if (Z_TYPE_P(&classes) == IS_ARRAY) { @@ -785,7 +785,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, setDirectories) } else { ZVAL_BOOL(&_2, 0); } - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addtocollection", NULL, 396, &directories, &_0, &_1, &_2); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addtocollection", NULL, 408, &directories, &_0, &_1, &_2); zephir_check_call_status(); RETURN_MM(); } @@ -836,7 +836,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, setExtensions) if (!merge) { ZEPHIR_INIT_VAR(&_0$$3); array_init(&_0$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 462, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 471, &_0$$3); ZEPHIR_INIT_VAR(&_1$$3); ZVAL_STRING(&_1$$3, "php"); ZEPHIR_INIT_VAR(&_2$$3); @@ -927,16 +927,16 @@ PHP_METHOD(Phalcon_Autoload_Loader, setFileCheckingCallback) method = &__$null; } if (1 == zephir_is_callable(method)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 463, method); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 472, method); } else if (Z_TYPE_P(method) == IS_NULL) { ZEPHIR_INIT_VAR(&_0$$4); ZEPHIR_INIT_NVAR(&_0$$4); - zephir_create_closure_ex(&_0$$4, NULL, phalcon_6__closure_ce, SL("__invoke")); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 463, &_0$$4); + zephir_create_closure_ex(&_0$$4, NULL, phalcon_8__closure_ce, SL("__invoke")); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 472, &_0$$4); } else { ZEPHIR_INIT_VAR(&_1$$5); object_init_ex(&_1$$5, phalcon_autoload_exceptions_loadermethodnotcallable_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$5, "__construct", NULL, 397); + ZEPHIR_CALL_METHOD(NULL, &_1$$5, "__construct", NULL, 409); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$5, "phalcon/Autoload/Loader.zep", 453); ZEPHIR_MM_RESTORE(); @@ -989,7 +989,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, setFiles) } else { ZVAL_BOOL(&_2, 0); } - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addtocollection", NULL, 396, &files, &_0, &_1, &_2); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addtocollection", NULL, 408, &files, &_0, &_1, &_2); zephir_check_call_status(); RETURN_MM(); } @@ -1040,7 +1040,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, setNamespaces) if (!merge) { ZEPHIR_INIT_VAR(&_0$$3); array_init(&_0$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 455, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 464, &_0$$3); } zephir_is_iterable(&namespaces, 0, "phalcon/Autoload/Loader.zep", 498); if (Z_TYPE_P(&namespaces) == IS_ARRAY) { @@ -1122,7 +1122,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, unregister) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 460, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 469, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { ZEPHIR_INIT_VAR(&_1$$3); zephir_create_array(&_1$$3, 2, 0); @@ -1130,12 +1130,12 @@ PHP_METHOD(Phalcon_Autoload_Loader, unregister) ZEPHIR_INIT_VAR(&_2$$3); ZVAL_STRING(&_2$$3, "autoload"); zephir_array_fast_append(&_1$$3, &_2$$3); - ZEPHIR_CALL_FUNCTION(NULL, "spl_autoload_unregister", NULL, 398, &_1$$3); + ZEPHIR_CALL_FUNCTION(NULL, "spl_autoload_unregister", NULL, 410, &_1$$3); zephir_check_call_status(); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 460, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 469, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 460, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 469, &__$false); } } RETURN_THIS(); @@ -1179,18 +1179,18 @@ PHP_METHOD(Phalcon_Autoload_Loader, requireFile) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&file_zv); ZVAL_STR_COPY(&file_zv, file); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 463, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 472, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_1, "call_user_func", NULL, 80, &_0, &file_zv); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&_1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 464, &file_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 473, &file_zv); ZEPHIR_INIT_VAR(&_2$$3); ZVAL_STRING(&_2$$3, "loader:pathFound"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "firemanagerevent", NULL, 0, &_2$$3, &file_zv); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_3$$3); ZEPHIR_CONCAT_SV(&_3$$3, "Require: ", &file_zv); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 391, &_3$$3); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 403, &_3$$3); zephir_check_call_status(); if (zephir_require_once_zval(&file_zv) == FAILURE) { RETURN_MM_NULL(); @@ -1199,7 +1199,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, requireFile) } ZEPHIR_INIT_VAR(&_4); ZEPHIR_CONCAT_SV(&_4, "Require: 404: ", &file_zv); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 391, &_4); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 403, &_4); zephir_check_call_status(); RETURN_MM_BOOL(0); } @@ -1226,7 +1226,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, addDebug) Z_PARAM_STR(message) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&message_zv, message); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 454, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 463, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { zephir_update_property_array_append(this_ptr, SL("debug"), &message_zv); } @@ -1356,9 +1356,9 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckClasses) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&className_zv); ZVAL_STR_COPY(&className_zv, className); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 461, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 470, PH_NOISY_CC | PH_READONLY); if (1 == zephir_array_isset_value(&_0, &className_zv)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 461, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 470, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&filePath); zephir_array_fetch(&filePath, &_1$$3, &className_zv, PH_NOISY, "phalcon/Autoload/Loader.zep", 621); ZEPHIR_INIT_VAR(&_2$$3); @@ -1370,7 +1370,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckClasses) if (ZEPHIR_IS_TRUE_IDENTICAL(&_3$$3)) { ZEPHIR_INIT_VAR(&_4$$4); ZEPHIR_CONCAT_SV(&_4$$4, "Class: load: ", &filePath); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 391, &_4$$4); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 403, &_4$$4); zephir_check_call_status(); RETURN_MM_BOOL(1); } @@ -1461,7 +1461,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckDirectories) ZVAL_STRING(&nsSeparator, "\\"); ZEPHIR_INIT_VAR(&localClassName); zephir_fast_str_replace(&localClassName, &nsSeparator, &dirSeparator, &className_zv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 462, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 471, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extensions, &_0); zephir_is_iterable(&directories, 0, "phalcon/Autoload/Loader.zep", 682); if (Z_TYPE_P(&directories) == IS_ARRAY) { @@ -1481,7 +1481,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckDirectories) ZVAL_COPY(&extension, _3$$3); ZEPHIR_INIT_NVAR(&filePath); ZEPHIR_CONCAT_VVSV(&filePath, &fixedDirectory, &localClassName, ".", &extension); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 465, &filePath); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 474, &filePath); ZEPHIR_INIT_NVAR(&_4$$4); ZVAL_STRING(&_4$$4, "loader:beforeCheckPath"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "firemanagerevent", &_5, 0, &_4$$4, &filePath); @@ -1492,7 +1492,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckDirectories) if (isDirectory) { ZEPHIR_INIT_NVAR(&_8$$6); ZEPHIR_CONCAT_SV(&_8$$6, "Directories: ", &filePath); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 391, &_8$$6); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 403, &_8$$6); zephir_check_call_status(); } RETURN_MM_BOOL(1); @@ -1518,7 +1518,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckDirectories) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&filePath); ZEPHIR_CONCAT_VVSV(&filePath, &fixedDirectory, &localClassName, ".", &extension); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 465, &filePath); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 474, &filePath); ZEPHIR_INIT_NVAR(&_12$$7); ZVAL_STRING(&_12$$7, "loader:beforeCheckPath"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "firemanagerevent", &_5, 0, &_12$$7, &filePath); @@ -1529,7 +1529,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckDirectories) if (isDirectory) { ZEPHIR_INIT_NVAR(&_14$$9); ZEPHIR_CONCAT_SV(&_14$$9, "Directories: ", &filePath); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 391, &_14$$9); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 403, &_14$$9); zephir_check_call_status(); } RETURN_MM_BOOL(1); @@ -1568,7 +1568,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckDirectories) ZVAL_COPY(&extension, _18$$10); ZEPHIR_INIT_NVAR(&filePath); ZEPHIR_CONCAT_VVSV(&filePath, &fixedDirectory, &localClassName, ".", &extension); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 465, &filePath); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 474, &filePath); ZEPHIR_INIT_NVAR(&_19$$11); ZVAL_STRING(&_19$$11, "loader:beforeCheckPath"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "firemanagerevent", &_5, 0, &_19$$11, &filePath); @@ -1579,7 +1579,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckDirectories) if (isDirectory) { ZEPHIR_INIT_NVAR(&_21$$13); ZEPHIR_CONCAT_SV(&_21$$13, "Directories: ", &filePath); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 391, &_21$$13); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 403, &_21$$13); zephir_check_call_status(); } RETURN_MM_BOOL(1); @@ -1605,7 +1605,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckDirectories) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&filePath); ZEPHIR_CONCAT_VVSV(&filePath, &fixedDirectory, &localClassName, ".", &extension); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 465, &filePath); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 474, &filePath); ZEPHIR_INIT_NVAR(&_24$$14); ZVAL_STRING(&_24$$14, "loader:beforeCheckPath"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "firemanagerevent", &_5, 0, &_24$$14, &filePath); @@ -1616,7 +1616,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckDirectories) if (isDirectory) { ZEPHIR_INIT_NVAR(&_26$$16); ZEPHIR_CONCAT_SV(&_26$$16, "Directories: ", &filePath); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 391, &_26$$16); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 403, &_26$$16); zephir_check_call_status(); } RETURN_MM_BOOL(1); @@ -1680,7 +1680,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckNamespaces) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&className_zv); ZVAL_STR_COPY(&className_zv, className); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 455, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 464, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&namespaces, &_0); zephir_is_iterable(&namespaces, 0, "phalcon/Autoload/Loader.zep", 712); if (Z_TYPE_P(&namespaces) == IS_ARRAY) { @@ -1700,13 +1700,13 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckNamespaces) ZVAL_LONG(&_4$$3, zephir_fast_strlen_ev(&prefix)); ZEPHIR_INIT_NVAR(&fileName); zephir_substr(&fileName, &className_zv, zephir_get_intval(&_4$$3), 0, ZEPHIR_SUBSTR_NO_LENGTH); - ZEPHIR_CALL_METHOD(&_5$$3, this_ptr, "autoloadcheckdirectories", &_6, 394, &directories, &fileName); + ZEPHIR_CALL_METHOD(&_5$$3, this_ptr, "autoloadcheckdirectories", &_6, 406, &directories, &fileName); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_5$$3)) { - zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_1, 465, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_1, 474, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_8$$5); ZEPHIR_CONCAT_SVSV(&_8$$5, "Namespace: ", &prefix, " - ", &_7$$5); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 391, &_8$$5); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 403, &_8$$5); zephir_check_call_status(); RETURN_MM_BOOL(1); } @@ -1737,13 +1737,13 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckNamespaces) ZVAL_LONG(&_12$$6, zephir_fast_strlen_ev(&prefix)); ZEPHIR_INIT_NVAR(&fileName); zephir_substr(&fileName, &className_zv, zephir_get_intval(&_12$$6), 0, ZEPHIR_SUBSTR_NO_LENGTH); - ZEPHIR_CALL_METHOD(&_13$$6, this_ptr, "autoloadcheckdirectories", &_6, 394, &directories, &fileName); + ZEPHIR_CALL_METHOD(&_13$$6, this_ptr, "autoloadcheckdirectories", &_6, 406, &directories, &fileName); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_13$$6)) { - zephir_read_property_cached(&_14$$8, this_ptr, _zephir_prop_1, 465, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$8, this_ptr, _zephir_prop_1, 474, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_15$$8); ZEPHIR_CONCAT_SVSV(&_15$$8, "Namespace: ", &prefix, " - ", &_14$$8); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 391, &_15$$8); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 403, &_15$$8); zephir_check_call_status(); RETURN_MM_BOOL(1); } @@ -1815,7 +1815,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, checkDirectories) if (_0) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_autoload_exceptions_loaderdirectoriesnotarray_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 399, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 411, &name_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Autoload/Loader.zep", 737); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/cache/abstractcache.zep.c b/ext/phalcon/cache/abstractcache.zep.c index b62e6b15b1..d4ac7ea28b 100644 --- a/ext/phalcon/cache/abstractcache.zep.c +++ b/ext/phalcon/cache/abstractcache.zep.c @@ -82,7 +82,7 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, __construct) Z_PARAM_OBJECT_OF_CLASS(adapter, phalcon_cache_adapter_adapterinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &adapter); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 259, adapter); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 260, adapter); } /** @@ -140,7 +140,7 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, setEventsManager) Z_PARAM_OBJECT_OF_CLASS(eventsManager, phalcon_events_managerinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &eventsManager); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 260, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 261, eventsManager); } /** @@ -299,7 +299,7 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doClear) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 259, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 260, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "clear", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -346,7 +346,7 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doDelete) ZVAL_STRING(&_0, "cache:beforeDelete"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "fire", NULL, 0, &_0, &key_zv); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 259, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 260, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&result, &_1, "delete", NULL, 0, &key_zv); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_0); @@ -428,7 +428,7 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doDeleteMultiple) } } ZEPHIR_INIT_NVAR(&key); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 259, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 260, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&result, &_5, "deletemultiple", NULL, 0, &keysArray); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_0); @@ -492,7 +492,7 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doGet) ZVAL_STRING(&_0, "cache:beforeGet"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "fire", NULL, 0, &_0, &key_zv); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 259, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 260, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&result, &_1, "get", NULL, 0, &key_zv, defaultValue); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_0); @@ -559,7 +559,7 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doGetMultiple) ZEPHIR_INIT_VAR(&results); array_init(&results); zephir_memory_observe(&adapterClass); - zephir_read_property_cached(&adapterClass, this_ptr, _zephir_prop_0, 259, PH_NOISY_CC); + zephir_read_property_cached(&adapterClass, this_ptr, _zephir_prop_0, 260, PH_NOISY_CC); if (zephir_instance_of_ev(&adapterClass, phalcon_cache_adapter_redis_ce)) { ZEPHIR_INIT_VAR(&keysArray); array_init(&keysArray); @@ -597,10 +597,10 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doGetMultiple) } } ZEPHIR_INIT_NVAR(&element); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 259, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 260, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&serializer, &_5$$3, "getserializer", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 259, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 260, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_7$$3, &_6$$3, "getadapter", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&results, &_7$$3, "mget", NULL, 0, &keysArray); @@ -613,7 +613,7 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doGetMultiple) ZEPHIR_CALL_FUNCTION(&_9$$3, "array_map", NULL, 19, &_8$$3, &results); zephir_check_call_status(); ZEPHIR_CPY_WRT(&results, &_9$$3); - ZEPHIR_CALL_FUNCTION(&_9$$3, "array_combine", NULL, 238, &keysArray, &results); + ZEPHIR_CALL_FUNCTION(&_9$$3, "array_combine", NULL, 244, &keysArray, &results); zephir_check_call_status(); ZEPHIR_CPY_WRT(&results, &_9$$3); } else { @@ -699,7 +699,7 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doHas) ZVAL_STRING(&_0, "cache:beforeHas"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "fire", NULL, 0, &_0, &key_zv); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 259, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 260, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&result, &_1, "has", NULL, 0, &key_zv); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_0); @@ -772,7 +772,7 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doSet) ZVAL_STRING(&_0, "cache:beforeSet"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "fire", NULL, 0, &_0, &key_zv); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 259, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 260, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&result, &_1, "set", NULL, 0, &key_zv, value, ttl); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_0); @@ -924,11 +924,11 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, fire) keys = ZEND_CALL_ARG(execute_data, 2); zephir_memory_observe(&eventName_zv); ZVAL_STR_COPY(&eventName_zv, eventName); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 260, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 261, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 260, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 261, PH_NOISY_CC | PH_READONLY); ZVAL_BOOL(&_2, 0); ZEPHIR_CALL_METHOD(NULL, &_1, "fire", NULL, 0, &eventName_zv, this_ptr, keys, &_2); zephir_check_call_status(); diff --git a/ext/phalcon/cache/adapterfactory.zep.c b/ext/phalcon/cache/adapterfactory.zep.c index 897c90958a..4553c6d917 100644 --- a/ext/phalcon/cache/adapterfactory.zep.c +++ b/ext/phalcon/cache/adapterfactory.zep.c @@ -76,7 +76,7 @@ PHP_METHOD(Phalcon_Cache_AdapterFactory, __construct) } else { zephir_get_arrval(&services, services_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 466, factory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 475, factory); ZEPHIR_CALL_METHOD(NULL, this_ptr, "init", NULL, 0, &services); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -152,7 +152,7 @@ PHP_METHOD(Phalcon_Cache_AdapterFactory, newInstance) ZEPHIR_INIT_VAR(&_0); zephir_create_array(&_0, 2, 0); zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 466, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 475, PH_NOISY_CC); zephir_array_fast_append(&_0, &_1); zephir_array_fast_append(&_0, &options); ZEPHIR_LAST_CALL_STATUS = zephir_create_instance_params(return_value, &definition, &_0); diff --git a/ext/phalcon/cache/cachefactory.zep.c b/ext/phalcon/cache/cachefactory.zep.c index afca88ccbd..f345674974 100644 --- a/ext/phalcon/cache/cachefactory.zep.c +++ b/ext/phalcon/cache/cachefactory.zep.c @@ -59,7 +59,7 @@ PHP_METHOD(Phalcon_Cache_CacheFactory, __construct) Z_PARAM_OBJECT_OF_CLASS(factory, phalcon_cache_adapterfactory_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &factory); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 467, factory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 476, factory); } /** @@ -195,11 +195,11 @@ PHP_METHOD(Phalcon_Cache_CacheFactory, newInstance) } else { zephir_get_arrval(&options, options_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 467, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 476, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&adapter, &_0, "newinstance", NULL, 0, &name_zv, &options); zephir_check_call_status(); object_init_ex(return_value, phalcon_cache_cache_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 400, &adapter); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 412, &adapter); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/cli/console.zep.c b/ext/phalcon/cli/console.zep.c index 26010a99e9..4cdd29fae7 100644 --- a/ext/phalcon/cli/console.zep.c +++ b/ext/phalcon/cli/console.zep.c @@ -150,19 +150,19 @@ PHP_METHOD(Phalcon_Cli_Console, handle) } else { zephir_get_arrval(&arguments, arguments_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 468, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 477, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_cli_console_exceptions_containerrequired_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 401); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 413); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Cli/Console.zep", 49); ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 469, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 478, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_2) != IS_NULL) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 469, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 478, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_5$$4); ZVAL_STRING(&_5$$4, "console:boot"); ZEPHIR_CALL_METHOD(&_4$$4, &_3$$4, "fire", NULL, 0, &_5$$4, this_ptr); @@ -171,7 +171,7 @@ PHP_METHOD(Phalcon_Cli_Console, handle) RETURN_MM_BOOL(0); } } - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 468, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 477, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_8); ZVAL_STRING(&_8, "router"); ZEPHIR_CALL_METHOD(&_7, &_6, "getshared", NULL, 0, &_8); @@ -179,11 +179,11 @@ PHP_METHOD(Phalcon_Cli_Console, handle) ZEPHIR_CPY_WRT(&router, &_7); _9 = !(zephir_fast_count_int(&arguments)); if (_9) { - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 470, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 479, PH_NOISY_CC | PH_READONLY); _9 = zephir_is_true(&_10); } if (_9) { - zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_2, 470, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_2, 479, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &router, "handle", NULL, 0, &_11$$6); zephir_check_call_status(); } else { @@ -194,12 +194,12 @@ PHP_METHOD(Phalcon_Cli_Console, handle) zephir_check_call_status(); if (!(zephir_is_true(&moduleName))) { ZEPHIR_OBS_NVAR(&moduleName); - zephir_read_property_cached(&moduleName, this_ptr, _zephir_prop_3, 471, PH_NOISY_CC); + zephir_read_property_cached(&moduleName, this_ptr, _zephir_prop_3, 480, PH_NOISY_CC); } if (zephir_is_true(&moduleName)) { - zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_1, 469, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_1, 478, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_12$$9) != IS_NULL) { - zephir_read_property_cached(&_13$$10, this_ptr, _zephir_prop_1, 469, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$10, this_ptr, _zephir_prop_1, 478, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_15$$10); ZVAL_STRING(&_15$$10, "console:beforeStartModule"); ZEPHIR_CALL_METHOD(&_14$$10, &_13$$10, "fire", NULL, 0, &_15$$10, this_ptr, &moduleName); @@ -219,7 +219,7 @@ PHP_METHOD(Phalcon_Cli_Console, handle) object_init_ex(&_17$$12, phalcon_cli_console_exceptions_invalidmoduledefinition_ce); ZEPHIR_INIT_VAR(&_18$$12); ZVAL_STRING(&_18$$12, "The module definition must be an array or an object"); - ZEPHIR_CALL_METHOD(NULL, &_17$$12, "__construct", NULL, 402, &moduleName, &_18$$12); + ZEPHIR_CALL_METHOD(NULL, &_17$$12, "__construct", NULL, 414, &moduleName, &_18$$12); zephir_check_call_status(); zephir_throw_exception_debug(&_17$$12, "phalcon/Cli/Console.zep", 98); ZEPHIR_MM_RESTORE(); @@ -238,7 +238,7 @@ PHP_METHOD(Phalcon_Cli_Console, handle) if (UNEXPECTED(!zephir_is_true(&_19$$15))) { ZEPHIR_INIT_VAR(&_20$$16); object_init_ex(&_20$$16, phalcon_cli_console_exceptions_moduledefinitionpathnotfound_ce); - ZEPHIR_CALL_METHOD(NULL, &_20$$16, "__construct", NULL, 403, &path); + ZEPHIR_CALL_METHOD(NULL, &_20$$16, "__construct", NULL, 415, &path); zephir_check_call_status(); zephir_throw_exception_debug(&_20$$16, "phalcon/Cli/Console.zep", 118); ZEPHIR_MM_RESTORE(); @@ -250,14 +250,14 @@ PHP_METHOD(Phalcon_Cli_Console, handle) } } } - zephir_read_property_cached(&_21$$13, this_ptr, _zephir_prop_0, 468, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$13, this_ptr, _zephir_prop_0, 477, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_22$$13, &_21$$13, "get", NULL, 0, &className); zephir_check_call_status(); ZEPHIR_CPY_WRT(&moduleObject, &_22$$13); - zephir_read_property_cached(&_23$$13, this_ptr, _zephir_prop_0, 468, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$13, this_ptr, _zephir_prop_0, 477, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &moduleObject, "registerautoloaders", NULL, 0, &_23$$13); zephir_check_call_status(); - zephir_read_property_cached(&_24$$13, this_ptr, _zephir_prop_0, 468, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24$$13, this_ptr, _zephir_prop_0, 477, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &moduleObject, "registerservices", NULL, 0, &_24$$13); zephir_check_call_status(); } else { @@ -266,7 +266,7 @@ PHP_METHOD(Phalcon_Cli_Console, handle) object_init_ex(&_25$$19, phalcon_cli_console_exceptions_invalidmoduledefinition_ce); ZEPHIR_INIT_VAR(&_26$$19); ZVAL_STRING(&_26$$19, "The module definition object must be a Closure"); - ZEPHIR_CALL_METHOD(NULL, &_25$$19, "__construct", NULL, 402, &moduleName, &_26$$19); + ZEPHIR_CALL_METHOD(NULL, &_25$$19, "__construct", NULL, 414, &moduleName, &_26$$19); zephir_check_call_status(); zephir_throw_exception_debug(&_25$$19, "phalcon/Cli/Console.zep", 142); ZEPHIR_MM_RESTORE(); @@ -275,15 +275,15 @@ PHP_METHOD(Phalcon_Cli_Console, handle) ZEPHIR_INIT_VAR(&_27$$18); zephir_create_array(&_27$$18, 1, 0); zephir_memory_observe(&_28$$18); - zephir_read_property_cached(&_28$$18, this_ptr, _zephir_prop_0, 468, PH_NOISY_CC); + zephir_read_property_cached(&_28$$18, this_ptr, _zephir_prop_0, 477, PH_NOISY_CC); zephir_array_fast_append(&_27$$18, &_28$$18); ZEPHIR_INIT_NVAR(&moduleObject); ZEPHIR_CALL_USER_FUNC_ARRAY(&moduleObject, &module, &_27$$18); zephir_check_call_status(); } - zephir_read_property_cached(&_29$$9, this_ptr, _zephir_prop_1, 469, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$9, this_ptr, _zephir_prop_1, 478, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_29$$9) != IS_NULL) { - zephir_read_property_cached(&_30$$20, this_ptr, _zephir_prop_1, 469, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_30$$20, this_ptr, _zephir_prop_1, 478, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_32$$20); ZVAL_STRING(&_32$$20, "console:afterStartModule"); ZEPHIR_CALL_METHOD(&_31$$20, &_30$$20, "fire", NULL, 0, &_32$$20, this_ptr, &moduleObject); @@ -293,7 +293,7 @@ PHP_METHOD(Phalcon_Cli_Console, handle) } } } - zephir_read_property_cached(&_33, this_ptr, _zephir_prop_0, 468, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_33, this_ptr, _zephir_prop_0, 477, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_8); ZVAL_STRING(&_8, "dispatcher"); ZEPHIR_CALL_METHOD(&_7, &_33, "getshared", NULL, 0, &_8); @@ -313,12 +313,12 @@ PHP_METHOD(Phalcon_Cli_Console, handle) zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &dispatcher, "setparams", NULL, 0, &_35); zephir_check_call_status(); - zephir_read_property_cached(&_36, this_ptr, _zephir_prop_4, 472, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_36, this_ptr, _zephir_prop_4, 481, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &dispatcher, "setoptions", NULL, 0, &_36); zephir_check_call_status(); - zephir_read_property_cached(&_37, this_ptr, _zephir_prop_1, 469, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_37, this_ptr, _zephir_prop_1, 478, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_37) != IS_NULL) { - zephir_read_property_cached(&_38$$22, this_ptr, _zephir_prop_1, 469, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_38$$22, this_ptr, _zephir_prop_1, 478, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_40$$22); ZVAL_STRING(&_40$$22, "console:beforeHandleTask"); ZEPHIR_CALL_METHOD(&_39$$22, &_38$$22, "fire", NULL, 0, &_40$$22, this_ptr, &dispatcher); @@ -329,9 +329,9 @@ PHP_METHOD(Phalcon_Cli_Console, handle) } ZEPHIR_CALL_METHOD(&task, &dispatcher, "dispatch", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_41, this_ptr, _zephir_prop_1, 469, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_41, this_ptr, _zephir_prop_1, 478, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_41) != IS_NULL) { - zephir_read_property_cached(&_42$$24, this_ptr, _zephir_prop_1, 469, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_42$$24, this_ptr, _zephir_prop_1, 478, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_43$$24); ZVAL_STRING(&_43$$24, "console:afterHandleTask"); ZEPHIR_CALL_METHOD(NULL, &_42$$24, "fire", NULL, 0, &_43$$24, this_ptr, &task); @@ -462,7 +462,7 @@ PHP_METHOD(Phalcon_Cli_Console, setArgument) ZEPHIR_INIT_NVAR(&_2$$5); ZVAL_STRING(&_2$$5, "--"); ZVAL_LONG(&_3$$5, 2); - ZEPHIR_CALL_FUNCTION(&_4$$5, "strncmp", &_5, 404, &arg, &_2$$5, &_3$$5); + ZEPHIR_CALL_FUNCTION(&_4$$5, "strncmp", &_5, 416, &arg, &_2$$5, &_3$$5); zephir_check_call_status(); if (ZEPHIR_IS_LONG(&_4$$5, 0)) { ZEPHIR_INIT_NVAR(&_6$$6); @@ -494,7 +494,7 @@ PHP_METHOD(Phalcon_Cli_Console, setArgument) ZEPHIR_INIT_NVAR(&_17$$9); ZVAL_STRING(&_17$$9, "-"); ZVAL_LONG(&_18$$9, 1); - ZEPHIR_CALL_FUNCTION(&_19$$9, "strncmp", &_5, 404, &arg, &_17$$9, &_18$$9); + ZEPHIR_CALL_FUNCTION(&_19$$9, "strncmp", &_5, 416, &arg, &_17$$9, &_18$$9); zephir_check_call_status(); if (ZEPHIR_IS_LONG(&_19$$9, 0)) { ZVAL_LONG(&_20$$10, 1); @@ -531,7 +531,7 @@ PHP_METHOD(Phalcon_Cli_Console, setArgument) ZEPHIR_INIT_NVAR(&_24$$14); ZVAL_STRING(&_24$$14, "--"); ZVAL_LONG(&_25$$14, 2); - ZEPHIR_CALL_FUNCTION(&_26$$14, "strncmp", &_5, 404, &arg, &_24$$14, &_25$$14); + ZEPHIR_CALL_FUNCTION(&_26$$14, "strncmp", &_5, 416, &arg, &_24$$14, &_25$$14); zephir_check_call_status(); if (ZEPHIR_IS_LONG(&_26$$14, 0)) { ZEPHIR_INIT_NVAR(&_27$$15); @@ -563,7 +563,7 @@ PHP_METHOD(Phalcon_Cli_Console, setArgument) ZEPHIR_INIT_NVAR(&_38$$18); ZVAL_STRING(&_38$$18, "-"); ZVAL_LONG(&_39$$18, 1); - ZEPHIR_CALL_FUNCTION(&_40$$18, "strncmp", &_5, 404, &arg, &_38$$18, &_39$$18); + ZEPHIR_CALL_FUNCTION(&_40$$18, "strncmp", &_5, 416, &arg, &_38$$18, &_39$$18); zephir_check_call_status(); if (ZEPHIR_IS_LONG(&_40$$18, 0)) { ZVAL_LONG(&_41$$19, 1); @@ -585,7 +585,7 @@ PHP_METHOD(Phalcon_Cli_Console, setArgument) ZEPHIR_CALL_CE_STATIC(&_44$$22, phalcon_cli_router_route_ce, "getdelimiter", NULL, 0); zephir_check_call_status(); zephir_fast_join(&_43$$22, &_44$$22, &args); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 470, &_43$$22); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 479, &_43$$22); } else { if (zephir_fast_count_int(&args)) { ZEPHIR_MAKE_REF(&args); @@ -606,9 +606,9 @@ PHP_METHOD(Phalcon_Cli_Console, setArgument) zephir_fast_array_merge(&_47$$26, &handleArgs, &args); ZEPHIR_CPY_WRT(&handleArgs, &_47$$26); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 470, &handleArgs); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 479, &handleArgs); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 472, &opts); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 481, &opts); RETURN_THIS(); } diff --git a/ext/phalcon/cli/dispatcher.zep.c b/ext/phalcon/cli/dispatcher.zep.c index 2edd7413f0..3f71e793f9 100644 --- a/ext/phalcon/cli/dispatcher.zep.c +++ b/ext/phalcon/cli/dispatcher.zep.c @@ -127,7 +127,7 @@ PHP_METHOD(Phalcon_Cli_Dispatcher, callActionMethod) ZEPHIR_CALL_FUNCTION(&localParams, "array_values", NULL, 27, ¶ms); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 473, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 482, PH_NOISY_CC | PH_READONLY); zephir_fast_array_merge(&_0, &localParams, &_1); ZEPHIR_CPY_WRT(&localParams, &_0); ZEPHIR_INIT_VAR(&_2); @@ -211,7 +211,7 @@ PHP_METHOD(Phalcon_Cli_Dispatcher, getOption) defaultValue = &defaultValue_sub; defaultValue = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 473, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 482, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); zephir_memory_observe(&optionValue); if (!(zephir_array_isset_fetch(&optionValue, &options, option, 0))) { @@ -221,7 +221,7 @@ PHP_METHOD(Phalcon_Cli_Dispatcher, getOption) if (Z_TYPE_P(filters) == IS_NULL) { RETURN_CCTOR(&optionValue); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 474, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 483, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (Z_TYPE_P(&container) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$5); @@ -286,7 +286,7 @@ PHP_METHOD(Phalcon_Cli_Dispatcher, hasOption) Z_PARAM_ZVAL(option) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &option); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 473, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 482, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, option)); } @@ -309,7 +309,7 @@ PHP_METHOD(Phalcon_Cli_Dispatcher, setDefaultTask) Z_PARAM_STR(taskName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&taskName_zv, taskName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 475, &taskName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 484, &taskName_zv); } /** @@ -335,7 +335,7 @@ PHP_METHOD(Phalcon_Cli_Dispatcher, setOptions) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &options_param); zephir_get_arrval(&options, options_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 473, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 482, &options); ZEPHIR_MM_RESTORE(); } @@ -358,7 +358,7 @@ PHP_METHOD(Phalcon_Cli_Dispatcher, setTaskName) Z_PARAM_STR(taskName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&taskName_zv, taskName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 476, &taskName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 485, &taskName_zv); } /** @@ -380,7 +380,7 @@ PHP_METHOD(Phalcon_Cli_Dispatcher, setTaskSuffix) Z_PARAM_STR(taskSuffix) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&taskSuffix_zv, taskSuffix); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 477, &taskSuffix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 486, &taskSuffix_zv); } /** @@ -409,7 +409,7 @@ PHP_METHOD(Phalcon_Cli_Dispatcher, handleException) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &exception); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 478, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 487, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_0); if (Z_TYPE_P(&eventsManager) != IS_NULL) { ZEPHIR_INIT_VAR(&_2$$3); diff --git a/ext/phalcon/cli/router.zep.c b/ext/phalcon/cli/router.zep.c index 183d409e7f..5afc4a019f 100644 --- a/ext/phalcon/cli/router.zep.c +++ b/ext/phalcon/cli/router.zep.c @@ -144,9 +144,9 @@ PHP_METHOD(Phalcon_Cli_Router, __construct) add_assoc_long_ex(&_0$$3, SL("task"), 1); ZEPHIR_INIT_VAR(&_1$$3); ZVAL_STRING(&_1$$3, "#^(?::delimiter)?([a-zA-Z0-9\\_\\-]+)[:delimiter]{0,1}$#"); - ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 405, &_1$$3, &_0$$3); + ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 417, &_1$$3, &_0$$3); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_2$$3, &route, "getrouteid", NULL, 406); + ZEPHIR_CALL_METHOD(&_2$$3, &route, "getrouteid", NULL, 418); zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("routes"), &_2$$3, &route); ZEPHIR_INIT_NVAR(&route); @@ -158,9 +158,9 @@ PHP_METHOD(Phalcon_Cli_Router, __construct) add_assoc_long_ex(&_3$$3, SL("params"), 3); ZEPHIR_INIT_NVAR(&_1$$3); ZVAL_STRING(&_1$$3, "#^(?::delimiter)?([a-zA-Z0-9\\_\\-]+):delimiter([a-zA-Z0-9\\.\\_]+)(:delimiter.*)?$#"); - ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 405, &_1$$3, &_3$$3); + ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 417, &_1$$3, &_3$$3); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_4$$3, &route, "getrouteid", NULL, 406); + ZEPHIR_CALL_METHOD(&_4$$3, &route, "getrouteid", NULL, 418); zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("routes"), &_4$$3, &route); } @@ -208,9 +208,9 @@ PHP_METHOD(Phalcon_Cli_Router, add) } ZEPHIR_INIT_VAR(&route); object_init_ex(&route, phalcon_cli_router_route_ce); - ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 405, &pattern_zv, paths); + ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 417, &pattern_zv, paths); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_0, &route, "getrouteid", NULL, 406); + ZEPHIR_CALL_METHOD(&_0, &route, "getrouteid", NULL, 418); zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("routes"), &_0, &route); RETURN_CCTOR(&route); @@ -302,9 +302,9 @@ PHP_METHOD(Phalcon_Cli_Router, getRouteById) Z_PARAM_ZVAL(id) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &id); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 479, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 488, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, id)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 479, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 488, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_2$$3, &_1$$3, id, PH_NOISY | PH_READONLY, "phalcon/Cli/Router.zep", 211); RETURN_CTORW(&_2$$3); } @@ -341,7 +341,7 @@ PHP_METHOD(Phalcon_Cli_Router, getRouteByName) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 479, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 488, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "phalcon/Cli/Router.zep", 230); if (Z_TYPE_P(&_0) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1) @@ -546,11 +546,11 @@ PHP_METHOD(Phalcon_Cli_Router, handle) ZEPHIR_INIT_VAR(&matches); ZVAL_NULL(&matches); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 480, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 489, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 480, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 489, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 481, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 490, &__$null); if (Z_TYPE_P(arguments) != IS_ARRAY) { _0$$3 = Z_TYPE_P(arguments) != IS_STRING; if (_0$$3) { @@ -561,13 +561,13 @@ PHP_METHOD(Phalcon_Cli_Router, handle) object_init_ex(&_1$$4, phalcon_cli_router_exceptions_routerargumentsinvalidtype_ce); ZEPHIR_INIT_VAR(&_2$$4); zephir_gettype(&_2$$4, arguments); - ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 407, &_2$$4); + ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 419, &_2$$4); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$4, "phalcon/Cli/Router.zep", 269); ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 479, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 488, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_3$$3, 0, "phalcon/Cli/Router.zep", 373); if (Z_TYPE_P(&_3$$3) == IS_ARRAY) { ZEND_HASH_REVERSE_FOREACH_VAL(Z_ARRVAL_P(&_3$$3), _4$$3) @@ -592,7 +592,7 @@ PHP_METHOD(Phalcon_Cli_Router, handle) object_init_ex(&_5$$10, phalcon_cli_router_exceptions_beforematchnotcallable_ce); ZEPHIR_CALL_METHOD(&_6$$10, &route, "getpattern", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &_5$$10, "__construct", &_7, 408, &_6$$10); + ZEPHIR_CALL_METHOD(NULL, &_5$$10, "__construct", &_7, 420, &_6$$10); zephir_check_call_status(); zephir_throw_exception_debug(&_5$$10, "phalcon/Cli/Router.zep", 295); ZEPHIR_MM_RESTORE(); @@ -704,9 +704,9 @@ PHP_METHOD(Phalcon_Cli_Router, handle) } ZEPHIR_INIT_NVAR(&position); ZEPHIR_INIT_NVAR(&part); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 482, &matches); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 491, &matches); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 481, &route); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 490, &route); break; } } ZEND_HASH_FOREACH_END(); @@ -746,7 +746,7 @@ PHP_METHOD(Phalcon_Cli_Router, handle) object_init_ex(&_24$$30, phalcon_cli_router_exceptions_beforematchnotcallable_ce); ZEPHIR_CALL_METHOD(&_25$$30, &route, "getpattern", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &_24$$30, "__construct", &_7, 408, &_25$$30); + ZEPHIR_CALL_METHOD(NULL, &_24$$30, "__construct", &_7, 420, &_25$$30); zephir_check_call_status(); zephir_throw_exception_debug(&_24$$30, "phalcon/Cli/Router.zep", 295); ZEPHIR_MM_RESTORE(); @@ -858,9 +858,9 @@ PHP_METHOD(Phalcon_Cli_Router, handle) } ZEPHIR_INIT_NVAR(&position); ZEPHIR_INIT_NVAR(&part); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 482, &matches); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 491, &matches); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 481, &route); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 490, &route); break; } } @@ -868,24 +868,24 @@ PHP_METHOD(Phalcon_Cli_Router, handle) ZEPHIR_INIT_NVAR(&route); if (zephir_is_true(&routeFound)) { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 480, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 489, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 480, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 489, &__$false); } } else { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 480, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 489, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 480, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 489, &__$false); } - zephir_read_property_cached(&_40$$46, this_ptr, _zephir_prop_4, 483, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 484, &_40$$46); - zephir_read_property_cached(&_41$$46, this_ptr, _zephir_prop_6, 485, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 486, &_41$$46); - zephir_read_property_cached(&_42$$46, this_ptr, _zephir_prop_8, 487, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 488, &_42$$46); - zephir_read_property_cached(&_43$$46, this_ptr, _zephir_prop_10, 489, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 490, &_43$$46); + zephir_read_property_cached(&_40$$46, this_ptr, _zephir_prop_4, 492, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 493, &_40$$46); + zephir_read_property_cached(&_41$$46, this_ptr, _zephir_prop_6, 494, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 495, &_41$$46); + zephir_read_property_cached(&_42$$46, this_ptr, _zephir_prop_8, 496, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 497, &_42$$46); + zephir_read_property_cached(&_43$$46, this_ptr, _zephir_prop_10, 498, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 499, &_43$$46); RETURN_THIS(); } } else { @@ -902,21 +902,21 @@ PHP_METHOD(Phalcon_Cli_Router, handle) zephir_array_unset_string(&parts, SL("module"), PH_SEPARATE); } else { ZEPHIR_OBS_NVAR(&moduleName); - zephir_read_property_cached(&moduleName, this_ptr, _zephir_prop_4, 483, PH_NOISY_CC); + zephir_read_property_cached(&moduleName, this_ptr, _zephir_prop_4, 492, PH_NOISY_CC); } ZEPHIR_OBS_NVAR(&taskName); if (zephir_array_isset_string_fetch(&taskName, &parts, SL("task"), 0)) { zephir_array_unset_string(&parts, SL("task"), PH_SEPARATE); } else { ZEPHIR_OBS_NVAR(&taskName); - zephir_read_property_cached(&taskName, this_ptr, _zephir_prop_6, 485, PH_NOISY_CC); + zephir_read_property_cached(&taskName, this_ptr, _zephir_prop_6, 494, PH_NOISY_CC); } ZEPHIR_OBS_NVAR(&actionName); if (zephir_array_isset_string_fetch(&actionName, &parts, SL("action"), 0)) { zephir_array_unset_string(&parts, SL("action"), PH_SEPARATE); } else { ZEPHIR_OBS_NVAR(&actionName); - zephir_read_property_cached(&actionName, this_ptr, _zephir_prop_8, 487, PH_NOISY_CC); + zephir_read_property_cached(&actionName, this_ptr, _zephir_prop_8, 496, PH_NOISY_CC); } ZEPHIR_OBS_NVAR(¶ms); if (zephir_array_isset_string_fetch(¶ms, &parts, SL("params"), 0)) { @@ -944,10 +944,10 @@ PHP_METHOD(Phalcon_Cli_Router, handle) } else { ZEPHIR_CPY_WRT(¶ms, &parts); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 484, &moduleName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 486, &taskName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 488, &actionName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 490, ¶ms); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 493, &moduleName); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 495, &taskName); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 497, &actionName); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 499, ¶ms); RETURN_THIS(); } @@ -970,7 +970,7 @@ PHP_METHOD(Phalcon_Cli_Router, setDefaultAction) Z_PARAM_STR(actionName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&actionName_zv, actionName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 487, &actionName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 496, &actionName_zv); RETURN_THISW(); } @@ -993,7 +993,7 @@ PHP_METHOD(Phalcon_Cli_Router, setDefaultModule) Z_PARAM_STR(moduleName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&moduleName_zv, moduleName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 483, &moduleName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 492, &moduleName_zv); RETURN_THISW(); } @@ -1049,19 +1049,19 @@ PHP_METHOD(Phalcon_Cli_Router, setDefaults) zephir_get_arrval(&defaults, defaults_param); zephir_memory_observe(&module); if (zephir_array_isset_string_fetch(&module, &defaults, SL("module"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 483, &module); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 492, &module); } zephir_memory_observe(&task); if (zephir_array_isset_string_fetch(&task, &defaults, SL("task"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 485, &task); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 494, &task); } zephir_memory_observe(&action); if (zephir_array_isset_string_fetch(&action, &defaults, SL("action"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 487, &action); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 496, &action); } zephir_memory_observe(¶ms); if (zephir_array_isset_string_fetch(¶ms, &defaults, SL("params"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 489, ¶ms); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 498, ¶ms); } RETURN_THIS(); } @@ -1085,7 +1085,7 @@ PHP_METHOD(Phalcon_Cli_Router, setDefaultTask) Z_PARAM_STR(taskName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&taskName_zv, taskName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 485, &taskName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 494, &taskName_zv); RETURN_THISW(); } diff --git a/ext/phalcon/cli/router/route.zep.c b/ext/phalcon/cli/router/route.zep.c index 5f8be8d0be..437f339c99 100644 --- a/ext/phalcon/cli/router/route.zep.c +++ b/ext/phalcon/cli/router/route.zep.c @@ -139,7 +139,7 @@ PHP_METHOD(Phalcon_Cli_Router_Route, __construct) } zephir_memory_observe(&_0); zephir_read_static_property_ce(&_0, phalcon_cli_router_route_ce, SL("delimiterPath"), PH_NOISY_CC); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 491, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 500, &_0); ZEPHIR_CALL_METHOD(NULL, this_ptr, "reconfigure", NULL, 0, &pattern_zv, paths); zephir_check_call_status(); zephir_memory_observe(&_1); @@ -147,7 +147,7 @@ PHP_METHOD(Phalcon_Cli_Router_Route, __construct) ZEPHIR_CPY_WRT(&uniqueId, &_1); ZEPHIR_CPY_WRT(&routeId, &uniqueId); zephir_cast_to_string(&_2, &routeId); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 492, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 501, &_2); ZVAL_UNDEF(&_1); ZVAL_LONG(&_1, (zephir_get_numberval(&uniqueId) + 1)); zephir_update_static_property_ce(phalcon_cli_router_route_ce, ZEND_STRL("uniqueId"), &_1); @@ -189,14 +189,14 @@ PHP_METHOD(Phalcon_Cli_Router_Route, beforeMatch) if (UNEXPECTED(!(zephir_is_callable(callback)))) { ZEPHIR_INIT_VAR(&_0$$3); object_init_ex(&_0$$3, phalcon_cli_router_exceptions_beforematchnotcallable_ce); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 493, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 408, &_1$$3); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 502, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 420, &_1$$3); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$3, "phalcon/Cli/Router/Route.zep", 113); ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 494, callback); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 503, callback); RETURN_THIS(); } @@ -250,41 +250,41 @@ PHP_METHOD(Phalcon_Cli_Router_Route, compilePattern) zephir_fetch_params(1, 1, 0, &pattern_param); zephir_get_strval(&pattern, pattern_param); if (zephir_memnstr_str(&pattern, SL(":"), "phalcon/Cli/Router/Route.zep", 131)) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 500, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&idPattern); ZEPHIR_CONCAT_VS(&idPattern, &_0$$3, "([a-zA-Z0-9\\_\\-]+)"); ZEPHIR_INIT_VAR(&map); zephir_create_array(&map, 7, 0); zephir_memory_observe(&_1$$3); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 500, PH_NOISY_CC); zephir_array_update_string(&map, SL(":delimiter"), &_1$$3, PH_COPY | PH_SEPARATE); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 500, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_3$$3); ZEPHIR_CONCAT_VS(&_3$$3, &_2$$3, ":module"); zephir_array_update_zval(&map, &_3$$3, &idPattern, PH_COPY); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 500, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_5$$3); ZEPHIR_CONCAT_VS(&_5$$3, &_4$$3, ":task"); zephir_array_update_zval(&map, &_5$$3, &idPattern, PH_COPY); - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 500, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_7$$3); ZEPHIR_CONCAT_VS(&_7$$3, &_6$$3, ":namespace"); zephir_array_update_zval(&map, &_7$$3, &idPattern, PH_COPY); - zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 500, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_9$$3); ZEPHIR_CONCAT_VS(&_9$$3, &_8$$3, ":action"); zephir_array_update_zval(&map, &_9$$3, &idPattern, PH_COPY); - zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 500, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_11$$3); ZEPHIR_CONCAT_VS(&_11$$3, &_10$$3, ":params"); - zephir_read_property_cached(&_12$$3, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$3, this_ptr, _zephir_prop_0, 500, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_13$$3); ZEPHIR_CONCAT_SVS(&_13$$3, "(", &_12$$3, ".*)?"); zephir_array_update_zval(&map, &_11$$3, &_13$$3, PH_COPY); - zephir_read_property_cached(&_14$$3, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$3, this_ptr, _zephir_prop_0, 500, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_13$$3); ZEPHIR_CONCAT_VS(&_13$$3, &_14$$3, ":int"); - zephir_read_property_cached(&_15$$3, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$3, this_ptr, _zephir_prop_0, 500, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_16$$3); ZEPHIR_CONCAT_VS(&_16$$3, &_15$$3, "([0-9]+)"); zephir_array_update_zval(&map, &_13$$3, &_16$$3, PH_COPY); @@ -562,7 +562,7 @@ PHP_METHOD(Phalcon_Cli_Router_Route, extractNamedParams) } zephir_array_update_zval(&matches, &variable, &tmp, PH_COPY | PH_SEPARATE); } else { - zephir_read_property_cached(&_28$$27, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$27, this_ptr, _zephir_prop_0, 500, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_29$$27); ZEPHIR_CONCAT_SVS(&_29$$27, "([^", &_28$$27, "]*)"); zephir_concat_self(&route, &_29$$27); @@ -693,8 +693,8 @@ PHP_METHOD(Phalcon_Cli_Router_Route, getReversedPaths) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 495, PH_NOISY_CC | PH_READONLY); - ZEPHIR_RETURN_CALL_FUNCTION("array_flip", NULL, 247, &_0); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 504, PH_NOISY_CC | PH_READONLY); + ZEPHIR_RETURN_CALL_FUNCTION("array_flip", NULL, 253, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -835,7 +835,7 @@ PHP_METHOD(Phalcon_Cli_Router_Route, reConfigure) if (UNEXPECTED(_1$$10)) { ZEPHIR_INIT_VAR(&_2$$11); object_init_ex(&_2$$11, phalcon_cli_router_exceptions_invalidroutepaths_ce); - ZEPHIR_CALL_METHOD(NULL, &_2$$11, "__construct", NULL, 409, &pattern); + ZEPHIR_CALL_METHOD(NULL, &_2$$11, "__construct", NULL, 421, &pattern); zephir_check_call_status(); zephir_throw_exception_debug(&_2$$11, "phalcon/Cli/Router/Route.zep", 466); ZEPHIR_MM_RESTORE(); @@ -860,7 +860,7 @@ PHP_METHOD(Phalcon_Cli_Router_Route, reConfigure) if (UNEXPECTED(Z_TYPE_P(&routePaths) != IS_ARRAY)) { ZEPHIR_INIT_VAR(&_4$$16); object_init_ex(&_4$$16, phalcon_cli_router_exceptions_invalidroutepaths_ce); - ZEPHIR_CALL_METHOD(NULL, &_4$$16, "__construct", NULL, 409, &pattern); + ZEPHIR_CALL_METHOD(NULL, &_4$$16, "__construct", NULL, 421, &pattern); zephir_check_call_status(); zephir_throw_exception_debug(&_4$$16, "phalcon/Cli/Router/Route.zep", 490); ZEPHIR_MM_RESTORE(); @@ -884,7 +884,7 @@ PHP_METHOD(Phalcon_Cli_Router_Route, reConfigure) } else { if (zephir_memnstr_str(&pattern, SL(":delimiter"), "phalcon/Cli/Router/Route.zep", 515)) { ZEPHIR_INIT_VAR(&_7$$21); - zephir_read_property_cached(&_8$$21, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$21, this_ptr, _zephir_prop_0, 500, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_9$$21); ZVAL_STRING(&_9$$21, ":delimiter"); zephir_fast_str_replace(&_7$$21, &_9$$21, &_8$$21, &pattern); @@ -892,9 +892,9 @@ PHP_METHOD(Phalcon_Cli_Router_Route, reConfigure) } ZEPHIR_CPY_WRT(&compiledPattern, &pattern); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 493, &pattern); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 496, &compiledPattern); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 495, &routePaths); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 502, &pattern); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 505, &compiledPattern); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 504, &routePaths); ZEPHIR_MM_RESTORE(); } @@ -934,7 +934,7 @@ PHP_METHOD(Phalcon_Cli_Router_Route, setDescription) Z_PARAM_STR(description) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&description_zv, description); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 497, &description_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 506, &description_zv); RETURN_THISW(); } @@ -966,7 +966,7 @@ PHP_METHOD(Phalcon_Cli_Router_Route, setName) Z_PARAM_STR(name) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 498, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 507, &name_zv); RETURN_THISW(); } diff --git a/ext/phalcon/cli/task.zep.c b/ext/phalcon/cli/task.zep.c index 54902030b7..5322772598 100644 --- a/ext/phalcon/cli/task.zep.c +++ b/ext/phalcon/cli/task.zep.c @@ -111,6 +111,6 @@ PHP_METHOD(Phalcon_Cli_Task, setEventsManager) Z_PARAM_OBJECT_OF_CLASS(eventsManager, phalcon_events_managerinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &eventsManager); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 261, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 262, eventsManager); } diff --git a/ext/phalcon/config/adapter/grouped.zep.c b/ext/phalcon/config/adapter/grouped.zep.c index fc763c6fe4..b5bd569686 100644 --- a/ext/phalcon/config/adapter/grouped.zep.c +++ b/ext/phalcon/config/adapter/grouped.zep.c @@ -172,7 +172,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Grouped, __construct) if (Z_TYPE_P(&configFactory) == IS_NULL) { ZEPHIR_INIT_NVAR(&configFactory); object_init_ex(&configFactory, phalcon_config_configfactory_ce); - ZEPHIR_CALL_METHOD(NULL, &configFactory, "__construct", NULL, 410); + ZEPHIR_CALL_METHOD(NULL, &configFactory, "__construct", NULL, 422); zephir_check_call_status(); } zephir_is_iterable(&arrayConfig, 0, "phalcon/Config/Adapter/Grouped.zep", 135); @@ -194,7 +194,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Grouped, __construct) ZEPHIR_INIT_NVAR(&_4$$6); ZVAL_STRING(&_4$$6, ""); if (ZEPHIR_IS_IDENTICAL(&_4$$6, &defaultAdapter_zv)) { - ZEPHIR_CALL_METHOD(&_5$$7, &configFactory, "load", &_6, 411, &configName); + ZEPHIR_CALL_METHOD(&_5$$7, &configFactory, "load", &_6, 423, &configName); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, this_ptr, "merge", &_3, 0, &_5$$7); zephir_check_call_status(); @@ -215,7 +215,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Grouped, __construct) if (!(zephir_array_isset_value_string(&configInstance, SL("config")))) { ZEPHIR_INIT_NVAR(&_10$$10); object_init_ex(&_10$$10, phalcon_config_exceptions_groupedadapterrequiresarray_ce); - ZEPHIR_CALL_METHOD(NULL, &_10$$10, "__construct", &_11, 412); + ZEPHIR_CALL_METHOD(NULL, &_10$$10, "__construct", &_11, 424); zephir_check_call_status(); zephir_throw_exception_debug(&_10$$10, "phalcon/Config/Adapter/Grouped.zep", 124); ZEPHIR_MM_RESTORE(); @@ -225,11 +225,11 @@ PHP_METHOD(Phalcon_Config_Adapter_Grouped, __construct) zephir_array_fetch_string(&configArray, &configInstance, SL("config"), PH_NOISY, "phalcon/Config/Adapter/Grouped.zep", 127); ZEPHIR_INIT_NVAR(&configInstance); object_init_ex(&configInstance, phalcon_config_config_ce); - zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_0, 499, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_0, 508, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &configInstance, "__construct", &_13, 41, &configArray, &_12$$9); zephir_check_call_status(); } else { - ZEPHIR_CALL_METHOD(&_14$$11, &configFactory, "load", &_6, 411, &configInstance); + ZEPHIR_CALL_METHOD(&_14$$11, &configFactory, "load", &_6, 423, &configInstance); zephir_check_call_status(); ZEPHIR_CPY_WRT(&configInstance, &_14$$11); } @@ -267,7 +267,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Grouped, __construct) ZEPHIR_INIT_NVAR(&_18$$14); ZVAL_STRING(&_18$$14, ""); if (ZEPHIR_IS_IDENTICAL(&_18$$14, &defaultAdapter_zv)) { - ZEPHIR_CALL_METHOD(&_19$$15, &configFactory, "load", &_6, 411, &configName); + ZEPHIR_CALL_METHOD(&_19$$15, &configFactory, "load", &_6, 423, &configName); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, this_ptr, "merge", &_3, 0, &_19$$15); zephir_check_call_status(); @@ -288,7 +288,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Grouped, __construct) if (!(zephir_array_isset_value_string(&configInstance, SL("config")))) { ZEPHIR_INIT_NVAR(&_23$$18); object_init_ex(&_23$$18, phalcon_config_exceptions_groupedadapterrequiresarray_ce); - ZEPHIR_CALL_METHOD(NULL, &_23$$18, "__construct", &_11, 412); + ZEPHIR_CALL_METHOD(NULL, &_23$$18, "__construct", &_11, 424); zephir_check_call_status(); zephir_throw_exception_debug(&_23$$18, "phalcon/Config/Adapter/Grouped.zep", 124); ZEPHIR_MM_RESTORE(); @@ -298,11 +298,11 @@ PHP_METHOD(Phalcon_Config_Adapter_Grouped, __construct) zephir_array_fetch_string(&configArray, &configInstance, SL("config"), PH_NOISY, "phalcon/Config/Adapter/Grouped.zep", 127); ZEPHIR_INIT_NVAR(&configInstance); object_init_ex(&configInstance, phalcon_config_config_ce); - zephir_read_property_cached(&_24$$17, this_ptr, _zephir_prop_0, 499, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24$$17, this_ptr, _zephir_prop_0, 508, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &configInstance, "__construct", &_13, 41, &configArray, &_24$$17); zephir_check_call_status(); } else { - ZEPHIR_CALL_METHOD(&_25$$19, &configFactory, "load", &_6, 411, &configInstance); + ZEPHIR_CALL_METHOD(&_25$$19, &configFactory, "load", &_6, 423, &configInstance); zephir_check_call_status(); ZEPHIR_CPY_WRT(&configInstance, &_25$$19); } diff --git a/ext/phalcon/config/adapter/ini.zep.c b/ext/phalcon/config/adapter/ini.zep.c index 18fa0ade23..3b794030b8 100644 --- a/ext/phalcon/config/adapter/ini.zep.c +++ b/ext/phalcon/config/adapter/ini.zep.c @@ -154,7 +154,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Ini, __construct) object_init_ex(&_2$$3, phalcon_config_exceptions_cannotloadconfigfile_ce); ZEPHIR_INIT_VAR(&_3$$3); zephir_basename(&_3$$3, &filePath_zv); - ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 413, &_3$$3); + ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 425, &_3$$3); zephir_check_call_status(); zephir_throw_exception_debug(&_2$$3, "phalcon/Config/Adapter/Ini.zep", 80); ZEPHIR_MM_RESTORE(); @@ -539,7 +539,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Ini, parseIniString) ZEPHIR_INIT_VAR(&_3); zephir_substr(&_3, &path, zephir_get_intval(&_2), 0, ZEPHIR_SUBSTR_NO_LENGTH); zephir_get_strval(&path, &_3); - ZEPHIR_CALL_METHOD(&result, this_ptr, "parseinistring", NULL, 414, &path, &castValue); + ZEPHIR_CALL_METHOD(&result, this_ptr, "parseinistring", NULL, 426, &path, &castValue); zephir_check_call_status(); zephir_create_array(return_value, 1, 0); zephir_array_update_zval(return_value, &key, &result, PH_COPY); @@ -584,7 +584,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Ini, phpIniGet) zephir_memory_observe(&defaultValue_zv); ZVAL_STR_COPY(&defaultValue_zv, defaultValue); } - ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 427, &input_zv); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&value)) { RETURN_MM_STR(zend_string_copy(defaultValue)); @@ -631,7 +631,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Ini, phpIniGetBool) } else { } result = 0; - ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 427, &input_zv); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&value)) { RETURN_MM_BOOL(defaultValue); @@ -683,7 +683,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Ini, phpIniGetInt) defaultValue = 0; } else { } - ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 427, &input_zv); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&value)) { RETURN_MM_LONG(defaultValue); @@ -739,7 +739,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Ini, phpParseIniFile) } ZVAL_BOOL(&_0, (processSections ? 1 : 0)); ZVAL_LONG(&_1, scannerMode); - ZEPHIR_RETURN_CALL_FUNCTION("parse_ini_file", NULL, 416, &filename_zv, &_0, &_1); + ZEPHIR_RETURN_CALL_FUNCTION("parse_ini_file", NULL, 428, &filename_zv, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/config/adapter/json.zep.c b/ext/phalcon/config/adapter/json.zep.c index 298c3b2c0c..a1331bd9cb 100644 --- a/ext/phalcon/config/adapter/json.zep.c +++ b/ext/phalcon/config/adapter/json.zep.c @@ -89,7 +89,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Json, __construct) object_init_ex(&_0$$3, phalcon_config_exceptions_cannotloadconfigfile_ce); ZEPHIR_INIT_VAR(&_1$$3); zephir_basename(&_1$$3, &filePath_zv); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 413, &_1$$3); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 425, &_1$$3); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$3, "phalcon/Config/Adapter/Json.zep", 54); ZEPHIR_MM_RESTORE(); @@ -103,7 +103,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Json, __construct) } ZVAL_BOOL(&_4, 1); - ZEPHIR_CALL_METHOD(&_3, &_2, "__invoke", NULL, 359, &content, &_4); + ZEPHIR_CALL_METHOD(&_3, &_2, "__invoke", NULL, 371, &content, &_4); zephir_check_call_status(); ZEPHIR_CALL_PARENT(NULL, phalcon_config_adapter_json_ce, getThis(), "__construct", NULL, 0, &_3); zephir_check_call_status(); diff --git a/ext/phalcon/config/adapter/php.zep.c b/ext/phalcon/config/adapter/php.zep.c index 1d0c3462d3..75665726af 100644 --- a/ext/phalcon/config/adapter/php.zep.c +++ b/ext/phalcon/config/adapter/php.zep.c @@ -95,14 +95,14 @@ PHP_METHOD(Phalcon_Config_Adapter_Php, __construct) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&filePath_zv); ZVAL_STR_COPY(&filePath_zv, filePath); - ZEPHIR_CALL_FUNCTION(&_0, "is_file", NULL, 417, &filePath_zv); + ZEPHIR_CALL_FUNCTION(&_0, "is_file", NULL, 429, &filePath_zv); zephir_check_call_status(); if (UNEXPECTED(!ZEPHIR_IS_TRUE_IDENTICAL(&_0))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_config_exceptions_cannotloadconfigfile_ce); ZEPHIR_INIT_VAR(&_2$$3); zephir_basename(&_2$$3, &filePath_zv); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 413, &_2$$3); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 425, &_2$$3); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Config/Adapter/Php.zep", 61); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/config/adapter/yaml.zep.c b/ext/phalcon/config/adapter/yaml.zep.c index cee1ff8917..d82a7a5adf 100644 --- a/ext/phalcon/config/adapter/yaml.zep.c +++ b/ext/phalcon/config/adapter/yaml.zep.c @@ -118,7 +118,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Yaml, __construct) if (UNEXPECTED(!zephir_is_true(&_0))) { ZEPHIR_INIT_VAR(&_2$$3); object_init_ex(&_2$$3, phalcon_config_exceptions_missingyamlextension_ce); - ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 418); + ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 430); zephir_check_call_status(); zephir_throw_exception_debug(&_2$$3, "phalcon/Config/Adapter/Yaml.zep", 70); ZEPHIR_MM_RESTORE(); @@ -141,7 +141,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Yaml, __construct) object_init_ex(&_4$$7, phalcon_config_exceptions_cannotloadconfigfile_ce); ZEPHIR_INIT_VAR(&_5$$7); zephir_basename(&_5$$7, &filePath_zv); - ZEPHIR_CALL_METHOD(NULL, &_4$$7, "__construct", NULL, 413, &_5$$7); + ZEPHIR_CALL_METHOD(NULL, &_4$$7, "__construct", NULL, 425, &_5$$7); zephir_check_call_status(); zephir_throw_exception_debug(&_4$$7, "phalcon/Config/Adapter/Yaml.zep", 84); ZEPHIR_MM_RESTORE(); @@ -176,7 +176,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Yaml, phpExtensionLoaded) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 431, &name_zv); zephir_check_call_status(); RETURN_MM(); } @@ -256,7 +256,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Yaml, phpYamlParseFile) ZVAL_NULL(&ndocs); ZVAL_LONG(&_0, pos); ZEPHIR_MAKE_REF(&ndocs); - ZEPHIR_RETURN_CALL_FUNCTION("yaml_parse_file", NULL, 420, &filename_zv, &_0, &ndocs, &callbacks); + ZEPHIR_RETURN_CALL_FUNCTION("yaml_parse_file", NULL, 432, &filename_zv, &_0, &ndocs, &callbacks); ZEPHIR_UNREF(&ndocs); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/config/configfactory.zep.c b/ext/phalcon/config/configfactory.zep.c index 2b0b91be78..06b0e56dc8 100644 --- a/ext/phalcon/config/configfactory.zep.c +++ b/ext/phalcon/config/configfactory.zep.c @@ -359,7 +359,7 @@ PHP_METHOD(Phalcon_Config_ConfigFactory, parseConfig) if (1 == ZEPHIR_IS_EMPTY(&extension)) { ZEPHIR_INIT_VAR(&_1$$4); object_init_ex(&_1$$4, phalcon_config_exceptions_missingfileextension_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 421); + ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 433); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$4, "phalcon/Config/ConfigFactory.zep", 188); ZEPHIR_MM_RESTORE(); @@ -383,13 +383,13 @@ PHP_METHOD(Phalcon_Config_ConfigFactory, parseConfig) if (Z_TYPE_P(config) != IS_ARRAY) { ZEPHIR_INIT_VAR(&_5$$6); object_init_ex(&_5$$6, phalcon_config_exceptions_confignotarrayorobject_ce); - ZEPHIR_CALL_METHOD(NULL, &_5$$6, "__construct", NULL, 422); + ZEPHIR_CALL_METHOD(NULL, &_5$$6, "__construct", NULL, 434); zephir_check_call_status(); zephir_throw_exception_debug(&_5$$6, "phalcon/Config/ConfigFactory.zep", 202); ZEPHIR_MM_RESTORE(); return; } - ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkconfigarray", NULL, 423, config); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkconfigarray", NULL, 435, config); zephir_check_call_status(); RETVAL_ZVAL(config, 1, 0); RETURN_MM(); diff --git a/ext/phalcon/config/exceptions/cannotloadconfigfile.zep.c b/ext/phalcon/config/exceptions/cannotloadconfigfile.zep.c index ca37af2329..72ecd05782 100644 --- a/ext/phalcon/config/exceptions/cannotloadconfigfile.zep.c +++ b/ext/phalcon/config/exceptions/cannotloadconfigfile.zep.c @@ -60,7 +60,7 @@ PHP_METHOD(Phalcon_Config_Exceptions_CannotLoadConfigFile, __construct) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&fileName_zv); ZVAL_STR_COPY(&fileName_zv, fileName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 500, &fileName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 509, &fileName_zv); ZEPHIR_INIT_VAR(&_0); ZEPHIR_CONCAT_SVS(&_0, "Configuration file ", &fileName_zv, " cannot be loaded"); ZEPHIR_CALL_PARENT(NULL, phalcon_config_exceptions_cannotloadconfigfile_ce, getThis(), "__construct", NULL, 0, &_0); diff --git a/ext/phalcon/config/exceptions/missingconfigoption.zep.c b/ext/phalcon/config/exceptions/missingconfigoption.zep.c index 419bd30b7a..f336a5feb0 100644 --- a/ext/phalcon/config/exceptions/missingconfigoption.zep.c +++ b/ext/phalcon/config/exceptions/missingconfigoption.zep.c @@ -60,7 +60,7 @@ PHP_METHOD(Phalcon_Config_Exceptions_MissingConfigOption, __construct) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&option_zv); ZVAL_STR_COPY(&option_zv, option); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 501, &option_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 510, &option_zv); ZEPHIR_INIT_VAR(&_0); ZEPHIR_CONCAT_SVS(&_0, "You must provide '", &option_zv, "' option in factory config parameter."); ZEPHIR_CALL_PARENT(NULL, phalcon_config_exceptions_missingconfigoption_ce, getThis(), "__construct", NULL, 0, &_0); diff --git a/ext/phalcon/container/container.zep.c b/ext/phalcon/container/container.zep.c index 1a7f9e974e..ad1ca923a0 100644 --- a/ext/phalcon/container/container.zep.c +++ b/ext/phalcon/container/container.zep.c @@ -123,7 +123,7 @@ PHP_METHOD(Phalcon_Container_Container, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 502, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 511, &_0); ZEPHIR_INIT_VAR(&_1); zephir_create_array(&_1, 3, 0); ZEPHIR_INIT_VAR(&_2); @@ -150,7 +150,7 @@ PHP_METHOD(Phalcon_Container_Container, __construct) } zephir_array_fast_append(&_1, &_2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 503, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 512, &_1); ZEPHIR_MM_RESTORE(); } @@ -211,8 +211,8 @@ PHP_METHOD(Phalcon_Container_Container, callableGet) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); ZEPHIR_CPY_WRT(&serviceName, &name_zv); - zephir_create_closure_ex(return_value, this_ptr, phalcon_7__closure_ce, SL("__invoke")); - zephir_update_static_property_ce(phalcon_7__closure_ce, ZEND_STRL("serviceName"), &serviceName); + zephir_create_closure_ex(return_value, this_ptr, phalcon_9__closure_ce, SL("__invoke")); + zephir_update_static_property_ce(phalcon_9__closure_ce, ZEND_STRL("serviceName"), &serviceName); RETURN_MM(); } @@ -239,8 +239,8 @@ PHP_METHOD(Phalcon_Container_Container, callableNew) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); ZEPHIR_CPY_WRT(&serviceName, &name_zv); - zephir_create_closure_ex(return_value, this_ptr, phalcon_8__closure_ce, SL("__invoke")); - zephir_update_static_property_ce(phalcon_8__closure_ce, ZEND_STRL("serviceName"), &serviceName); + zephir_create_closure_ex(return_value, this_ptr, phalcon_10__closure_ce, SL("__invoke")); + zephir_update_static_property_ce(phalcon_10__closure_ce, ZEND_STRL("serviceName"), &serviceName); RETURN_MM(); } @@ -288,30 +288,30 @@ PHP_METHOD(Phalcon_Container_Container, extend) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 2, 0, &name_param, &callableObject); zephir_get_strval(&name, name_param); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "resolvealias", NULL, 424, &name); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "resolvealias", NULL, 436, &name); zephir_check_call_status(); zephir_get_strval(&name, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 504, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 513, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_1, &name)) { ZEPHIR_INIT_VAR(&_2$$3); object_init_ex(&_2$$3, phalcon_container_exceptions_cannotextendresolved_ce); - ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 425, &name); + ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 437, &name); zephir_check_call_status(); zephir_throw_exception_debug(&_2$$3, "phalcon/Container/Container.zep", 165); ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 505, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 514, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_key_exists(&_3, &name))) { ZEPHIR_INIT_VAR(&_4$$4); object_init_ex(&_4$$4, phalcon_container_exceptions_servicenotfound_ce); - ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 426, &name); + ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 438, &name); zephir_check_call_status(); zephir_throw_exception_debug(&_4$$4, "phalcon/Container/Container.zep", 169); ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 505, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 514, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_6, &_5, &name, PH_NOISY | PH_READONLY, "phalcon/Container/Container.zep", 172); ZEPHIR_CALL_METHOD(NULL, &_6, "addextender", NULL, 0, callableObject); zephir_check_call_status(); @@ -357,23 +357,23 @@ PHP_METHOD(Phalcon_Container_Container, get) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &name_param); zephir_get_strval(&name, name_param); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "resolvealias", NULL, 424, &name); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "resolvealias", NULL, 436, &name); zephir_check_call_status(); zephir_get_strval(&name, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 506, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 515, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_1, &name)) { - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "resolveparameter", NULL, 427, &name); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "resolveparameter", NULL, 439, &name); zephir_check_call_status(); RETURN_MM(); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 504, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 513, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_2, &name)) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 504, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 513, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_4$$4, &_3$$4, &name, PH_NOISY | PH_READONLY, "phalcon/Container/Container.zep", 192); RETURN_CTOR(&_4$$4); } ZVAL_BOOL(&_5, 1); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "resolve", NULL, 428, &name, &_5); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "resolve", NULL, 440, &name, &_5); zephir_check_call_status(); RETURN_MM(); } @@ -408,7 +408,7 @@ PHP_METHOD(Phalcon_Container_Container, getAlias) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); zephir_memory_observe(&alias); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 507, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 516, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&alias, &_0, &name_zv, 0)) { RETURN_CCTOR(&alias); } @@ -453,7 +453,7 @@ PHP_METHOD(Phalcon_Container_Container, getByTag) zephir_memory_observe(&tag_zv); ZVAL_STR_COPY(&tag_zv, tag); zephir_memory_observe(&names); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 508, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 517, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&names, &_0, &tag_zv, 0))) { ZEPHIR_INIT_NVAR(&names); array_init(&names); @@ -530,17 +530,17 @@ PHP_METHOD(Phalcon_Container_Container, getDefinition) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 505, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 514, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_key_exists(&_0, &name_zv))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_container_exceptions_servicenotfound_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 426, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 438, &name_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Container/Container.zep", 251); ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 505, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 514, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_3, &_2, &name_zv, PH_NOISY | PH_READONLY, "phalcon/Container/Container.zep", 254); RETURN_CTOR(&_3); } @@ -578,17 +578,17 @@ PHP_METHOD(Phalcon_Container_Container, getInstance) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 504, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 513, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_key_exists(&_0, &name_zv))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_container_exceptions_instancenotfound_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 429, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 441, &name_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Container/Container.zep", 268); ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 504, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 513, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_3, &_2, &name_zv, PH_NOISY | PH_READONLY, "phalcon/Container/Container.zep", 271); RETURN_CTOR(&_3); } @@ -624,17 +624,17 @@ PHP_METHOD(Phalcon_Container_Container, getParameter) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 506, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 515, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_key_exists(&_0, &name_zv))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_container_exceptions_parameternotfound_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 430, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 442, &name_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Container/Container.zep", 285); ZEPHIR_MM_RESTORE(); return; } - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "resolveparameter", NULL, 427, &name_zv); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "resolveparameter", NULL, 439, &name_zv); zephir_check_call_status(); RETURN_MM(); } @@ -682,7 +682,7 @@ PHP_METHOD(Phalcon_Container_Container, getService) if (!(Z_TYPE_P(&result) == IS_OBJECT)) { ZEPHIR_INIT_VAR(&_0$$3); object_init_ex(&_0$$3, phalcon_container_exceptions_servicenotregistered_ce); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 431, &serviceName_zv); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 443, &serviceName_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$3, "phalcon/Container/Container.zep", 317); ZEPHIR_MM_RESTORE(); @@ -744,27 +744,27 @@ PHP_METHOD(Phalcon_Container_Container, has) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &name_param); zephir_get_strval(&name, name_param); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "resolvealias", NULL, 424, &name); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "resolvealias", NULL, 436, &name); zephir_check_call_status(); zephir_get_strval(&name, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 506, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 515, PH_NOISY_CC | PH_READONLY); _2 = zephir_array_key_exists(&_1, &name); if (!(_2)) { - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 504, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 513, PH_NOISY_CC | PH_READONLY); _2 = zephir_array_key_exists(&_3, &name); } _4 = _2; if (!(_4)) { - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 505, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 514, PH_NOISY_CC | PH_READONLY); _4 = zephir_array_key_exists(&_5, &name); } if (_4) { RETURN_MM_BOOL(1); } - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_3, 509, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_3, 518, PH_NOISY_CC | PH_READONLY); _7 = zephir_is_true(&_6); if (_7) { - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_4, 502, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_4, 511, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_9, &_8, "isresolvableclass", NULL, 0, &name); zephir_check_call_status(); _7 = zephir_is_true(&_9); @@ -796,7 +796,7 @@ PHP_METHOD(Phalcon_Container_Container, hasAlias) Z_PARAM_STR(name) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 507, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 516, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_key_exists(&_0, &name_zv)); } @@ -824,7 +824,7 @@ PHP_METHOD(Phalcon_Container_Container, hasDefinition) Z_PARAM_STR(name) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 505, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 514, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_key_exists(&_0, &name_zv)); } @@ -852,7 +852,7 @@ PHP_METHOD(Phalcon_Container_Container, hasInstance) Z_PARAM_STR(name) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 504, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 513, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_key_exists(&_0, &name_zv)); } @@ -880,7 +880,7 @@ PHP_METHOD(Phalcon_Container_Container, hasParameter) Z_PARAM_STR(name) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 506, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 515, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_key_exists(&_0, &name_zv)); } @@ -952,11 +952,11 @@ PHP_METHOD(Phalcon_Container_Container, new) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &name_param); zephir_get_strval(&name, name_param); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "resolvealias", NULL, 424, &name); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "resolvealias", NULL, 436, &name); zephir_check_call_status(); zephir_get_strval(&name, &_0); ZVAL_BOOL(&_1, 0); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "resolve", NULL, 428, &name, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "resolve", NULL, 440, &name, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -987,7 +987,7 @@ PHP_METHOD(Phalcon_Container_Container, newDefinition) object_init_ex(return_value, phalcon_container_definition_servicedefinition_ce); ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "string"); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 432, &name_zv, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 444, &name_zv, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -1022,7 +1022,7 @@ PHP_METHOD(Phalcon_Container_Container, set) definition = ZEND_CALL_ARG(execute_data, 2); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_CALL_METHOD(&processor, this_ptr, "findprocessor", NULL, 433, definition); + ZEPHIR_CALL_METHOD(&processor, this_ptr, "findprocessor", NULL, 445, definition); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&def, &processor, "process", NULL, 0, &name_zv, definition, this_ptr); zephir_check_call_status(); @@ -1061,7 +1061,7 @@ PHP_METHOD(Phalcon_Container_Container, setAlias) ZVAL_STR_COPY(&name_zv, name); zephir_memory_observe(&alias_zv); ZVAL_STR_COPY(&alias_zv, alias); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "detectcircularalias", NULL, 434, &alias_zv, &name_zv); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "detectcircularalias", NULL, 446, &alias_zv, &name_zv); zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("aliases"), &alias_zv, &name_zv); RETURN_THIS(); @@ -1092,9 +1092,9 @@ PHP_METHOD(Phalcon_Container_Container, setAutowire) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &enabled_param); if (enabled) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 509, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 518, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 509, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 518, &__$false); } RETURN_THISW(); } @@ -1221,13 +1221,13 @@ PHP_METHOD(Phalcon_Container_Container, setTag) ZVAL_STR_COPY(&tag_zv, tag); zephir_memory_observe(&serviceName_zv); ZVAL_STR_COPY(&serviceName_zv, serviceName); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 508, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 517, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_key_exists(&_0, &tag_zv))) { ZEPHIR_INIT_VAR(&_1$$3); array_init(&_1$$3); zephir_update_property_array(this_ptr, SL("tags"), &tag_zv, &_1$$3); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 508, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 517, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_3, &_2, &tag_zv, PH_NOISY | PH_READONLY, "phalcon/Container/Container.zep", 561); ZEPHIR_CALL_FUNCTION(&_4, "in_array", NULL, 87, &serviceName_zv, &_3, &__$true); zephir_check_call_status(); @@ -1262,7 +1262,7 @@ PHP_METHOD(Phalcon_Container_Container, unsetAlias) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); zephir_unset_property_array(this_ptr, ZEND_STRL("aliases"), &name_zv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 507, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 516, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_0, &name_zv, PH_SEPARATE); } @@ -1291,7 +1291,7 @@ PHP_METHOD(Phalcon_Container_Container, unsetDefinition) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); zephir_unset_property_array(this_ptr, ZEND_STRL("services"), &name_zv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 505, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 514, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_0, &name_zv, PH_SEPARATE); } @@ -1325,10 +1325,10 @@ PHP_METHOD(Phalcon_Container_Container, unsetInstance) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); zephir_unset_property_array(this_ptr, ZEND_STRL("instances"), &name_zv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 504, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 513, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_0, &name_zv, PH_SEPARATE); zephir_unset_property_array(this_ptr, ZEND_STRL("instanceLifetimes"), &name_zv); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 510, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 519, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_1, &name_zv, PH_SEPARATE); } @@ -1374,7 +1374,7 @@ PHP_METHOD(Phalcon_Container_Container, unsetInstances) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&lifetime_zv); ZVAL_STR_COPY(&lifetime_zv, lifetime); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 510, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 519, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "phalcon/Container/Container.zep", 620); if (Z_TYPE_P(&_0) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_0), _2, _3, _1) @@ -1389,10 +1389,10 @@ PHP_METHOD(Phalcon_Container_Container, unsetInstances) ZVAL_COPY(&instanceLifetime, _1); if (ZEPHIR_IS_IDENTICAL(&instanceLifetime, &lifetime_zv)) { zephir_unset_property_array(this_ptr, ZEND_STRL("instances"), &name); - zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_1, 504, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_1, 513, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_4$$4, &name, PH_SEPARATE); zephir_unset_property_array(this_ptr, ZEND_STRL("instanceLifetimes"), &name); - zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 510, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 519, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_5$$4, &name, PH_SEPARATE); } } ZEND_HASH_FOREACH_END(); @@ -1418,10 +1418,10 @@ PHP_METHOD(Phalcon_Container_Container, unsetInstances) zephir_check_call_status(); if (ZEPHIR_IS_IDENTICAL(&instanceLifetime, &lifetime_zv)) { zephir_unset_property_array(this_ptr, ZEND_STRL("instances"), &name); - zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_1, 504, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_1, 513, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_8$$6, &name, PH_SEPARATE); zephir_unset_property_array(this_ptr, ZEND_STRL("instanceLifetimes"), &name); - zephir_read_property_cached(&_9$$6, this_ptr, _zephir_prop_0, 510, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$6, this_ptr, _zephir_prop_0, 519, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_9$$6, &name, PH_SEPARATE); } } @@ -1456,7 +1456,7 @@ PHP_METHOD(Phalcon_Container_Container, unsetParameter) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); zephir_unset_property_array(this_ptr, ZEND_STRL("parameters"), &name_zv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 506, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 515, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_0, &name_zv, PH_SEPARATE); } @@ -1512,7 +1512,7 @@ PHP_METHOD(Phalcon_Container_Container, detectCircularAlias) if (ZEPHIR_IS_IDENTICAL(¤t, &alias_zv)) { ZEPHIR_INIT_NVAR(&_0$$4); object_init_ex(&_0$$4, phalcon_container_exceptions_circularaliasfound_ce); - ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", &_1, 435, &alias_zv); + ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", &_1, 447, &alias_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$4, "phalcon/Container/Container.zep", 652); ZEPHIR_MM_RESTORE(); @@ -1521,12 +1521,12 @@ PHP_METHOD(Phalcon_Container_Container, detectCircularAlias) if (zephir_array_key_exists(&seen, ¤t)) { break; } - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 507, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 516, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_key_exists(&_2$$3, ¤t))) { break; } zephir_array_update_zval(&seen, ¤t, &__$true, PH_COPY | PH_SEPARATE); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 507, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 516, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_4$$3, &_3$$3, ¤t, PH_NOISY | PH_READONLY, "phalcon/Container/Container.zep", 664); ZEPHIR_CPY_WRT(¤t, &_4$$3); } @@ -1567,7 +1567,7 @@ PHP_METHOD(Phalcon_Container_Container, findProcessor) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &definition); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 503, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 512, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "phalcon/Container/Container.zep", 686); if (Z_TYPE_P(&_0) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1) @@ -1608,7 +1608,7 @@ PHP_METHOD(Phalcon_Container_Container, findProcessor) ZEPHIR_INIT_NVAR(&processor); ZEPHIR_INIT_VAR(&_6); object_init_ex(&_6, phalcon_container_exceptions_noprocessorfound_ce); - ZEPHIR_CALL_METHOD(NULL, &_6, "__construct", NULL, 436); + ZEPHIR_CALL_METHOD(NULL, &_6, "__construct", NULL, 448); zephir_check_call_status(); zephir_throw_exception_debug(&_6, "phalcon/Container/Container.zep", 686); ZEPHIR_MM_RESTORE(); @@ -1660,9 +1660,9 @@ PHP_METHOD(Phalcon_Container_Container, resolve) cache_param = ZEND_CALL_ARG(execute_data, 2); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 505, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 514, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_key_exists(&_0, &name_zv))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 509, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 518, PH_NOISY_CC | PH_READONLY); _2$$3 = zephir_is_true(&_1$$3); if (_2$$3) { _2$$3 = zephir_class_exists(&name_zv, 1); @@ -1673,14 +1673,14 @@ PHP_METHOD(Phalcon_Container_Container, resolve) } else { ZEPHIR_INIT_VAR(&_3$$5); object_init_ex(&_3$$5, phalcon_container_exceptions_servicenotfound_ce); - ZEPHIR_CALL_METHOD(NULL, &_3$$5, "__construct", NULL, 426, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_3$$5, "__construct", NULL, 438, &name_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_3$$5, "phalcon/Container/Container.zep", 707); ZEPHIR_MM_RESTORE(); return; } } - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 505, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 514, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&definition); zephir_array_fetch(&definition, &_4, &name_zv, PH_NOISY, "phalcon/Container/Container.zep", 711); ZEPHIR_CALL_METHOD(NULL, &definition, "freeze", NULL, 0, this_ptr); @@ -1745,21 +1745,21 @@ PHP_METHOD(Phalcon_Container_Container, resolveAlias) array_init(&seen); ZEPHIR_CPY_WRT(¤t, &name_zv); while (1) { - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 507, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 516, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_key_exists(&_0, ¤t))) { break; } if (zephir_array_key_exists(&seen, ¤t)) { ZEPHIR_INIT_NVAR(&_1$$4); object_init_ex(&_1$$4, phalcon_container_exceptions_circularaliasfound_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", &_2, 435, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", &_2, 447, &name_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$4, "phalcon/Container/Container.zep", 747); ZEPHIR_MM_RESTORE(); return; } zephir_array_update_zval(&seen, ¤t, &__$true, PH_COPY | PH_SEPARATE); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 507, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 516, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_4$$3, &_3$$3, ¤t, PH_NOISY | PH_READONLY, "phalcon/Container/Container.zep", 751); ZEPHIR_CPY_WRT(¤t, &_4$$3); } @@ -1798,7 +1798,7 @@ PHP_METHOD(Phalcon_Container_Container, resolveParameter) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 506, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 515, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&value); zephir_array_fetch(&value, &_0, &name_zv, PH_NOISY, "phalcon/Container/Container.zep", 768); _1 = Z_TYPE_P(&value) == IS_OBJECT; diff --git a/ext/phalcon/container/containerfactory.zep.c b/ext/phalcon/container/containerfactory.zep.c index d00c83c890..e91e6a5581 100644 --- a/ext/phalcon/container/containerfactory.zep.c +++ b/ext/phalcon/container/containerfactory.zep.c @@ -107,9 +107,9 @@ PHP_METHOD(Phalcon_Container_ContainerFactory, newContainer) ZEPHIR_INIT_VAR(&container); object_init_ex(&container, phalcon_container_container_ce); - ZEPHIR_CALL_METHOD(NULL, &container, "__construct", NULL, 437); + ZEPHIR_CALL_METHOD(NULL, &container, "__construct", NULL, 213); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 511, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 520, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "phalcon/Container/ContainerFactory.zep", 72); if (Z_TYPE_P(&_0) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1) diff --git a/ext/phalcon/container/definition/processor/closureprocessor.zep.c b/ext/phalcon/container/definition/processor/closureprocessor.zep.c index a74242e196..cc93aa43b9 100644 --- a/ext/phalcon/container/definition/processor/closureprocessor.zep.c +++ b/ext/phalcon/container/definition/processor/closureprocessor.zep.c @@ -109,9 +109,9 @@ PHP_METHOD(Phalcon_Container_Definition_Processor_ClosureProcessor, process) object_init_ex(&def, phalcon_container_definition_servicedefinition_ce); ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "closure"); - ZEPHIR_CALL_METHOD(NULL, &def, "__construct", NULL, 432, &name_zv, &_0, definition); + ZEPHIR_CALL_METHOD(NULL, &def, "__construct", NULL, 444, &name_zv, &_0, definition); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &def, "setfactory", NULL, 438, definition); + ZEPHIR_CALL_METHOD(NULL, &def, "setfactory", NULL, 449, definition); zephir_check_call_status(); RETURN_CCTOR(&def); } diff --git a/ext/phalcon/container/definition/processor/objectprocessor.zep.c b/ext/phalcon/container/definition/processor/objectprocessor.zep.c index df15bb9180..903935461d 100644 --- a/ext/phalcon/container/definition/processor/objectprocessor.zep.c +++ b/ext/phalcon/container/definition/processor/objectprocessor.zep.c @@ -114,13 +114,13 @@ PHP_METHOD(Phalcon_Container_Definition_Processor_ObjectProcessor, process) object_init_ex(&def, phalcon_container_definition_servicedefinition_ce); ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "object"); - ZEPHIR_CALL_METHOD(NULL, &def, "__construct", NULL, 432, &name_zv, &_0, definition); + ZEPHIR_CALL_METHOD(NULL, &def, "__construct", NULL, 444, &name_zv, &_0, definition); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_9__closure_ce, SL("__invoke")); - zephir_update_static_property_ce(phalcon_9__closure_ce, ZEND_STRL("definition"), definition); - ZEPHIR_CALL_METHOD(NULL, &def, "setfactory", NULL, 438, &_0); + zephir_create_closure_ex(&_0, NULL, phalcon_11__closure_ce, SL("__invoke")); + zephir_update_static_property_ce(phalcon_11__closure_ce, ZEND_STRL("definition"), definition); + ZEPHIR_CALL_METHOD(NULL, &def, "setfactory", NULL, 449, &_0); zephir_check_call_status(); RETURN_CCTOR(&def); } diff --git a/ext/phalcon/container/definition/processor/parameterprocessor.zep.c b/ext/phalcon/container/definition/processor/parameterprocessor.zep.c index ef605bd558..6652869c60 100644 --- a/ext/phalcon/container/definition/processor/parameterprocessor.zep.c +++ b/ext/phalcon/container/definition/processor/parameterprocessor.zep.c @@ -111,7 +111,7 @@ PHP_METHOD(Phalcon_Container_Definition_Processor_ParameterProcessor, process) object_init_ex(&def, phalcon_container_definition_servicedefinition_ce); ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "parameter"); - ZEPHIR_CALL_METHOD(NULL, &def, "__construct", NULL, 432, &name_zv, &_0, definition); + ZEPHIR_CALL_METHOD(NULL, &def, "__construct", NULL, 444, &name_zv, &_0, definition); zephir_check_call_status(); _1 = !((zephir_is_instance_of(definition, SL("Closure")))); if (_1) { @@ -123,7 +123,7 @@ PHP_METHOD(Phalcon_Container_Definition_Processor_ParameterProcessor, process) } else { ZVAL_BOOL(&_2, 0); } - ZEPHIR_CALL_METHOD(NULL, &def, "setiscacheable", NULL, 439, &_2); + ZEPHIR_CALL_METHOD(NULL, &def, "setiscacheable", NULL, 450, &_2); zephir_check_call_status(); RETURN_CCTOR(&def); } diff --git a/ext/phalcon/container/definition/processor/stringprocessor.zep.c b/ext/phalcon/container/definition/processor/stringprocessor.zep.c index 484c3eaba8..7501cc1efb 100644 --- a/ext/phalcon/container/definition/processor/stringprocessor.zep.c +++ b/ext/phalcon/container/definition/processor/stringprocessor.zep.c @@ -114,12 +114,12 @@ PHP_METHOD(Phalcon_Container_Definition_Processor_StringProcessor, process) object_init_ex(&def, phalcon_container_definition_servicedefinition_ce); ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "string"); - ZEPHIR_CALL_METHOD(NULL, &def, "__construct", NULL, 432, &name_zv, &_0, definition); + ZEPHIR_CALL_METHOD(NULL, &def, "__construct", NULL, 444, &name_zv, &_0, definition); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &def, "setclass", NULL, 440, definition); + ZEPHIR_CALL_METHOD(NULL, &def, "setclass", NULL, 451, definition); zephir_check_call_status(); ZVAL_BOOL(&_1, 1); - ZEPHIR_CALL_METHOD(NULL, &def, "setiscacheable", NULL, 439, &_1); + ZEPHIR_CALL_METHOD(NULL, &def, "setiscacheable", NULL, 450, &_1); zephir_check_call_status(); RETURN_CCTOR(&def); } diff --git a/ext/phalcon/container/definition/servicedefinition.zep.c b/ext/phalcon/container/definition/servicedefinition.zep.c index 2d3cfd2218..86a206c57f 100644 --- a/ext/phalcon/container/definition/servicedefinition.zep.c +++ b/ext/phalcon/container/definition/servicedefinition.zep.c @@ -150,9 +150,9 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, __construct) raw = &raw_sub; raw = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 512, &serviceName_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 513, &type_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 514, raw); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 521, &serviceName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 522, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 523, raw); } /** @@ -230,21 +230,21 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, addTag) ZVAL_STR_COPY(&tag_zv, tag); ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkfrozen", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 515, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 524, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_1, "in_array", NULL, 87, &tag_zv, &_0, &__$true); zephir_check_call_status(); if (!zephir_is_true(&_1)) { zephir_update_property_array_append(this_ptr, SL("tags"), &tag_zv); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 516, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 525, PH_NOISY_CC | PH_READONLY); _3 = Z_TYPE_P(&_2) != IS_NULL; if (_3) { - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 516, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 525, PH_NOISY_CC | PH_READONLY); _3 = (zephir_method_exists_ex(&_4, ZEND_STRL("settag")) == SUCCESS); } if (_3) { - zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_1, 516, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_2, 512, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_1, 525, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_2, 521, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_5$$4, "settag", NULL, 0, &tag_zv, &_6$$4); zephir_check_call_status(); } @@ -313,32 +313,32 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, buildService) ZEPHIR_CALL_METHOD(&_0, this_ptr, "hasfactory", NULL, 0); zephir_check_call_status(); if (zephir_is_true(&_0)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 517, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 526, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&factory, &_1$$3); ZEPHIR_CALL_ZVAL_FUNCTION(&instance, &factory, NULL, 0, container); zephir_check_call_status(); } else { ZEPHIR_INIT_VAR(&_2$$4); - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 518, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 527, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_3$$4) != IS_NULL) { ZEPHIR_OBS_NVAR(&_2$$4); - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 518, PH_NOISY_CC); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 527, PH_NOISY_CC); } else { ZEPHIR_OBS_NVAR(&_2$$4); - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 512, PH_NOISY_CC); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 521, PH_NOISY_CC); } ZEPHIR_CPY_WRT(&className, &_2$$4); - zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_3, 519, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(&args, this_ptr, "resolveargs", NULL, 441, container, &_4$$4); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_3, 528, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(&args, this_ptr, "resolveargs", NULL, 452, container, &_4$$4); zephir_check_call_status(); ZEPHIR_INIT_VAR(&reflection); object_init_ex(&reflection, zephir_get_internal_ce(SL("reflectionclass"))); - ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 233, &className); + ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 239, &className); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&instance, &reflection, "newinstanceargs", NULL, 442, &args); + ZEPHIR_CALL_METHOD(&instance, &reflection, "newinstanceargs", NULL, 453, &args); zephir_check_call_status(); } - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_4, 520, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_4, 529, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_5, 0, "phalcon/Container/Definition/ServiceDefinition.zep", 177); if (Z_TYPE_P(&_5) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_5), _6) @@ -441,11 +441,11 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, freeze) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &container); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 521, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 530, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 513, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 522, PH_NOISY_CC | PH_READONLY); _2 = ZEPHIR_IS_STRING_IDENTICAL(&_1, "string"); if (_2) { _2 = (zephir_method_exists_ex(container, ZEND_STRL("isautowireenabled")) == SUCCESS); @@ -458,20 +458,20 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, freeze) } if (_3) { ZEPHIR_INIT_VAR(&_8$$4); - zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_3, 518, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_3, 527, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_9$$4) != IS_NULL) { ZEPHIR_OBS_NVAR(&_8$$4); - zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_3, 518, PH_NOISY_CC); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_3, 527, PH_NOISY_CC); } else { ZEPHIR_OBS_NVAR(&_8$$4); - zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_4, 512, PH_NOISY_CC); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_4, 521, PH_NOISY_CC); } ZEPHIR_CPY_WRT(&className, &_8$$4); ZEPHIR_INIT_VAR(&reflection); object_init_ex(&reflection, zephir_get_internal_ce(SL("reflectionclass"))); - ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 233, &className); + ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 239, &className); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&constructor, &reflection, "getconstructor", NULL, 443); + ZEPHIR_CALL_METHOD(&constructor, &reflection, "getconstructor", NULL, 454); zephir_check_call_status(); if (Z_TYPE_P(&constructor) != IS_NULL) { ZEPHIR_CALL_METHOD(¶ms, &constructor, "getparameters", NULL, 0); @@ -483,28 +483,28 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, freeze) if ((zephir_method_exists_ex(container, ZEND_STRL("getresolver")) == SUCCESS)) { ZEPHIR_CALL_METHOD(&_10$$5, container, "getresolver", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_2, 522, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_2, 531, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_11$$5, &_10$$5, "resolveparameters", NULL, 0, container, ¶ms, &_12$$5); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 519, &_11$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 528, &_11$$5); } } else { - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 513, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 522, PH_NOISY_CC | PH_READONLY); _6 = ZEPHIR_IS_STRING_IDENTICAL(&_5, "string"); if (_6) { zephir_memory_observe(&_7); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 522, PH_NOISY_CC); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 531, PH_NOISY_CC); _6 = !(ZEPHIR_IS_EMPTY(&_7)); } if (_6) { - zephir_read_property_cached(&_13$$6, this_ptr, _zephir_prop_2, 522, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 519, &_13$$6); + zephir_read_property_cached(&_13$$6, this_ptr, _zephir_prop_2, 531, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 528, &_13$$6); } } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 521, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 530, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 521, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 530, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -547,12 +547,12 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, getClass) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 518, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 527, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_container_exceptions_noclassset_ce); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 512, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 444, &_2$$3); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 521, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 455, &_2$$3); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Container/Definition/ServiceDefinition.zep", 239); ZEPHIR_MM_RESTORE(); @@ -610,12 +610,12 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, getFactory) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 517, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 526, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_container_exceptions_nofactoryset_ce); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 512, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 445, &_2$$3); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 521, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 456, &_2$$3); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Container/Definition/ServiceDefinition.zep", 274); ZEPHIR_MM_RESTORE(); @@ -683,7 +683,7 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, hasClass) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("className", 9, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 518, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 527, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(Z_TYPE_P(&_0) != IS_NULL); } @@ -707,7 +707,7 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, hasExtenders) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 520, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 529, PH_NOISY_CC); RETURN_MM_BOOL(!(ZEPHIR_IS_EMPTY(&_0))); } @@ -726,7 +726,7 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, hasFactory) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("factory", 7, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 517, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 526, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(Z_TYPE_P(&_0) != IS_NULL); } @@ -751,10 +751,10 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, isCacheable) if (UNEXPECTED(!_zephir_prop_1)) { _zephir_prop_1 = zend_string_init("frozen", 6, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 523, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 532, PH_NOISY_CC | PH_READONLY); _1 = zephir_is_true(&_0); if (_1) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 521, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 530, PH_NOISY_CC | PH_READONLY); _1 = zephir_is_true(&_2); } RETURN_BOOL(_1); @@ -824,7 +824,7 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, setContainer) Z_PARAM_OBJECT(container) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &container); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 516, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 525, container); RETURN_THISW(); } @@ -859,7 +859,7 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, setClass) ZVAL_STR_COPY(&className_zv, className); ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkfrozen", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 518, &className_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 527, &className_zv); RETURN_THIS(); } @@ -928,9 +928,9 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, setExtenders) if (!(zephir_is_callable(&extender))) { ZEPHIR_INIT_NVAR(&_3$$4); object_init_ex(&_3$$4, phalcon_container_exceptions_invalidextender_ce); - zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_0, 512, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_0, 521, PH_NOISY_CC | PH_READONLY); zephir_cast_to_string(&_5$$4, &key); - ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", &_6, 446, &_4$$4, &_5$$4); + ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", &_6, 457, &_4$$4, &_5$$4); zephir_check_call_status(); zephir_throw_exception_debug(&_3$$4, "phalcon/Container/Definition/ServiceDefinition.zep", 434); ZEPHIR_MM_RESTORE(); @@ -960,9 +960,9 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, setExtenders) if (!(zephir_is_callable(&extender))) { ZEPHIR_INIT_NVAR(&_9$$6); object_init_ex(&_9$$6, phalcon_container_exceptions_invalidextender_ce); - zephir_read_property_cached(&_10$$6, this_ptr, _zephir_prop_0, 512, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$6, this_ptr, _zephir_prop_0, 521, PH_NOISY_CC | PH_READONLY); zephir_cast_to_string(&_11$$6, &key); - ZEPHIR_CALL_METHOD(NULL, &_9$$6, "__construct", &_6, 446, &_10$$6, &_11$$6); + ZEPHIR_CALL_METHOD(NULL, &_9$$6, "__construct", &_6, 457, &_10$$6, &_11$$6); zephir_check_call_status(); zephir_throw_exception_debug(&_9$$6, "phalcon/Container/Definition/ServiceDefinition.zep", 434); ZEPHIR_MM_RESTORE(); @@ -972,7 +972,7 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, setExtenders) } ZEPHIR_INIT_NVAR(&extender); ZEPHIR_INIT_NVAR(&key); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 520, &extenders); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 529, &extenders); RETURN_THIS(); } @@ -1005,7 +1005,7 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, setFactory) zephir_fetch_params(1, 1, 0, &factory); ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkfrozen", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 517, factory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 526, factory); RETURN_THIS(); } @@ -1040,9 +1040,9 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, setIsCacheable) ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkfrozen", NULL, 0); zephir_check_call_status(); if (isCacheable) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 523, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 532, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 523, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 532, &__$false); } RETURN_THIS(); } @@ -1078,7 +1078,7 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, setLifetime) ZVAL_STR_COPY(&lifetime_zv, lifetime); ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkfrozen", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 524, &lifetime_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 533, &lifetime_zv); RETURN_THIS(); } @@ -1105,7 +1105,7 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, unsetClass) ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkfrozen", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 518, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 527, &__$null); RETURN_THIS(); } @@ -1134,7 +1134,7 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, unsetExtenders) zephir_check_call_status(); ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 520, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 529, &_0); RETURN_THIS(); } @@ -1161,7 +1161,7 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, unsetFactory) ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkfrozen", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 517, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 526, &__$null); RETURN_THIS(); } @@ -1192,12 +1192,12 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, checkFrozen) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 521, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 530, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_container_exceptions_frozendefinition_ce); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 512, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 447, &_2$$3); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 521, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 458, &_2$$3); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Container/Definition/ServiceDefinition.zep", 541); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/container/provider/cli.zep.c b/ext/phalcon/container/provider/cli.zep.c index a7d65e7854..d3d435c0e0 100644 --- a/ext/phalcon/container/provider/cli.zep.c +++ b/ext/phalcon/container/provider/cli.zep.c @@ -115,7 +115,7 @@ PHP_METHOD(Phalcon_Container_Provider_Cli, provide) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_10__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_12__closure_ce, SL("__invoke")); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "Phalcon\\Filter\\FilterInterface"); ZEPHIR_CALL_METHOD(NULL, services, "set", NULL, 0, &_1, &_0); @@ -176,7 +176,7 @@ PHP_METHOD(Phalcon_Container_Provider_Cli, provide) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); - zephir_create_closure_ex(&_1, NULL, phalcon_11__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_1, NULL, phalcon_13__closure_ce, SL("__invoke")); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "Phalcon\\Auth\\Access\\AccessLocator"); ZEPHIR_CALL_METHOD(NULL, services, "set", NULL, 0, &_2, &_1); diff --git a/ext/phalcon/container/provider/web.zep.c b/ext/phalcon/container/provider/web.zep.c index 3a1b5ca8c4..5c0273d4b1 100644 --- a/ext/phalcon/container/provider/web.zep.c +++ b/ext/phalcon/container/provider/web.zep.c @@ -139,7 +139,7 @@ PHP_METHOD(Phalcon_Container_Provider_Web, provide) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_12__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_14__closure_ce, SL("__invoke")); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "Phalcon\\Filter\\FilterInterface"); ZEPHIR_CALL_METHOD(NULL, services, "set", NULL, 0, &_1, &_0); @@ -236,7 +236,7 @@ PHP_METHOD(Phalcon_Container_Provider_Web, provide) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); - zephir_create_closure_ex(&_1, NULL, phalcon_13__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_1, NULL, phalcon_15__closure_ce, SL("__invoke")); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "Phalcon\\Auth\\Access\\AccessLocator"); ZEPHIR_CALL_METHOD(NULL, services, "set", NULL, 0, &_2, &_1); diff --git a/ext/phalcon/container/resolver/lazy/arrayvalues.zep.c b/ext/phalcon/container/resolver/lazy/arrayvalues.zep.c index 041a975328..a5bd22ae67 100644 --- a/ext/phalcon/container/resolver/lazy/arrayvalues.zep.c +++ b/ext/phalcon/container/resolver/lazy/arrayvalues.zep.c @@ -93,7 +93,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_ArrayValues, __construct) } else { zephir_get_arrval(&values, values_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 525, &values); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 534, &values); ZEPHIR_MM_RESTORE(); } @@ -107,7 +107,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_ArrayValues, count) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("values", 6, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 525, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 534, PH_NOISY_CC | PH_READONLY); RETURN_LONG(zephir_fast_count_int(&_0)); } @@ -127,7 +127,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_ArrayValues, getIterator) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); object_init_ex(return_value, spl_ce_ArrayIterator); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 525, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 534, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 18, &_0); zephir_check_call_status(); RETURN_MM(); @@ -225,7 +225,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_ArrayValues, offsetExists) Z_PARAM_ZVAL(offset) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &offset); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 525, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 534, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_key_exists(&_0, offset)); } @@ -247,7 +247,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_ArrayValues, offsetGet) Z_PARAM_ZVAL(offset) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &offset); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 525, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 534, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_1, &_0, offset, PH_NOISY | PH_READONLY, "phalcon/Container/Resolver/Lazy/ArrayValues.zep", 88); RETURN_CTORW(&_1); } @@ -290,7 +290,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_ArrayValues, offsetUnset) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &offset); zephir_unset_property_array(this_ptr, ZEND_STRL("values"), offset); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 525, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 534, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_0, offset, PH_SEPARATE); } @@ -321,7 +321,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_ArrayValues, resolve) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &ioc); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 525, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 534, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "resolvevalues", NULL, 0, ioc, &_0); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/container/resolver/lazy/call.zep.c b/ext/phalcon/container/resolver/lazy/call.zep.c index 18d51ab275..c7af3c0129 100644 --- a/ext/phalcon/container/resolver/lazy/call.zep.c +++ b/ext/phalcon/container/resolver/lazy/call.zep.c @@ -74,7 +74,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_Call, __construct) Z_PARAM_ZVAL(callableObject) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &callableObject); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 526, callableObject); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 535, callableObject); } /** @@ -105,7 +105,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_Call, resolve) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &ioc); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 526, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 535, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&callableObject, &_0); ZEPHIR_RETURN_CALL_ZVAL_FUNCTION(&callableObject, NULL, 0, ioc); zephir_check_call_status(); diff --git a/ext/phalcon/container/resolver/lazy/callableget.zep.c b/ext/phalcon/container/resolver/lazy/callableget.zep.c index c882b9756b..30f781f79e 100644 --- a/ext/phalcon/container/resolver/lazy/callableget.zep.c +++ b/ext/phalcon/container/resolver/lazy/callableget.zep.c @@ -73,7 +73,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_CallableGet, __construct) Z_PARAM_ZVAL(id) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &id); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 527, id); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 536, id); } /** @@ -98,8 +98,8 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_CallableGet, resolve) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &ioc); ZEPHIR_INIT_VAR(&instance); - zephir_create_closure_ex(&instance, this_ptr, phalcon_14__closure_ce, SL("__invoke")); - zephir_update_static_property_ce(phalcon_14__closure_ce, ZEND_STRL("ioc"), ioc); + zephir_create_closure_ex(&instance, this_ptr, phalcon_16__closure_ce, SL("__invoke")); + zephir_update_static_property_ce(phalcon_16__closure_ce, ZEND_STRL("ioc"), ioc); RETURN_CCTOR(&instance); } diff --git a/ext/phalcon/container/resolver/lazy/callablenew.zep.c b/ext/phalcon/container/resolver/lazy/callablenew.zep.c index f6cb9a6c7d..f3385a0646 100644 --- a/ext/phalcon/container/resolver/lazy/callablenew.zep.c +++ b/ext/phalcon/container/resolver/lazy/callablenew.zep.c @@ -73,7 +73,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_CallableNew, __construct) Z_PARAM_ZVAL(id) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &id); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 528, id); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 537, id); } /** @@ -98,8 +98,8 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_CallableNew, resolve) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &ioc); ZEPHIR_INIT_VAR(&instance); - zephir_create_closure_ex(&instance, this_ptr, phalcon_15__closure_ce, SL("__invoke")); - zephir_update_static_property_ce(phalcon_15__closure_ce, ZEND_STRL("ioc"), ioc); + zephir_create_closure_ex(&instance, this_ptr, phalcon_17__closure_ce, SL("__invoke")); + zephir_update_static_property_ce(phalcon_17__closure_ce, ZEND_STRL("ioc"), ioc); RETURN_CCTOR(&instance); } diff --git a/ext/phalcon/container/resolver/lazy/csenv.zep.c b/ext/phalcon/container/resolver/lazy/csenv.zep.c index 4b68910e4e..db46f722b2 100644 --- a/ext/phalcon/container/resolver/lazy/csenv.zep.c +++ b/ext/phalcon/container/resolver/lazy/csenv.zep.c @@ -105,9 +105,9 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_CsEnv, resolve) ZVAL_STRING(&_2, "\""); ZEPHIR_INIT_VAR(&_3); ZVAL_STRING(&_3, "\\"); - ZEPHIR_CALL_FUNCTION(&values, "str_getcsv", NULL, 448, &_0, &_1, &_2, &_3); + ZEPHIR_CALL_FUNCTION(&values, "str_getcsv", NULL, 459, &_0, &_1, &_2, &_3); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 529, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 538, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_4) != IS_NULL) { ZEPHIR_INIT_VAR(&result); array_init(&result); @@ -123,7 +123,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_CsEnv, resolve) } ZEPHIR_INIT_NVAR(&value); ZVAL_COPY(&value, _5$$3); - zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 529, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 538, PH_NOISY_CC | PH_READONLY); ZEPHIR_MAKE_REF(&value); ZEPHIR_CALL_FUNCTION(NULL, "settype", &_9, 16, &value, &_8$$4); ZEPHIR_UNREF(&value); @@ -150,7 +150,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_CsEnv, resolve) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&value, &values, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_0, 529, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_0, 538, PH_NOISY_CC | PH_READONLY); ZEPHIR_MAKE_REF(&value); ZEPHIR_CALL_FUNCTION(NULL, "settype", &_9, 16, &value, &_12$$5); ZEPHIR_UNREF(&value); diff --git a/ext/phalcon/container/resolver/lazy/envdefault.zep.c b/ext/phalcon/container/resolver/lazy/envdefault.zep.c index a156ed4f53..95d38367f6 100644 --- a/ext/phalcon/container/resolver/lazy/envdefault.zep.c +++ b/ext/phalcon/container/resolver/lazy/envdefault.zep.c @@ -95,7 +95,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_EnvDefault, __construct) zephir_memory_observe(&vartype_zv); ZVAL_STR_COPY(&vartype_zv, vartype); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 530, defaultValue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 539, defaultValue); ZEPHIR_CALL_PARENT(NULL, phalcon_container_resolver_lazy_envdefault_ce, getThis(), "__construct", NULL, 0, &varname_zv, &vartype_zv); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/container/resolver/lazy/functioncall.zep.c b/ext/phalcon/container/resolver/lazy/functioncall.zep.c index 6713c55686..fbe841c82b 100644 --- a/ext/phalcon/container/resolver/lazy/functioncall.zep.c +++ b/ext/phalcon/container/resolver/lazy/functioncall.zep.c @@ -93,8 +93,8 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_FunctionCall, __construct) arguments_param = ZEND_CALL_ARG(execute_data, 2); ZVAL_STR(&functionName_zv, functionName); zephir_get_arrval(&arguments, arguments_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 531, &functionName_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 532, &arguments); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 540, &functionName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 541, &arguments); ZEPHIR_MM_RESTORE(); } @@ -131,10 +131,10 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_FunctionCall, resolve) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &ioc); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 532, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 541, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&arguments, this_ptr, "resolvearguments", NULL, 0, ioc, &_0); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 531, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 540, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_USER_FUNC_ARRAY(return_value, &_1, &arguments); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/container/resolver/lazy/get.zep.c b/ext/phalcon/container/resolver/lazy/get.zep.c index 4735c5fb6f..2c3dae1aab 100644 --- a/ext/phalcon/container/resolver/lazy/get.zep.c +++ b/ext/phalcon/container/resolver/lazy/get.zep.c @@ -74,7 +74,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_Get, __construct) Z_PARAM_ZVAL(id) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &id); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 533, id); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 542, id); } /** @@ -105,7 +105,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_Get, resolve) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &ioc); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 533, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 542, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&id, this_ptr, "resolveargument", NULL, 0, ioc, &_0); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(ioc, "get", NULL, 0, &id); diff --git a/ext/phalcon/container/resolver/lazy/getcall.zep.c b/ext/phalcon/container/resolver/lazy/getcall.zep.c index 5488ae5cf3..c610e85a58 100644 --- a/ext/phalcon/container/resolver/lazy/getcall.zep.c +++ b/ext/phalcon/container/resolver/lazy/getcall.zep.c @@ -106,9 +106,9 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_GetCall, __construct) arguments_param = ZEND_CALL_ARG(execute_data, 3); ZVAL_STR(&method_zv, method); zephir_get_arrval(&arguments, arguments_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 534, id); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 535, &method_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 536, &arguments); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 543, id); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 544, &method_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 545, &arguments); ZEPHIR_MM_RESTORE(); } @@ -154,10 +154,10 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_GetCall, resolve) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &ioc); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 534, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 543, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&id, this_ptr, "resolveargument", NULL, 0, ioc, &_0); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 536, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 545, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&arguments, this_ptr, "resolvearguments", NULL, 0, ioc, &_1); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&service, ioc, "get", NULL, 0, &id); @@ -166,7 +166,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_GetCall, resolve) zephir_create_array(&_2, 2, 0); zephir_array_fast_append(&_2, &service); zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 535, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 544, PH_NOISY_CC); zephir_array_fast_append(&_2, &_3); ZEPHIR_CALL_USER_FUNC_ARRAY(return_value, &_2, &arguments); zephir_check_call_status(); diff --git a/ext/phalcon/container/resolver/lazy/lazyfactory.zep.c b/ext/phalcon/container/resolver/lazy/lazyfactory.zep.c index c4862a6d27..488b2da64e 100644 --- a/ext/phalcon/container/resolver/lazy/lazyfactory.zep.c +++ b/ext/phalcon/container/resolver/lazy/lazyfactory.zep.c @@ -74,7 +74,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_LazyFactory, arrayValues) zephir_fetch_params(1, 1, 0, &values_param); zephir_get_arrval(&values, values_param); object_init_ex(return_value, phalcon_container_resolver_lazy_arrayvalues_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 449, &values); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 460, &values); zephir_check_call_status(); RETURN_MM(); } @@ -93,7 +93,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_LazyFactory, call) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &callableObject); object_init_ex(return_value, phalcon_container_resolver_lazy_call_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 450, callableObject); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 461, callableObject); zephir_check_call_status(); RETURN_MM(); } @@ -114,7 +114,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_LazyFactory, callableGet) zephir_memory_observe(&id_zv); ZVAL_STR_COPY(&id_zv, id); object_init_ex(return_value, phalcon_container_resolver_lazy_callableget_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 451, &id_zv); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 462, &id_zv); zephir_check_call_status(); RETURN_MM(); } @@ -135,7 +135,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_LazyFactory, callableNew) zephir_memory_observe(&id_zv); ZVAL_STR_COPY(&id_zv, id); object_init_ex(return_value, phalcon_container_resolver_lazy_callablenew_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 452, &id_zv); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 463, &id_zv); zephir_check_call_status(); RETURN_MM(); } @@ -166,7 +166,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_LazyFactory, csEnv) ZVAL_STR_COPY(&type_zv, type); } object_init_ex(return_value, phalcon_container_resolver_lazy_csenv_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 453, &name_zv, &type_zv); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 464, &name_zv, &type_zv); zephir_check_call_status(); RETURN_MM(); } @@ -197,7 +197,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_LazyFactory, env) ZVAL_STR_COPY(&type_zv, type); } object_init_ex(return_value, phalcon_container_resolver_lazy_env_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 453, &name_zv, &type_zv); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 464, &name_zv, &type_zv); zephir_check_call_status(); RETURN_MM(); } @@ -232,7 +232,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_LazyFactory, envDefault) ZVAL_STR_COPY(&type_zv, type); } object_init_ex(return_value, phalcon_container_resolver_lazy_envdefault_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 454, &name_zv, defaultValue, &type_zv); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 465, &name_zv, defaultValue, &type_zv); zephir_check_call_status(); RETURN_MM(); } @@ -264,7 +264,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_LazyFactory, functionCall) ZVAL_STR_COPY(&functionName_zv, functionName); zephir_get_arrval(&args, args_param); object_init_ex(return_value, phalcon_container_resolver_lazy_functioncall_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 455, &functionName_zv, &args); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 466, &functionName_zv, &args); zephir_check_call_status(); RETURN_MM(); } @@ -285,7 +285,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_LazyFactory, get) zephir_memory_observe(&id_zv); ZVAL_STR_COPY(&id_zv, id); object_init_ex(return_value, phalcon_container_resolver_lazy_get_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 456, &id_zv); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 467, &id_zv); zephir_check_call_status(); RETURN_MM(); } @@ -322,7 +322,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_LazyFactory, getCall) ZVAL_STR_COPY(&method_zv, method); zephir_get_arrval(&args, args_param); object_init_ex(return_value, phalcon_container_resolver_lazy_getcall_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 457, &id_zv, &method_zv, &args); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 468, &id_zv, &method_zv, &args); zephir_check_call_status(); RETURN_MM(); } @@ -359,7 +359,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_LazyFactory, newCall) ZVAL_STR_COPY(&method_zv, method); zephir_get_arrval(&args, args_param); object_init_ex(return_value, phalcon_container_resolver_lazy_newcall_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 458, &id_zv, &method_zv, &args); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 469, &id_zv, &method_zv, &args); zephir_check_call_status(); RETURN_MM(); } @@ -380,7 +380,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_LazyFactory, newInstance) zephir_memory_observe(&id_zv); ZVAL_STR_COPY(&id_zv, id); object_init_ex(return_value, phalcon_container_resolver_lazy_newinstance_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 459, &id_zv); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 470, &id_zv); zephir_check_call_status(); RETURN_MM(); } @@ -417,7 +417,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_LazyFactory, staticCall) ZVAL_STR_COPY(&method_zv, method); zephir_get_arrval(&args, args_param); object_init_ex(return_value, phalcon_container_resolver_lazy_staticcall_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 460, &className_zv, &method_zv, &args); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 471, &className_zv, &method_zv, &args); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/container/resolver/lazy/newcall.zep.c b/ext/phalcon/container/resolver/lazy/newcall.zep.c index 7fcbd5e53c..6ffd0a29fc 100644 --- a/ext/phalcon/container/resolver/lazy/newcall.zep.c +++ b/ext/phalcon/container/resolver/lazy/newcall.zep.c @@ -106,9 +106,9 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_NewCall, __construct) arguments_param = ZEND_CALL_ARG(execute_data, 3); ZVAL_STR(&method_zv, method); zephir_get_arrval(&arguments, arguments_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 537, id); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 538, &method_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 539, &arguments); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 546, id); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 547, &method_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 548, &arguments); ZEPHIR_MM_RESTORE(); } @@ -154,10 +154,10 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_NewCall, resolve) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &ioc); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 537, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 546, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&id, this_ptr, "resolveargument", NULL, 0, ioc, &_0); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 539, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 548, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&arguments, this_ptr, "resolvearguments", NULL, 0, ioc, &_1); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&service, ioc, "new", NULL, 0, &id); @@ -166,7 +166,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_NewCall, resolve) zephir_create_array(&_2, 2, 0); zephir_array_fast_append(&_2, &service); zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 538, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 547, PH_NOISY_CC); zephir_array_fast_append(&_2, &_3); ZEPHIR_CALL_USER_FUNC_ARRAY(return_value, &_2, &arguments); zephir_check_call_status(); diff --git a/ext/phalcon/container/resolver/lazy/newinstance.zep.c b/ext/phalcon/container/resolver/lazy/newinstance.zep.c index 2c65d5ada3..ad729b9abd 100644 --- a/ext/phalcon/container/resolver/lazy/newinstance.zep.c +++ b/ext/phalcon/container/resolver/lazy/newinstance.zep.c @@ -74,7 +74,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_NewInstance, __construct) Z_PARAM_ZVAL(id) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &id); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 540, id); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 549, id); } /** @@ -105,7 +105,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_NewInstance, resolve) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &ioc); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 540, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 549, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&id, this_ptr, "resolveargument", NULL, 0, ioc, &_0); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(ioc, "new", NULL, 0, &id); diff --git a/ext/phalcon/container/resolver/lazy/staticcall.zep.c b/ext/phalcon/container/resolver/lazy/staticcall.zep.c index 7cb29fa277..9b5d6afc3b 100644 --- a/ext/phalcon/container/resolver/lazy/staticcall.zep.c +++ b/ext/phalcon/container/resolver/lazy/staticcall.zep.c @@ -106,9 +106,9 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_StaticCall, __construct) arguments_param = ZEND_CALL_ARG(execute_data, 3); ZVAL_STR(&method_zv, method); zephir_get_arrval(&arguments, arguments_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 541, className); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 542, &method_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 543, &arguments); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 550, className); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 551, &method_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 552, &arguments); ZEPHIR_MM_RESTORE(); } @@ -153,17 +153,17 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_StaticCall, resolve) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &ioc); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 541, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 550, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&className, this_ptr, "resolveargument", NULL, 0, ioc, &_0); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 543, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 552, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&arguments, this_ptr, "resolvearguments", NULL, 0, ioc, &_1); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_2); zephir_create_array(&_2, 2, 0); zephir_array_fast_append(&_2, &className); zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 542, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 551, PH_NOISY_CC); zephir_array_fast_append(&_2, &_3); ZEPHIR_CALL_USER_FUNC_ARRAY(return_value, &_2, &arguments); zephir_check_call_status(); diff --git a/ext/phalcon/container/resolver/resolver.zep.c b/ext/phalcon/container/resolver/resolver.zep.c index f91983929e..be9553edf2 100644 --- a/ext/phalcon/container/resolver/resolver.zep.c +++ b/ext/phalcon/container/resolver/resolver.zep.c @@ -85,9 +85,9 @@ PHP_METHOD(Phalcon_Container_Resolver_Resolver, isResolvableClass) } ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, zephir_get_internal_ce(SL("reflectionclass"))); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 233, &className_zv); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 239, &className_zv); zephir_check_call_status(); - ZEPHIR_RETURN_CALL_METHOD(&_0, "isinstantiable", NULL, 461); + ZEPHIR_RETURN_CALL_METHOD(&_0, "isinstantiable", NULL, 472); zephir_check_call_status(); RETURN_MM(); } @@ -136,9 +136,9 @@ PHP_METHOD(Phalcon_Container_Resolver_Resolver, resolveCall) } ZEPHIR_INIT_VAR(&reflection); object_init_ex(&reflection, zephir_get_internal_ce(SL("reflectionfunction"))); - ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 230, &closure); + ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 236, &closure); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(¶ms, &reflection, "getparameters", NULL, 231); + ZEPHIR_CALL_METHOD(¶ms, &reflection, "getparameters", NULL, 237); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&resolved, this_ptr, "resolveparameters", NULL, 0, ioc, ¶ms, &arguments); zephir_check_call_status(); @@ -188,14 +188,14 @@ PHP_METHOD(Phalcon_Container_Resolver_Resolver, resolveClass) zephir_get_arrval(&arguments, arguments_param); ZEPHIR_INIT_VAR(&reflection); object_init_ex(&reflection, zephir_get_internal_ce(SL("reflectionclass"))); - ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 233, &className_zv); + ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 239, &className_zv); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&constructor, &reflection, "getconstructor", NULL, 443); + ZEPHIR_CALL_METHOD(&constructor, &reflection, "getconstructor", NULL, 454); zephir_check_call_status(); if (Z_TYPE_P(&constructor) == IS_NULL) { ZEPHIR_INIT_VAR(&_0$$3); array_init(&_0$$3); - ZEPHIR_RETURN_CALL_METHOD(&reflection, "newinstanceargs", NULL, 442, &_0$$3); + ZEPHIR_RETURN_CALL_METHOD(&reflection, "newinstanceargs", NULL, 453, &_0$$3); zephir_check_call_status(); RETURN_MM(); } @@ -203,7 +203,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Resolver, resolveClass) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&resolved, this_ptr, "resolveparameters", NULL, 0, ioc, ¶ms, &arguments); zephir_check_call_status(); - ZEPHIR_RETURN_CALL_METHOD(&reflection, "newinstanceargs", NULL, 442, &resolved); + ZEPHIR_RETURN_CALL_METHOD(&reflection, "newinstanceargs", NULL, 453, &resolved); zephir_check_call_status(); RETURN_MM(); } @@ -334,7 +334,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Resolver, resolveParameter) object_init_ex(&_6, phalcon_container_exceptions_cannotresolveparameter_ce); ZEPHIR_CALL_METHOD(&_7, parameter, "getname", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &_6, "__construct", NULL, 462, &_7, &declaringName); + ZEPHIR_CALL_METHOD(NULL, &_6, "__construct", NULL, 473, &_7, &declaringName); zephir_check_call_status(); zephir_throw_exception_debug(&_6, "phalcon/Container/Resolver/Resolver.zep", 183); ZEPHIR_MM_RESTORE(); @@ -399,14 +399,14 @@ PHP_METHOD(Phalcon_Container_Resolver_Resolver, resolveParameters) zephir_check_call_status(); if (zephir_array_key_exists(&arguments, &position)) { zephir_array_fetch(&_4$$4, &arguments, &position, PH_NOISY | PH_READONLY, "phalcon/Container/Resolver/Resolver.zep", 199); - ZEPHIR_CALL_METHOD(&_3$$4, this_ptr, "resolvearg", &_5, 463, ioc, &_4$$4); + ZEPHIR_CALL_METHOD(&_3$$4, this_ptr, "resolvearg", &_5, 474, ioc, &_4$$4); zephir_check_call_status(); zephir_array_update_zval(&resolved, &position, &_3$$4, PH_COPY | PH_SEPARATE); continue; } if (zephir_array_key_exists(&arguments, &name)) { zephir_array_fetch(&_7$$5, &arguments, &name, PH_NOISY | PH_READONLY, "phalcon/Container/Resolver/Resolver.zep", 204); - ZEPHIR_CALL_METHOD(&_6$$5, this_ptr, "resolvearg", &_5, 463, ioc, &_7$$5); + ZEPHIR_CALL_METHOD(&_6$$5, this_ptr, "resolvearg", &_5, 474, ioc, &_7$$5); zephir_check_call_status(); zephir_array_update_zval(&resolved, &position, &_6$$5, PH_COPY | PH_SEPARATE); continue; @@ -439,14 +439,14 @@ PHP_METHOD(Phalcon_Container_Resolver_Resolver, resolveParameters) zephir_check_call_status(); if (zephir_array_key_exists(&arguments, &position)) { zephir_array_fetch(&_13$$7, &arguments, &position, PH_NOISY | PH_READONLY, "phalcon/Container/Resolver/Resolver.zep", 199); - ZEPHIR_CALL_METHOD(&_12$$7, this_ptr, "resolvearg", &_5, 463, ioc, &_13$$7); + ZEPHIR_CALL_METHOD(&_12$$7, this_ptr, "resolvearg", &_5, 474, ioc, &_13$$7); zephir_check_call_status(); zephir_array_update_zval(&resolved, &position, &_12$$7, PH_COPY | PH_SEPARATE); continue; } if (zephir_array_key_exists(&arguments, &name)) { zephir_array_fetch(&_15$$8, &arguments, &name, PH_NOISY | PH_READONLY, "phalcon/Container/Resolver/Resolver.zep", 204); - ZEPHIR_CALL_METHOD(&_14$$8, this_ptr, "resolvearg", &_5, 463, ioc, &_15$$8); + ZEPHIR_CALL_METHOD(&_14$$8, this_ptr, "resolvearg", &_5, 474, ioc, &_15$$8); zephir_check_call_status(); zephir_array_update_zval(&resolved, &position, &_14$$8, PH_COPY | PH_SEPARATE); continue; diff --git a/ext/phalcon/contracts/adr/application.zep.c b/ext/phalcon/contracts/adr/application.zep.c new file mode 100644 index 0000000000..f745d11c3a --- /dev/null +++ b/ext/phalcon/contracts/adr/application.zep.c @@ -0,0 +1,37 @@ + +#ifdef HAVE_CONFIG_H +#include "../../../ext_config.h" +#endif + +#include +#include "../../../php_ext.h" +#include "../../../ext.h" + +#include + +#include "kernel/main.h" + + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ +/** + * Handles a request end to end: routes it, dispatches the Action and returns + * the response, routing any error through the error responder. + */ +ZEPHIR_INIT_CLASS(Phalcon_Contracts_ADR_Application) +{ + ZEPHIR_REGISTER_INTERFACE(Phalcon\\Contracts\\ADR, Application, phalcon, contracts_adr_application, phalcon_contracts_adr_application_method_entry); + + return SUCCESS; +} + +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Application, handle); diff --git a/ext/phalcon/contracts/adr/application.zep.h b/ext/phalcon/contracts/adr/application.zep.h new file mode 100644 index 0000000000..a9b2d884ec --- /dev/null +++ b/ext/phalcon/contracts/adr/application.zep.h @@ -0,0 +1,13 @@ + +extern zend_class_entry *phalcon_contracts_adr_application_ce; + +ZEPHIR_INIT_CLASS(Phalcon_Contracts_ADR_Application); + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_contracts_adr_application_handle, 0, 1, Phalcon\\Http\\ResponseInterface, 0) + ZEND_ARG_OBJ_INFO(0, request, Phalcon\\Contracts\\Http\\AttributeRequestInterface, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_contracts_adr_application_method_entry) { + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Application, handle, arginfo_phalcon_contracts_adr_application_handle) + PHP_FE_END +}; diff --git a/ext/phalcon/contracts/adr/emitter/emitter.zep.c b/ext/phalcon/contracts/adr/emitter/emitter.zep.c new file mode 100644 index 0000000000..4b1fa0c076 --- /dev/null +++ b/ext/phalcon/contracts/adr/emitter/emitter.zep.c @@ -0,0 +1,36 @@ + +#ifdef HAVE_CONFIG_H +#include "../../../../ext_config.h" +#endif + +#include +#include "../../../../php_ext.h" +#include "../../../../ext.h" + +#include + +#include "kernel/main.h" + + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ +/** + * Sends a response to the client. Called by the Kernel only. + */ +ZEPHIR_INIT_CLASS(Phalcon_Contracts_ADR_Emitter_Emitter) +{ + ZEPHIR_REGISTER_INTERFACE(Phalcon\\Contracts\\ADR\\Emitter, Emitter, phalcon, contracts_adr_emitter_emitter, phalcon_contracts_adr_emitter_emitter_method_entry); + + return SUCCESS; +} + +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Emitter_Emitter, emit); diff --git a/ext/phalcon/contracts/adr/emitter/emitter.zep.h b/ext/phalcon/contracts/adr/emitter/emitter.zep.h new file mode 100644 index 0000000000..95d14a4118 --- /dev/null +++ b/ext/phalcon/contracts/adr/emitter/emitter.zep.h @@ -0,0 +1,14 @@ + +extern zend_class_entry *phalcon_contracts_adr_emitter_emitter_ce; + +ZEPHIR_INIT_CLASS(Phalcon_Contracts_ADR_Emitter_Emitter); + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_contracts_adr_emitter_emitter_emit, 0, 1, IS_VOID, 0) + + ZEND_ARG_OBJ_INFO(0, response, Phalcon\\Http\\ResponseInterface, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_contracts_adr_emitter_emitter_method_entry) { + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Emitter_Emitter, emit, arginfo_phalcon_contracts_adr_emitter_emitter_emit) + PHP_FE_END +}; diff --git a/ext/phalcon/contracts/adr/kernel/kernel.zep.c b/ext/phalcon/contracts/adr/kernel/kernel.zep.c new file mode 100644 index 0000000000..90246aed56 --- /dev/null +++ b/ext/phalcon/contracts/adr/kernel/kernel.zep.c @@ -0,0 +1,37 @@ + +#ifdef HAVE_CONFIG_H +#include "../../../../ext_config.h" +#endif + +#include +#include "../../../../php_ext.h" +#include "../../../../ext.h" + +#include + +#include "kernel/main.h" + + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + * + * Based on the Action Domain Responder pattern + * @link https://pmjones.io/adr/ + */ +/** + * Boots the container, handles the incoming request and emits the response. + * Returns a process exit code. + */ +ZEPHIR_INIT_CLASS(Phalcon_Contracts_ADR_Kernel_Kernel) +{ + ZEPHIR_REGISTER_INTERFACE(Phalcon\\Contracts\\ADR\\Kernel, Kernel, phalcon, contracts_adr_kernel_kernel, phalcon_contracts_adr_kernel_kernel_method_entry); + + return SUCCESS; +} + +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Kernel_Kernel, run); diff --git a/ext/phalcon/contracts/adr/kernel/kernel.zep.h b/ext/phalcon/contracts/adr/kernel/kernel.zep.h new file mode 100644 index 0000000000..babbee24f3 --- /dev/null +++ b/ext/phalcon/contracts/adr/kernel/kernel.zep.h @@ -0,0 +1,12 @@ + +extern zend_class_entry *phalcon_contracts_adr_kernel_kernel_ce; + +ZEPHIR_INIT_CLASS(Phalcon_Contracts_ADR_Kernel_Kernel); + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_contracts_adr_kernel_kernel_run, 0, 0, IS_LONG, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_contracts_adr_kernel_kernel_method_entry) { + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Kernel_Kernel, run, arginfo_phalcon_contracts_adr_kernel_kernel_run) + PHP_FE_END +}; diff --git a/ext/phalcon/datamapper/pdo/connection.zep.c b/ext/phalcon/datamapper/pdo/connection.zep.c index 5fcb60644d..c1d92792cc 100644 --- a/ext/phalcon/datamapper/pdo/connection.zep.c +++ b/ext/phalcon/datamapper/pdo/connection.zep.c @@ -160,7 +160,7 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Connection, __construct) ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_datamapper_pdo_exception_drivernotsupported_ce); zephir_array_fetch_long(&_2$$3, &parts, 0, PH_NOISY | PH_READONLY, "phalcon/DataMapper/Pdo/Connection.zep", 66); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 464, &_2$$3); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 475, &_2$$3); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/DataMapper/Pdo/Connection.zep", 66); ZEPHIR_MM_RESTORE(); @@ -178,11 +178,11 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Connection, __construct) zephir_array_fast_append(&_4, &password_zv); zephir_array_fast_append(&_4, &options); zephir_array_fast_append(&_4, &queries); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 544, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 553, &_4); if (Z_TYPE_P(profiler) == IS_NULL) { ZEPHIR_INIT_NVAR(profiler); object_init_ex(profiler, phalcon_datamapper_pdo_profiler_profiler_ce); - ZEPHIR_CALL_METHOD(NULL, profiler, "__construct", NULL, 465); + ZEPHIR_CALL_METHOD(NULL, profiler, "__construct", NULL, 476); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(NULL, this_ptr, "setprofiler", NULL, 0, profiler); @@ -218,7 +218,7 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Connection, __debugInfo) zephir_create_array(return_value, 1, 0); ZEPHIR_INIT_VAR(&_0); zephir_create_array(&_0, 5, 0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 544, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 553, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2); zephir_array_fetch_long(&_2, &_1, 0, PH_NOISY, "phalcon/DataMapper/Pdo/Connection.zep", 100); zephir_array_fast_append(&_0, &_2); @@ -228,11 +228,11 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Connection, __debugInfo) ZEPHIR_INIT_NVAR(&_3); ZVAL_STRING(&_3, "****"); zephir_array_fast_append(&_0, &_3); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 544, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 553, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_2); zephir_array_fetch_long(&_2, &_4, 3, PH_NOISY, "phalcon/DataMapper/Pdo/Connection.zep", 103); zephir_array_fast_append(&_0, &_2); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 544, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 553, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_2); zephir_array_fetch_long(&_2, &_5, 4, PH_NOISY, "phalcon/DataMapper/Pdo/Connection.zep", 105); zephir_array_fast_append(&_0, &_2); @@ -283,34 +283,34 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Connection, connect) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 545, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 554, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 546, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 555, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2$$3); ZVAL_STRING(&_2$$3, "connect"); ZEPHIR_CALL_METHOD(NULL, &_1$$3, "start", NULL, 0, &_2$$3); zephir_check_call_status(); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 544, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 553, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&dsn); zephir_array_fetch_long(&dsn, &_3$$3, 0, PH_NOISY, "phalcon/DataMapper/Pdo/Connection.zep", 120); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 544, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 553, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&username); zephir_array_fetch_long(&username, &_4$$3, 1, PH_NOISY, "phalcon/DataMapper/Pdo/Connection.zep", 121); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 544, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 553, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&password); zephir_array_fetch_long(&password, &_5$$3, 2, PH_NOISY, "phalcon/DataMapper/Pdo/Connection.zep", 122); - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_2, 544, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_2, 553, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&options); zephir_array_fetch_long(&options, &_6$$3, 3, PH_NOISY, "phalcon/DataMapper/Pdo/Connection.zep", 123); - zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_2, 544, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_2, 553, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&queries); zephir_array_fetch_long(&queries, &_7$$3, 4, PH_NOISY, "phalcon/DataMapper/Pdo/Connection.zep", 124); ZEPHIR_INIT_NVAR(&_2$$3); object_init_ex(&_2$$3, php_pdo_get_dbh_ce()); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 0, &dsn, &username, &password, &options); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 545, &_2$$3); - zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_1, 546, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 554, &_2$$3); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_1, 555, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_8$$3, "finish", NULL, 0); zephir_check_call_status(); zephir_is_iterable(&queries, 0, "phalcon/DataMapper/Pdo/Connection.zep", 134); @@ -374,13 +374,13 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Connection, disconnect) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 546, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 555, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "disconnect"); ZEPHIR_CALL_METHOD(NULL, &_0, "start", NULL, 0, &_1); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 545, &__$null); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 546, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 554, &__$null); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 555, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_2, "finish", NULL, 0); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/datamapper/pdo/connection/decorated.zep.c b/ext/phalcon/datamapper/pdo/connection/decorated.zep.c index 043540e13d..6caa5ddd97 100644 --- a/ext/phalcon/datamapper/pdo/connection/decorated.zep.c +++ b/ext/phalcon/datamapper/pdo/connection/decorated.zep.c @@ -84,11 +84,11 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Connection_Decorated, __construct) } else { ZEPHIR_SEPARATE_PARAM(profiler); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 547, pdo); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 556, pdo); if (Z_TYPE_P(profiler) == IS_NULL) { ZEPHIR_INIT_NVAR(profiler); object_init_ex(profiler, phalcon_datamapper_pdo_profiler_profiler_ce); - ZEPHIR_CALL_METHOD(NULL, profiler, "__construct", NULL, 465); + ZEPHIR_CALL_METHOD(NULL, profiler, "__construct", NULL, 476); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(NULL, this_ptr, "setprofiler", NULL, 0, profiler); diff --git a/ext/phalcon/datamapper/pdo/connectionlocator.zep.c b/ext/phalcon/datamapper/pdo/connectionlocator.zep.c index 7feb60c376..232893f0c7 100644 --- a/ext/phalcon/datamapper/pdo/connectionlocator.zep.c +++ b/ext/phalcon/datamapper/pdo/connectionlocator.zep.c @@ -320,7 +320,7 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_ConnectionLocator, setMaster) Z_PARAM_OBJECT_OF_CLASS(callableObject, phalcon_datamapper_pdo_connection_connectioninterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &callableObject); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 548, callableObject); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 557, callableObject); RETURN_THISW(); } @@ -431,7 +431,7 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_ConnectionLocator, getConnection) zephir_memory_observe(&collection); zephir_read_property_zval(&collection, this_ptr, &type_zv, PH_NOISY_CC); ZEPHIR_CPY_WRT(&requested, &name_zv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 549, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 558, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&instances, &_0); if (ZEPHIR_IS_EMPTY(&collection)) { ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getmaster", NULL, 0); @@ -441,7 +441,7 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_ConnectionLocator, getConnection) ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, ""); if (ZEPHIR_IS_IDENTICAL(&_1, &requested)) { - ZEPHIR_CALL_FUNCTION(&requested, "array_rand", NULL, 466, &collection); + ZEPHIR_CALL_FUNCTION(&requested, "array_rand", NULL, 477, &collection); zephir_check_call_status(); } if (!(zephir_array_isset_value(&collection, &requested))) { @@ -463,7 +463,7 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_ConnectionLocator, getConnection) ZEPHIR_CALL_USER_FUNC(&_4$$6, &_5$$6); zephir_check_call_status(); zephir_array_update_zval(&instances, &instanceName, &_4$$6, PH_COPY | PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 549, &instances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 558, &instances); } zephir_array_fetch(&_6, &instances, &instanceName, PH_NOISY | PH_READONLY, "phalcon/DataMapper/Pdo/ConnectionLocator.zep", 221); RETURN_CTOR(&_6); diff --git a/ext/phalcon/datamapper/pdo/profiler/profiler.zep.c b/ext/phalcon/datamapper/pdo/profiler/profiler.zep.c index 16076192a6..b1760f2d8e 100644 --- a/ext/phalcon/datamapper/pdo/profiler/profiler.zep.c +++ b/ext/phalcon/datamapper/pdo/profiler/profiler.zep.c @@ -128,11 +128,11 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Profiler_Profiler, __construct) ZEPHIR_INIT_VAR(&_0); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "{method} ({duration}s): {statement} {backtrace}"); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 550, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 559, &_0); ZVAL_UNDEF(&_1); ZVAL_LONG(&_1, 7); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 551, &_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 552, logger); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 560, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 561, logger); ZEPHIR_INIT_NVAR(&_0); object_init_ex(&_0, phalcon_support_helper_json_encode_ce); if (zephir_has_constructor(&_0)) { @@ -140,7 +140,7 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Profiler_Profiler, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 553, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 562, &_0); ZEPHIR_MM_RESTORE(); } @@ -228,20 +228,20 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Profiler_Profiler, finish) } else { zephir_get_arrval(&values, values_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 554, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 563, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(zephir_is_true(&_0))) { ZEPHIR_INIT_VAR(&ex); object_init_ex(&ex, phalcon_datamapper_pdo_exception_exception_ce); ZEPHIR_CALL_METHOD(NULL, &ex, "__construct", NULL, 8); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&finish, "hrtime", NULL, 467, &__$true); + ZEPHIR_CALL_FUNCTION(&finish, "hrtime", NULL, 478, &__$true); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_1$$3, &ex, "gettraceasstring", NULL, 468); + ZEPHIR_CALL_METHOD(&_1$$3, &ex, "gettraceasstring", NULL, 479); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_2$$3); ZVAL_STRING(&_2$$3, "backtrace"); zephir_update_property_array(this_ptr, SL("context"), &_2$$3, &_1$$3); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_1, 555, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_1, 564, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_4$$3, &_3$$3, SL("start"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Pdo/Profiler/Profiler.zep", 91); ZEPHIR_INIT_VAR(&_5$$3); zephir_sub_function(&_5$$3, &finish, &_4$$3); @@ -259,22 +259,22 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Profiler_Profiler, finish) ZEPHIR_INIT_NVAR(&_5$$3); ZVAL_STRING(&_5$$3, ""); } else { - zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_2, 553, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_2, 562, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5$$3, &_9$$3, "__invoke", NULL, 0, &values); zephir_check_call_status(); } ZEPHIR_INIT_VAR(&_10$$3); ZVAL_STRING(&_10$$3, "values"); zephir_update_property_array(this_ptr, SL("context"), &_10$$3, &_5$$3); - zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_3, 552, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_12$$3, this_ptr, _zephir_prop_4, 551, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_13$$3, this_ptr, _zephir_prop_5, 550, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_14$$3, this_ptr, _zephir_prop_1, 555, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_3, 561, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$3, this_ptr, _zephir_prop_4, 560, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$3, this_ptr, _zephir_prop_5, 559, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$3, this_ptr, _zephir_prop_1, 564, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_11$$3, "log", NULL, 0, &_12$$3, &_13$$3, &_14$$3); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_15$$3); array_init(&_15$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 555, &_15$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 564, &_15$$3); } ZEPHIR_MM_RESTORE(); } @@ -323,7 +323,7 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Profiler_Profiler, getLogLevel) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 551, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 560, PH_NOISY_CC); zephir_cast_to_string(&_1, &_0); RETURN_CTOR(&_1); } @@ -364,9 +364,9 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Profiler_Profiler, setActive) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &active_param); if (active) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 554, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 563, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 554, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 563, &__$false); } RETURN_THISW(); } @@ -394,7 +394,7 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Profiler_Profiler, setLogFormat) Z_PARAM_STR(logFormat) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&logFormat_zv, logFormat); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 550, &logFormat_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 559, &logFormat_zv); RETURN_THISW(); } @@ -421,7 +421,7 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Profiler_Profiler, setLogLevel) Z_PARAM_STR(logLevel) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&logLevel_zv, logLevel); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 551, &logLevel_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 560, &logLevel_zv); RETURN_THISW(); } @@ -460,15 +460,15 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Profiler_Profiler, start) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&method_zv); ZVAL_STR_COPY(&method_zv, method); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 554, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 563, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(zephir_is_true(&_0))) { ZEPHIR_INIT_VAR(&_1$$3); zephir_create_array(&_1$$3, 2, 0); zephir_array_update_string(&_1$$3, SL("method"), &method_zv, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_FUNCTION(&_2$$3, "hrtime", NULL, 467, &__$true); + ZEPHIR_CALL_FUNCTION(&_2$$3, "hrtime", NULL, 478, &__$true); zephir_check_call_status(); zephir_array_update_string(&_1$$3, SL("start"), &_2$$3, PH_COPY | PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 555, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 564, &_1$$3); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/datamapper/query/bind.zep.c b/ext/phalcon/datamapper/query/bind.zep.c index 1d64c98bf7..8a14c8bbde 100644 --- a/ext/phalcon/datamapper/query/bind.zep.c +++ b/ext/phalcon/datamapper/query/bind.zep.c @@ -108,11 +108,11 @@ PHP_METHOD(Phalcon_DataMapper_Query_Bind, bindInline) zephir_check_call_status(); RETURN_MM(); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 556, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 565, PH_NOISY_CC | PH_READONLY); ZVAL_UNDEF(&_4); ZVAL_LONG(&_4, (zephir_get_numberval(&_3) + 1)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 556, &_4); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 556, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 565, &_4); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 565, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&key); ZEPHIR_CONCAT_SVS(&key, "__", &_4, "__"); ZVAL_LONG(&_5, type); @@ -149,10 +149,10 @@ PHP_METHOD(Phalcon_DataMapper_Query_Bind, remove) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 557, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 566, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&store, &_0); zephir_array_unset(&store, &key_zv, PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 557, &store); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 566, &store); ZEPHIR_MM_RESTORE(); } @@ -383,11 +383,11 @@ PHP_METHOD(Phalcon_DataMapper_Query_Bind, inlineArray) { ZEPHIR_INIT_NVAR(&value); ZVAL_COPY(&value, _0); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 556, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 565, PH_NOISY_CC | PH_READONLY); ZVAL_UNDEF(&_2$$3); ZVAL_LONG(&_2$$3, (zephir_get_numberval(&_1$$3) + 1)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 556, &_2$$3); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 556, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 565, &_2$$3); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 565, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&key); ZEPHIR_CONCAT_SVS(&key, "__", &_2$$3, "__"); ZVAL_LONG(&_3$$3, type); @@ -415,11 +415,11 @@ PHP_METHOD(Phalcon_DataMapper_Query_Bind, inlineArray) } ZEPHIR_CALL_METHOD(&value, &data, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 556, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 565, PH_NOISY_CC | PH_READONLY); ZVAL_UNDEF(&_9$$4); ZVAL_LONG(&_9$$4, (zephir_get_numberval(&_8$$4) + 1)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 556, &_9$$4); - zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 556, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 565, &_9$$4); + zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 565, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&key); ZEPHIR_CONCAT_SVS(&key, "__", &_9$$4, "__"); ZVAL_LONG(&_10$$4, type); diff --git a/ext/phalcon/datamapper/query/delete.zep.c b/ext/phalcon/datamapper/query/delete.zep.c index 7bd66d16db..0a353273e8 100644 --- a/ext/phalcon/datamapper/query/delete.zep.c +++ b/ext/phalcon/datamapper/query/delete.zep.c @@ -145,7 +145,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Delete, returning) zephir_fetch_params(1, 1, 0, &columns_param); zephir_get_arrval(&columns, columns_param); ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 558, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 567, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_2, &_1, SL("RETURNING"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Delete.zep", 63); zephir_fast_array_merge(&_0, &_2, &columns); ZEPHIR_INIT_VAR(&_3); @@ -179,7 +179,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Delete, getStatement) ZEPHIR_CALL_METHOD(&_0, this_ptr, "buildflags", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 558, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 567, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_2, &_1, SL("FROM"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Delete.zep", 78); ZEPHIR_INIT_VAR(&_4); ZVAL_STRING(&_4, "WHERE"); diff --git a/ext/phalcon/datamapper/query/insert.zep.c b/ext/phalcon/datamapper/query/insert.zep.c index a0afaeafd2..7da61353f7 100644 --- a/ext/phalcon/datamapper/query/insert.zep.c +++ b/ext/phalcon/datamapper/query/insert.zep.c @@ -141,7 +141,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Insert, column) ZEPHIR_CONCAT_SV(&_0, ":", &column_zv); zephir_update_property_array_multi(this_ptr, SL("store"), &_0, SL("sz"), 3, SL("COLUMNS"), &column_zv); if (Z_TYPE_P(value) != IS_NULL) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 559, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 568, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2$$3, type); ZEPHIR_CALL_METHOD(NULL, &_1$$3, "setvalue", NULL, 0, &column_zv, value, &_2$$3); zephir_check_call_status(); @@ -297,7 +297,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Insert, getLastInsertId) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 560, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 569, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "lastinsertid", NULL, 0, &name_zv); zephir_check_call_status(); RETURN_MM(); @@ -327,9 +327,9 @@ PHP_METHOD(Phalcon_DataMapper_Query_Insert, getStatement) ZEPHIR_CALL_METHOD(&_0, this_ptr, "buildflags", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 561, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 570, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_2, &_1, SL("FROM"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Insert.zep", 113); - ZEPHIR_CALL_METHOD(&_3, this_ptr, "buildcolumns", NULL, 469); + ZEPHIR_CALL_METHOD(&_3, this_ptr, "buildcolumns", NULL, 480); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_4, this_ptr, "buildreturning", NULL, 0); zephir_check_call_status(); @@ -369,7 +369,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Insert, returning) zephir_fetch_params(1, 1, 0, &columns_param); zephir_get_arrval(&columns, columns_param); ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 561, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 570, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_2, &_1, SL("RETURNING"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Insert.zep", 127); zephir_fast_array_merge(&_0, &_2, &columns); ZEPHIR_INIT_VAR(&_3); @@ -459,7 +459,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Insert, set) ZVAL_STRING(value, "NULL"); } zephir_update_property_array_multi(this_ptr, SL("store"), value, SL("sz"), 3, SL("COLUMNS"), &column_zv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 559, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 568, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "remove", NULL, 0, &column_zv); zephir_check_call_status(); RETURN_THIS(); @@ -507,7 +507,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Insert, buildColumns) ZEPHIR_INIT_VAR(&columns); array_init(&columns); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 561, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 570, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_1, &_0, SL("COLUMNS"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Insert.zep", 176); ZEPHIR_INIT_VAR(&_2); zephir_is_iterable(&_1, 0, "phalcon/DataMapper/Query/Insert.zep", 180); @@ -560,7 +560,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Insert, buildColumns) zephir_check_call_status(); zephir_fast_trim(&_11, &_12, NULL , ZEPHIR_TRIM_LEFT); ZEPHIR_INIT_NVAR(&_13); - zephir_read_property_cached(&_15, this_ptr, _zephir_prop_0, 561, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15, this_ptr, _zephir_prop_0, 570, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_16, &_15, SL("COLUMNS"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Insert.zep", 183); ZEPHIR_CALL_FUNCTION(&_17, "array_values", NULL, 27, &_16); zephir_check_call_status(); diff --git a/ext/phalcon/datamapper/query/queryfactory.zep.c b/ext/phalcon/datamapper/query/queryfactory.zep.c index 5cd7c9e62f..277d73a9ad 100644 --- a/ext/phalcon/datamapper/query/queryfactory.zep.c +++ b/ext/phalcon/datamapper/query/queryfactory.zep.c @@ -80,7 +80,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_QueryFactory, __construct) ZEPHIR_INIT_NVAR(&selectClass); ZVAL_STRING(&selectClass, "Phalcon\\DataMapper\\Query\\Select"); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 562, &selectClass); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 571, &selectClass); ZEPHIR_MM_RESTORE(); } @@ -130,7 +130,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_QueryFactory, newDelete) object_init_ex(return_value, phalcon_datamapper_query_delete_ce); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newbind", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 470, connection, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 481, connection, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -160,7 +160,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_QueryFactory, newInsert) object_init_ex(return_value, phalcon_datamapper_query_insert_ce); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newbind", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 471, connection, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 482, connection, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -197,7 +197,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_QueryFactory, newSelect) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &connection); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 562, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 571, PH_NOISY_CC | PH_READONLY); zephir_get_strval(&selectClass, &_0); zephir_fetch_safe_class(&_1, &selectClass); _2 = zephir_fetch_class_str_ex(Z_STRVAL_P(&_1), Z_STRLEN_P(&_1), ZEND_FETCH_CLASS_AUTO); @@ -242,7 +242,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_QueryFactory, newUpdate) object_init_ex(return_value, phalcon_datamapper_query_update_ce); ZEPHIR_CALL_METHOD(&_0, this_ptr, "newbind", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 472, connection, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 483, connection, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/datamapper/query/select.zep.c b/ext/phalcon/datamapper/query/select.zep.c index 1be9bf37f8..88ad3037a5 100644 --- a/ext/phalcon/datamapper/query/select.zep.c +++ b/ext/phalcon/datamapper/query/select.zep.c @@ -131,7 +131,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, __call) ZEPHIR_INIT_VAR(&_0$$3); zephir_create_array(&_0$$3, 2, 0); zephir_memory_observe(&_1$$3); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 563, PH_NOISY_CC); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 572, PH_NOISY_CC); zephir_array_fast_append(&_0$$3, &_1$$3); zephir_array_fast_append(&_0$$3, &method_zv); ZEPHIR_INIT_VAR(&_2$$3); @@ -150,7 +150,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, __call) } ZEPHIR_INIT_VAR(&_5); object_init_ex(&_5, phalcon_datamapper_pdo_exception_unknownquerymethod_ce); - ZEPHIR_CALL_METHOD(NULL, &_5, "__construct", NULL, 473, &method_zv); + ZEPHIR_CALL_METHOD(NULL, &_5, "__construct", NULL, 484, &method_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_5, "phalcon/DataMapper/Query/Select.zep", 94); ZEPHIR_MM_RESTORE(); @@ -232,7 +232,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, asAlias) Z_PARAM_STR(asAlias) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&asAlias_zv, asAlias); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 564, &asAlias_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 573, &asAlias_zv); RETURN_THISW(); } @@ -355,22 +355,22 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, appendJoin) } else { } if (!(ZEPHIR_IS_EMPTY(value))) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 565, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 574, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2$$3, type); ZEPHIR_CALL_METHOD(&_1$$3, &_0$$3, "bindinline", NULL, 0, value, &_2$$3); zephir_check_call_status(); zephir_concat_self(&condition, &_1$$3); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 566, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 575, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_4, &_3, SL("FROM"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Select.zep", 169); ZEPHIR_CALL_FUNCTION(&end, "array_key_last", NULL, 20, &_4); zephir_check_call_status(); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 566, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 575, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_6, &_5, SL("FROM"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Select.zep", 170); zephir_array_fetch(&_7, &_6, &end, PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Select.zep", 170); ZEPHIR_CALL_FUNCTION(&key, "array_key_last", NULL, 20, &_7); zephir_check_call_status(); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 566, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 575, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_9, &_8, SL("FROM"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Select.zep", 172); zephir_array_fetch(&_10, &_9, &end, PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Select.zep", 172); zephir_array_fetch(&_11, &_10, &key, PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Select.zep", 172); @@ -476,7 +476,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, columns) ZEPHIR_INIT_NVAR(&value); ZEPHIR_INIT_NVAR(&key); ZEPHIR_INIT_VAR(&_7); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 566, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 575, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_9, &_8, SL("COLUMNS"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Select.zep", 199); zephir_fast_array_merge(&_7, &_9, &localColumns); ZEPHIR_INIT_VAR(&_10); @@ -584,9 +584,9 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, forUpdate) } else { } if (enable) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 567, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 576, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 567, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 576, &__$false); } RETURN_THISW(); } @@ -615,7 +615,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, getStatement) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 566, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 575, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_2, &_1, SL("UNION"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Select.zep", 253); zephir_fast_join_str(&_0, SL(""), &_2); ZEPHIR_CALL_METHOD(&_3, this_ptr, "getcurrentstatement", NULL, 0); @@ -669,7 +669,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, hasColumns) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("store", 5, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 566, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 575, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_1, &_0, SL("COLUMNS"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Select.zep", 277); RETURN_BOOL(zephir_fast_count_int(&_1) > 0); } @@ -860,13 +860,13 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, join) ZEPHIR_CPY_WRT(&condition, &_15$$4); } if (!(ZEPHIR_IS_EMPTY(value))) { - zephir_read_property_cached(&_16$$5, this_ptr, _zephir_prop_0, 565, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$5, this_ptr, _zephir_prop_0, 574, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_18$$5, type); ZEPHIR_CALL_METHOD(&_17$$5, &_16$$5, "bindinline", NULL, 0, value, &_18$$5); zephir_check_call_status(); zephir_concat_self(&condition, &_17$$5); } - zephir_read_property_cached(&_19, this_ptr, _zephir_prop_1, 566, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19, this_ptr, _zephir_prop_1, 575, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_20, &_19, SL("FROM"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Select.zep", 338); ZEPHIR_CALL_FUNCTION(&key, "array_key_last", NULL, 20, &_20); zephir_check_call_status(); @@ -963,11 +963,11 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, reset) ZEPHIR_INIT_VAR(&_0); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 564, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 573, &_0); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 567, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 576, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 567, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 576, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -998,9 +998,9 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, subSelect) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); object_init_ex(return_value, phalcon_datamapper_query_select_ce); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 563, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 565, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 474, &_0, &_1); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 572, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 574, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 485, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -1118,7 +1118,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, getCurrentStatement) } ZEPHIR_INIT_VAR(&forUpdate); ZVAL_STRING(&forUpdate, ""); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 567, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 576, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_INIT_NVAR(&forUpdate); ZVAL_STRING(&forUpdate, " FOR UPDATE"); @@ -1127,9 +1127,9 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, getCurrentStatement) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_2, this_ptr, "buildlimitearly", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_3, this_ptr, "buildcolumns", NULL, 475); + ZEPHIR_CALL_METHOD(&_3, this_ptr, "buildcolumns", NULL, 486); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_4, this_ptr, "buildfrom", NULL, 476); + ZEPHIR_CALL_METHOD(&_4, this_ptr, "buildfrom", NULL, 487); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_6); ZVAL_STRING(&_6, "WHERE"); @@ -1151,11 +1151,11 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, getCurrentStatement) zephir_check_call_status(); ZEPHIR_INIT_VAR(&statement); ZEPHIR_CONCAT_SVVVVVVVVVV(&statement, "SELECT", &_1, &_2, &_3, &_4, &_5, &_7, &_8, &_9, &_10, &forUpdate); - zephir_read_property_cached(&_11, this_ptr, _zephir_prop_1, 564, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11, this_ptr, _zephir_prop_1, 573, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_12); ZVAL_STRING(&_12, ""); if (UNEXPECTED(!ZEPHIR_IS_IDENTICAL(&_12, &_11))) { - zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 564, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 573, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_14$$4); ZEPHIR_CONCAT_SVSV(&_14$$4, "(", &statement, ") AS ", &_13$$4); ZEPHIR_CPY_WRT(&statement, &_14$$4); @@ -1197,7 +1197,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, buildColumns) ZVAL_STRING(&_1$$3, "*"); zephir_array_fast_append(&columns, &_1$$3); } else { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 566, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 575, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&columns); zephir_array_fetch_string(&columns, &_2$$4, SL("COLUMNS"), PH_NOISY, "phalcon/DataMapper/Query/Select.zep", 460); } @@ -1247,12 +1247,12 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, buildFrom) ZEPHIR_INIT_VAR(&from); array_init(&from); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 566, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 575, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_1, &_0, SL("FROM"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Select.zep", 476); if (ZEPHIR_IS_EMPTY(&_1)) { RETURN_MM_STRING(""); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 566, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 575, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_3, &_2, SL("FROM"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Select.zep", 480); zephir_is_iterable(&_3, 0, "phalcon/DataMapper/Query/Select.zep", 484); if (Z_TYPE_P(&_3) == IS_ARRAY) { diff --git a/ext/phalcon/datamapper/query/update.zep.c b/ext/phalcon/datamapper/query/update.zep.c index ef41f05d6d..b26087c753 100644 --- a/ext/phalcon/datamapper/query/update.zep.c +++ b/ext/phalcon/datamapper/query/update.zep.c @@ -140,7 +140,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Update, column) ZEPHIR_CONCAT_SV(&_0, ":", &column_zv); zephir_update_property_array_multi(this_ptr, SL("store"), &_0, SL("sz"), 3, SL("COLUMNS"), &column_zv); if (Z_TYPE_P(value) != IS_NULL) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 568, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 577, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2$$3, type); ZEPHIR_CALL_METHOD(NULL, &_1$$3, "setvalue", NULL, 0, &column_zv, value, &_2$$3); zephir_check_call_status(); @@ -287,9 +287,9 @@ PHP_METHOD(Phalcon_DataMapper_Query_Update, getStatement) ZEPHIR_CALL_METHOD(&_0, this_ptr, "buildflags", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 569, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 578, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_2, &_1, SL("FROM"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Update.zep", 101); - ZEPHIR_CALL_METHOD(&_3, this_ptr, "buildcolumns", NULL, 477); + ZEPHIR_CALL_METHOD(&_3, this_ptr, "buildcolumns", NULL, 488); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_5); ZVAL_STRING(&_5, "WHERE"); @@ -317,7 +317,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Update, hasColumns) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("store", 5, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 569, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 578, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_1, &_0, SL("COLUMNS"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Update.zep", 113); RETURN_BOOL(zephir_fast_count_int(&_1) > 0); } @@ -354,7 +354,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Update, returning) zephir_fetch_params(1, 1, 0, &columns_param); zephir_get_arrval(&columns, columns_param); ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 569, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 578, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_2, &_1, SL("RETURNING"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Update.zep", 126); zephir_fast_array_merge(&_0, &_2, &columns); ZEPHIR_INIT_VAR(&_3); @@ -444,7 +444,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Update, set) ZVAL_STRING(value, "NULL"); } zephir_update_property_array_multi(this_ptr, SL("store"), value, SL("sz"), 3, SL("COLUMNS"), &column_zv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 568, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 577, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "remove", NULL, 0, &column_zv); zephir_check_call_status(); RETURN_THIS(); @@ -488,7 +488,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Update, buildColumns) ZEPHIR_INIT_VAR(&assignments); array_init(&assignments); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 569, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 578, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_1, &_0, SL("COLUMNS"), PH_NOISY | PH_READONLY, "phalcon/DataMapper/Query/Update.zep", 175); zephir_is_iterable(&_1, 0, "phalcon/DataMapper/Query/Update.zep", 179); if (Z_TYPE_P(&_1) == IS_ARRAY) { diff --git a/ext/phalcon/db/adapter/pdo/mysql.zep.c b/ext/phalcon/db/adapter/pdo/mysql.zep.c index a9d8e42943..e69a50bef4 100644 --- a/ext/phalcon/db/adapter/pdo/mysql.zep.c +++ b/ext/phalcon/db/adapter/pdo/mysql.zep.c @@ -100,7 +100,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, addForeignKey) ZVAL_STR_COPY(&tableName_zv, tableName); zephir_memory_observe(&schemaName_zv); ZVAL_STR_COPY(&schemaName_zv, schemaName); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 570, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 579, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "getforeignkeychecks", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&foreignKeyCheck, this_ptr, "prepare", NULL, 0, &_1); @@ -110,13 +110,13 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, addForeignKey) if (UNEXPECTED(!zephir_is_true(&_2))) { ZEPHIR_INIT_VAR(&_3$$3); object_init_ex(&_3$$3, phalcon_db_exceptions_missingforeignkeychecks_ce); - ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 478); + ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 489); zephir_check_call_status(); zephir_throw_exception_debug(&_3$$3, "phalcon/Db/Adapter/Pdo/Mysql.zep", 65); ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 570, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 579, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5, &_4, "addforeignkey", NULL, 0, &tableName_zv, &schemaName_zv, reference); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "execute", NULL, 0, &_5); @@ -319,7 +319,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeColumns) ZVAL_STRING(&sizePattern, "#\\(([0-9]+)(?:,\\s*([0-9]+))*\\)#"); ZEPHIR_INIT_VAR(&columns); array_init(&columns); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 570, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 579, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "describecolumns", NULL, 0, &table_zv, &schema_zv); zephir_check_call_status(); ZVAL_LONG(&_2, 3); @@ -696,7 +696,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeColumns) zephir_array_fetch_long(&columnName, &field, 0, PH_NOISY | PH_READONLY, "phalcon/Db/Adapter/Pdo/Mysql.zep", 550); ZEPHIR_INIT_NVAR(&_71$$3); object_init_ex(&_71$$3, phalcon_db_column_ce); - ZEPHIR_CALL_METHOD(NULL, &_71$$3, "__construct", &_72, 479, &columnName, &definition); + ZEPHIR_CALL_METHOD(NULL, &_71$$3, "__construct", &_72, 490, &columnName, &definition); zephir_check_call_status(); zephir_array_append(&columns, &_71$$3, PH_SEPARATE, "phalcon/Db/Adapter/Pdo/Mysql.zep", 551); ZEPHIR_CPY_WRT(&oldColumn, &columnName); @@ -1086,7 +1086,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeColumns) zephir_array_fetch_long(&columnName, &field, 0, PH_NOISY, "phalcon/Db/Adapter/Pdo/Mysql.zep", 550); ZEPHIR_INIT_NVAR(&_143$$62); object_init_ex(&_143$$62, phalcon_db_column_ce); - ZEPHIR_CALL_METHOD(NULL, &_143$$62, "__construct", &_72, 479, &columnName, &definition); + ZEPHIR_CALL_METHOD(NULL, &_143$$62, "__construct", &_72, 490, &columnName, &definition); zephir_check_call_status(); zephir_array_append(&columns, &_143$$62, PH_SEPARATE, "phalcon/Db/Adapter/Pdo/Mysql.zep", 551); ZEPHIR_CPY_WRT(&oldColumn, &columnName); @@ -1198,7 +1198,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeIndexes) } ZEPHIR_INIT_VAR(&indexes); array_init(&indexes); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 570, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 579, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "describeindexes", NULL, 0, &table_zv, &schema_zv); zephir_check_call_status(); ZVAL_LONG(&_3, 2); @@ -1561,7 +1561,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeReferences) } ZEPHIR_INIT_VAR(&references); array_init(&references); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 570, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 579, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "describereferences", NULL, 0, &table_zv, &schema_zv); zephir_check_call_status(); ZVAL_LONG(&_3, 3); diff --git a/ext/phalcon/db/adapter/pdo/postgresql.zep.c b/ext/phalcon/db/adapter/pdo/postgresql.zep.c index 15e1c3a5e7..0cc2e20d49 100644 --- a/ext/phalcon/db/adapter/pdo/postgresql.zep.c +++ b/ext/phalcon/db/adapter/pdo/postgresql.zep.c @@ -131,7 +131,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, connect) zephir_get_arrval(&descriptor, descriptor_param); } if (ZEPHIR_IS_EMPTY(&descriptor)) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 571, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 580, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&descriptor, &_0$$3); } zephir_memory_observe(&schema); @@ -229,7 +229,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, createTable) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 572, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 581, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&sql, &_2, "createtable", NULL, 0, &tableName_zv, &schemaName_zv, &definition); zephir_check_call_status(); ZEPHIR_INIT_VAR(&queries); @@ -480,7 +480,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, describeColumns) ZVAL_NULL(&oldColumn); ZEPHIR_INIT_VAR(&columns); array_init(&columns); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 572, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 581, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "describecolumns", NULL, 0, &table_zv, &schema_zv); zephir_check_call_status(); ZVAL_LONG(&_2, 3); @@ -859,7 +859,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, describeColumns) zephir_array_fetch_long(&columnName, &field, 0, PH_NOISY | PH_READONLY, "phalcon/Db/Adapter/Pdo/Postgresql.zep", 624); ZEPHIR_INIT_NVAR(&_73$$3); object_init_ex(&_73$$3, phalcon_db_column_ce); - ZEPHIR_CALL_METHOD(NULL, &_73$$3, "__construct", &_74, 479, &columnName, &definition); + ZEPHIR_CALL_METHOD(NULL, &_73$$3, "__construct", &_74, 490, &columnName, &definition); zephir_check_call_status(); zephir_array_append(&columns, &_73$$3, PH_SEPARATE, "phalcon/Db/Adapter/Pdo/Postgresql.zep", 625); ZEPHIR_CPY_WRT(&oldColumn, &columnName); @@ -1251,7 +1251,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, describeColumns) zephir_array_fetch_long(&columnName, &field, 0, PH_NOISY, "phalcon/Db/Adapter/Pdo/Postgresql.zep", 624); ZEPHIR_INIT_NVAR(&_145$$57); object_init_ex(&_145$$57, phalcon_db_column_ce); - ZEPHIR_CALL_METHOD(NULL, &_145$$57, "__construct", &_74, 479, &columnName, &definition); + ZEPHIR_CALL_METHOD(NULL, &_145$$57, "__construct", &_74, 490, &columnName, &definition); zephir_check_call_status(); zephir_array_append(&columns, &_145$$57, PH_SEPARATE, "phalcon/Db/Adapter/Pdo/Postgresql.zep", 625); ZEPHIR_CPY_WRT(&oldColumn, &columnName); @@ -1345,7 +1345,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, describeReferences) } ZEPHIR_INIT_VAR(&references); array_init(&references); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 572, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 581, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "describereferences", NULL, 0, &table_zv, &schema_zv); zephir_check_call_status(); ZVAL_LONG(&_3, 3); @@ -1610,7 +1610,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, modifyColumn) currentColumn = ¤tColumn_sub; currentColumn = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 572, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 581, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&sql, &_0, "modifycolumn", NULL, 0, &tableName_zv, &schemaName_zv, column, currentColumn); zephir_check_call_status(); ZEPHIR_INIT_VAR(&queries); diff --git a/ext/phalcon/db/adapter/pdo/sqlite.zep.c b/ext/phalcon/db/adapter/pdo/sqlite.zep.c index e30b2b0eae..71092ebaaa 100644 --- a/ext/phalcon/db/adapter/pdo/sqlite.zep.c +++ b/ext/phalcon/db/adapter/pdo/sqlite.zep.c @@ -123,7 +123,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, connect) zephir_get_arrval(&descriptor, descriptor_param); } if (ZEPHIR_IS_EMPTY(&descriptor)) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 573, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 582, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&descriptor, &_0$$3); } zephir_memory_observe(&dbname); @@ -133,7 +133,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, connect) } else if (UNEXPECTED(!(zephir_array_isset_value_string(&descriptor, SL("dsn"))))) { ZEPHIR_INIT_VAR(&_1$$5); object_init_ex(&_1$$5, phalcon_db_exceptions_missingsqlitedatabase_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$5, "__construct", NULL, 480); + ZEPHIR_CALL_METHOD(NULL, &_1$$5, "__construct", NULL, 491); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$5, "phalcon/Db/Adapter/Pdo/Sqlite.zep", 81); ZEPHIR_MM_RESTORE(); @@ -286,7 +286,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeColumns) ZVAL_STRING(&sizePattern, "#\\(([0-9]+)(?:,\\s*([0-9]+))*\\)#"); ZEPHIR_INIT_VAR(&columns); array_init(&columns); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 574, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 583, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "describecolumns", NULL, 0, &table_zv, &schema_zv); zephir_check_call_status(); ZVAL_LONG(&_2, 3); @@ -471,7 +471,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeColumns) zephir_array_fetch_long(&columnName, &field, 1, PH_NOISY | PH_READONLY, "phalcon/Db/Adapter/Pdo/Sqlite.zep", 330); ZEPHIR_INIT_NVAR(&_4$$3); object_init_ex(&_4$$3, phalcon_db_column_ce); - ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", &_46, 479, &columnName, &definition); + ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", &_46, 490, &columnName, &definition); zephir_check_call_status(); zephir_array_append(&columns, &_4$$3, PH_SEPARATE, "phalcon/Db/Adapter/Pdo/Sqlite.zep", 331); ZEPHIR_CPY_WRT(&oldColumn, &columnName); @@ -669,7 +669,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeColumns) zephir_array_fetch_long(&columnName, &field, 1, PH_NOISY, "phalcon/Db/Adapter/Pdo/Sqlite.zep", 330); ZEPHIR_INIT_NVAR(&_50$$32); object_init_ex(&_50$$32, phalcon_db_column_ce); - ZEPHIR_CALL_METHOD(NULL, &_50$$32, "__construct", &_46, 479, &columnName, &definition); + ZEPHIR_CALL_METHOD(NULL, &_50$$32, "__construct", &_46, 490, &columnName, &definition); zephir_check_call_status(); zephir_array_append(&columns, &_50$$32, PH_SEPARATE, "phalcon/Db/Adapter/Pdo/Sqlite.zep", 331); ZEPHIR_CPY_WRT(&oldColumn, &columnName); @@ -777,7 +777,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeIndexes) } ZEPHIR_INIT_VAR(&indexes); array_init(&indexes); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 574, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 583, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "describeindexes", NULL, 0, &table_zv, &schema_zv); zephir_check_call_status(); ZVAL_LONG(&_3, 2); @@ -805,7 +805,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeIndexes) ZEPHIR_OBS_NVAR(&columns); zephir_array_fetch_string(&columns, &_7$$6, SL("columns"), PH_NOISY, "phalcon/Db/Adapter/Pdo/Sqlite.zep", 364); } - zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 574, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 583, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_9$$3, &_8$$3, "describeindex", NULL, 0, &keyName); zephir_check_call_status(); ZVAL_LONG(&_10$$3, 2); @@ -844,7 +844,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeIndexes) } ZEPHIR_INIT_NVAR(&describeIndex); zephir_array_update_multi(&indexes, &columns, SL("zs"), 3, &keyName, SL("columns")); - zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 574, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 583, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_16$$3, &_10$$3, "listindexessql", NULL, 0, &table_zv, &schema_zv, &keyName); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&indexSql, this_ptr, "fetchcolumn", &_17, 0, &_16$$3); @@ -907,7 +907,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeIndexes) ZEPHIR_OBS_NVAR(&columns); zephir_array_fetch_string(&columns, &_30$$16, SL("columns"), PH_NOISY, "phalcon/Db/Adapter/Pdo/Sqlite.zep", 364); } - zephir_read_property_cached(&_31$$13, this_ptr, _zephir_prop_0, 574, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_31$$13, this_ptr, _zephir_prop_0, 583, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_32$$13, &_31$$13, "describeindex", NULL, 0, &keyName); zephir_check_call_status(); ZVAL_LONG(&_33$$13, 2); @@ -946,7 +946,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeIndexes) } ZEPHIR_INIT_NVAR(&describeIndex); zephir_array_update_multi(&indexes, &columns, SL("zs"), 3, &keyName, SL("columns")); - zephir_read_property_cached(&_33$$13, this_ptr, _zephir_prop_0, 574, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_33$$13, this_ptr, _zephir_prop_0, 583, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_39$$13, &_33$$13, "listindexessql", NULL, 0, &table_zv, &schema_zv, &keyName); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&indexSql, this_ptr, "fetchcolumn", &_17, 0, &_39$$13); @@ -1076,7 +1076,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeReferences) } ZEPHIR_INIT_VAR(&references); array_init(&references); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 574, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 583, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "describereferences", NULL, 0, &table_zv, &schema_zv); zephir_check_call_status(); ZVAL_LONG(&_3, 3); diff --git a/ext/phalcon/db/check.zep.c b/ext/phalcon/db/check.zep.c index 0c6c60d5c8..a965ffde25 100644 --- a/ext/phalcon/db/check.zep.c +++ b/ext/phalcon/db/check.zep.c @@ -121,7 +121,7 @@ PHP_METHOD(Phalcon_Db_Check, __construct) if (UNEXPECTED(!(zephir_array_isset_string_fetch(&expression, &definition, SL("expression"), 0)))) { ZEPHIR_INIT_VAR(&_0$$3); object_init_ex(&_0$$3, phalcon_db_exceptions_checkexpressionrequired_ce); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 481); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 492); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$3, "phalcon/Db/Check.zep", 72); ZEPHIR_MM_RESTORE(); @@ -134,14 +134,14 @@ PHP_METHOD(Phalcon_Db_Check, __construct) if (UNEXPECTED(_1)) { ZEPHIR_INIT_VAR(&_2$$4); object_init_ex(&_2$$4, phalcon_db_exceptions_invalidcheckexpression_ce); - ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 482); + ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 493); zephir_check_call_status(); zephir_throw_exception_debug(&_2$$4, "phalcon/Db/Check.zep", 76); ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 575, &name_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 576, &expression); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 584, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 585, &expression); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/db/column.zep.c b/ext/phalcon/db/column.zep.c index faa310164d..f7b7dc56ed 100644 --- a/ext/phalcon/db/column.zep.c +++ b/ext/phalcon/db/column.zep.c @@ -709,48 +709,48 @@ PHP_METHOD(Phalcon_Db_Column, __construct) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); zephir_get_arrval(&definition, definition_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 577, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 586, &name_zv); zephir_memory_observe(&type); if (UNEXPECTED(!(zephir_array_isset_string_fetch(&type, &definition, SL("type"), 0)))) { ZEPHIR_INIT_VAR(&_0$$3); object_init_ex(&_0$$3, phalcon_db_exceptions_columntyperequired_ce); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 483); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 494); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$3, "phalcon/Db/Column.zep", 595); ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 578, &type); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 587, &type); zephir_memory_observe(&typeReference); if (zephir_array_isset_string_fetch(&typeReference, &definition, SL("typeReference"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 579, &typeReference); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 588, &typeReference); } zephir_memory_observe(&typeValues); if (zephir_array_isset_string_fetch(&typeValues, &definition, SL("typeValues"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 580, &typeValues); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 589, &typeValues); } zephir_memory_observe(¬Null); if (zephir_array_isset_string_fetch(¬Null, &definition, SL("notNull"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 581, ¬Null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 590, ¬Null); } zephir_memory_observe(&primary); if (zephir_array_isset_string_fetch(&primary, &definition, SL("primary"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 582, &primary); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 591, &primary); } zephir_memory_observe(&size); if (zephir_array_isset_string_fetch(&size, &definition, SL("size"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 583, &size); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 592, &size); } zephir_memory_observe(&scale); if (zephir_array_isset_string_fetch(&scale, &definition, SL("scale"), 0)) { do { if (ZEPHIR_IS_LONG(&type, 14) || ZEPHIR_IS_LONG(&type, 3) || ZEPHIR_IS_LONG(&type, 9) || ZEPHIR_IS_LONG(&type, 7) || ZEPHIR_IS_LONG(&type, 0) || ZEPHIR_IS_LONG(&type, 21) || ZEPHIR_IS_LONG(&type, 22) || ZEPHIR_IS_LONG(&type, 26)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 584, &scale); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 593, &scale); break; } ZEPHIR_INIT_VAR(&_1$$11); object_init_ex(&_1$$11, phalcon_db_exceptions_columntyperejectsscale_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$11, "__construct", NULL, 484); + ZEPHIR_CALL_METHOD(NULL, &_1$$11, "__construct", NULL, 495); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$11, "phalcon/Db/Column.zep", 643); ZEPHIR_MM_RESTORE(); @@ -760,37 +760,37 @@ PHP_METHOD(Phalcon_Db_Column, __construct) } zephir_memory_observe(&defaultValue); if (zephir_array_isset_string_fetch(&defaultValue, &definition, SL("default"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 585, &defaultValue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 594, &defaultValue); } zephir_memory_observe(&dunsigned); if (zephir_array_isset_string_fetch(&dunsigned, &definition, SL("unsigned"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 586, &dunsigned); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 595, &dunsigned); } zephir_memory_observe(&isNumeric); if (zephir_array_isset_string_fetch(&isNumeric, &definition, SL("isNumeric"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 587, &isNumeric); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 596, &isNumeric); } zephir_memory_observe(&autoIncrement); if (zephir_array_isset_string_fetch(&autoIncrement, &definition, SL("autoIncrement"), 0)) { if (!(zephir_is_true(&autoIncrement))) { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 588, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 597, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 588, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 597, &__$false); } } else { do { if (ZEPHIR_IS_LONG(&type, 14) || ZEPHIR_IS_LONG(&type, 0) || ZEPHIR_IS_LONG(&type, 21) || ZEPHIR_IS_LONG(&type, 22) || ZEPHIR_IS_LONG(&type, 26)) { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 588, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 597, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 588, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 597, &__$false); } break; } ZEPHIR_INIT_VAR(&_2$$19); object_init_ex(&_2$$19, phalcon_db_exceptions_columntyperejectsautoincrement_ce); - ZEPHIR_CALL_METHOD(NULL, &_2$$19, "__construct", NULL, 485); + ZEPHIR_CALL_METHOD(NULL, &_2$$19, "__construct", NULL, 496); zephir_check_call_status(); zephir_throw_exception_debug(&_2$$19, "phalcon/Db/Column.zep", 685); ZEPHIR_MM_RESTORE(); @@ -801,19 +801,19 @@ PHP_METHOD(Phalcon_Db_Column, __construct) } zephir_memory_observe(&first); if (zephir_array_isset_string_fetch(&first, &definition, SL("first"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_12, 589, &first); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_12, 598, &first); } zephir_memory_observe(&after); if (zephir_array_isset_string_fetch(&after, &definition, SL("after"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 590, &after); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 599, &after); } zephir_memory_observe(&bindType); if (zephir_array_isset_string_fetch(&bindType, &definition, SL("bindType"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_14, 591, &bindType); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_14, 600, &bindType); } zephir_memory_observe(&comment); if (zephir_array_isset_string_fetch(&comment, &definition, SL("comment"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_15, 592, &comment); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_15, 601, &comment); } zephir_memory_observe(&generated); if (zephir_array_isset_string_fetch(&generated, &definition, SL("generated"), 0)) { @@ -821,54 +821,54 @@ PHP_METHOD(Phalcon_Db_Column, __construct) if (UNEXPECTED(Z_TYPE_P(&generated) != IS_STRING)) { ZEPHIR_INIT_VAR(&_3$$26); object_init_ex(&_3$$26, phalcon_db_exceptions_invalidgenerationexpression_ce); - ZEPHIR_CALL_METHOD(NULL, &_3$$26, "__construct", NULL, 486); + ZEPHIR_CALL_METHOD(NULL, &_3$$26, "__construct", NULL, 497); zephir_check_call_status(); zephir_throw_exception_debug(&_3$$26, "phalcon/Db/Column.zep", 726); ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_4$$25, this_ptr, _zephir_prop_11, 588, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$25, this_ptr, _zephir_prop_11, 597, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(zephir_is_true(&_4$$25))) { ZEPHIR_INIT_VAR(&_5$$27); object_init_ex(&_5$$27, phalcon_db_exceptions_generatedautoincrementconflict_ce); - ZEPHIR_CALL_METHOD(NULL, &_5$$27, "__construct", NULL, 487); + ZEPHIR_CALL_METHOD(NULL, &_5$$27, "__construct", NULL, 498); zephir_check_call_status(); zephir_throw_exception_debug(&_5$$27, "phalcon/Db/Column.zep", 730); ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_6$$25, this_ptr, _zephir_prop_8, 585, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$25, this_ptr, _zephir_prop_8, 594, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(Z_TYPE_P(&_6$$25) != IS_NULL)) { ZEPHIR_INIT_VAR(&_7$$28); object_init_ex(&_7$$28, phalcon_db_exceptions_generateddefaultconflict_ce); - ZEPHIR_CALL_METHOD(NULL, &_7$$28, "__construct", NULL, 488); + ZEPHIR_CALL_METHOD(NULL, &_7$$28, "__construct", NULL, 499); zephir_check_call_status(); zephir_throw_exception_debug(&_7$$28, "phalcon/Db/Column.zep", 734); ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_16, 593, &generated); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_16, 602, &generated); } } if (zephir_array_isset_string_fetch(&generationStored, &definition, SL("generationStored"), 1)) { if (zephir_get_boolval(&generationStored)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 594, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 603, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 594, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 603, &__$false); } } if (zephir_array_isset_string_fetch(&invisible, &definition, SL("invisible"), 1)) { if (zephir_get_boolval(&invisible)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_18, 595, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_18, 604, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_18, 595, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_18, 604, &__$false); } } if (zephir_array_isset_string_fetch(&isArray, &definition, SL("array"), 1)) { if (zephir_get_boolval(&isArray)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 596, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 605, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 596, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 605, &__$false); } } ZEPHIR_MM_RESTORE(); @@ -998,7 +998,7 @@ PHP_METHOD(Phalcon_Db_Column, hasDefault) if (zephir_is_true(&_0)) { RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 585, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 594, PH_NOISY_CC | PH_READONLY); RETURN_MM_BOOL(Z_TYPE_P(&_1) != IS_NULL); } @@ -1044,7 +1044,7 @@ PHP_METHOD(Phalcon_Db_Column, isGenerated) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("generated", 9, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 593, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 602, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(Z_TYPE_P(&_0) != IS_NULL); } diff --git a/ext/phalcon/db/dialect/mysql.zep.c b/ext/phalcon/db/dialect/mysql.zep.c index 964f845d67..d35fb309db 100644 --- a/ext/phalcon/db/dialect/mysql.zep.c +++ b/ext/phalcon/db/dialect/mysql.zep.c @@ -166,7 +166,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Mysql, addColumn) } else { ZEPHIR_INIT_VAR(&_17$$11); ZVAL_STRING(&_17$$11, "\""); - ZEPHIR_CALL_FUNCTION(&_18$$11, "addcslashes", NULL, 489, &defaultValue, &_17$$11); + ZEPHIR_CALL_FUNCTION(&_18$$11, "addcslashes", NULL, 500, &defaultValue, &_17$$11); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_19$$11); ZEPHIR_CONCAT_SVS(&_19$$11, " DEFAULT \"", &_18$$11, "\""); @@ -667,7 +667,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Mysql, createTable) } else { ZEPHIR_INIT_NVAR(&_21$$16); ZVAL_STRING(&_21$$16, "\""); - ZEPHIR_CALL_FUNCTION(&_22$$16, "addcslashes", &_23, 489, &defaultValue, &_21$$16); + ZEPHIR_CALL_FUNCTION(&_22$$16, "addcslashes", &_23, 500, &defaultValue, &_21$$16); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_24$$16); ZEPHIR_CONCAT_SVS(&_24$$16, " DEFAULT \"", &_22$$16, "\""); @@ -777,7 +777,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Mysql, createTable) } else { ZEPHIR_INIT_NVAR(&_47$$29); ZVAL_STRING(&_47$$29, "\""); - ZEPHIR_CALL_FUNCTION(&_48$$29, "addcslashes", &_23, 489, &defaultValue, &_47$$29); + ZEPHIR_CALL_FUNCTION(&_48$$29, "addcslashes", &_23, 500, &defaultValue, &_47$$29); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_49$$29); ZEPHIR_CONCAT_SVS(&_49$$29, " DEFAULT \"", &_48$$29, "\""); @@ -1583,7 +1583,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnDefinition) } ZEPHIR_CALL_METHOD(&_0$$3, this_ptr, "getcolumnsize", NULL, 0, column); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "checkcolumnunsigned", NULL, 490, column); + ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "checkcolumnunsigned", NULL, 501, column); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_2$$3); ZEPHIR_CONCAT_VV(&_2$$3, &_0$$3, &_1$$3); @@ -1645,7 +1645,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnDefinition) } ZEPHIR_CALL_METHOD(&_7$$18, this_ptr, "getcolumnsizeandscale", NULL, 0, column); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_8$$18, this_ptr, "checkcolumnunsigned", NULL, 490, column); + ZEPHIR_CALL_METHOD(&_8$$18, this_ptr, "checkcolumnunsigned", NULL, 501, column); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_9$$18); ZEPHIR_CONCAT_VV(&_9$$18, &_7$$18, &_8$$18); @@ -1656,9 +1656,9 @@ PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnDefinition) if (ZEPHIR_IS_EMPTY(&columnSql)) { zephir_concat_self_str(&columnSql, SL("DOUBLE")); } - ZEPHIR_CALL_METHOD(&_10$$20, this_ptr, "checkcolumnsizeandscale", NULL, 491, column); + ZEPHIR_CALL_METHOD(&_10$$20, this_ptr, "checkcolumnsizeandscale", NULL, 502, column); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_11$$20, this_ptr, "checkcolumnunsigned", NULL, 490, column); + ZEPHIR_CALL_METHOD(&_11$$20, this_ptr, "checkcolumnunsigned", NULL, 501, column); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_12$$20); ZEPHIR_CONCAT_VV(&_12$$20, &_10$$20, &_11$$20); @@ -1678,9 +1678,9 @@ PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnDefinition) if (ZEPHIR_IS_EMPTY(&columnSql)) { zephir_concat_self_str(&columnSql, SL("FLOAT")); } - ZEPHIR_CALL_METHOD(&_14$$24, this_ptr, "checkcolumnsizeandscale", NULL, 491, column); + ZEPHIR_CALL_METHOD(&_14$$24, this_ptr, "checkcolumnsizeandscale", NULL, 502, column); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_15$$24, this_ptr, "checkcolumnunsigned", NULL, 490, column); + ZEPHIR_CALL_METHOD(&_15$$24, this_ptr, "checkcolumnunsigned", NULL, 501, column); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_16$$24); ZEPHIR_CONCAT_VV(&_16$$24, &_14$$24, &_15$$24); @@ -1693,7 +1693,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnDefinition) } ZEPHIR_CALL_METHOD(&_17$$26, this_ptr, "getcolumnsize", NULL, 0, column); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_18$$26, this_ptr, "checkcolumnunsigned", NULL, 490, column); + ZEPHIR_CALL_METHOD(&_18$$26, this_ptr, "checkcolumnunsigned", NULL, 501, column); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_19$$26); ZEPHIR_CONCAT_VV(&_19$$26, &_17$$26, &_18$$26); @@ -1730,7 +1730,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnDefinition) } ZEPHIR_CALL_METHOD(&_20$$36, this_ptr, "getcolumnsize", NULL, 0, column); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_21$$36, this_ptr, "checkcolumnunsigned", NULL, 490, column); + ZEPHIR_CALL_METHOD(&_21$$36, this_ptr, "checkcolumnunsigned", NULL, 501, column); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_22$$36); ZEPHIR_CONCAT_VV(&_22$$36, &_20$$36, &_21$$36); @@ -1749,7 +1749,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnDefinition) } ZEPHIR_CALL_METHOD(&_23$$40, this_ptr, "getcolumnsize", NULL, 0, column); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_24$$40, this_ptr, "checkcolumnunsigned", NULL, 490, column); + ZEPHIR_CALL_METHOD(&_24$$40, this_ptr, "checkcolumnunsigned", NULL, 501, column); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_25$$40); ZEPHIR_CONCAT_VV(&_25$$40, &_23$$40, &_24$$40); @@ -1800,7 +1800,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnDefinition) } ZEPHIR_CALL_METHOD(&_30$$52, this_ptr, "getcolumnsize", NULL, 0, column); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_31$$52, this_ptr, "checkcolumnunsigned", NULL, 490, column); + ZEPHIR_CALL_METHOD(&_31$$52, this_ptr, "checkcolumnunsigned", NULL, 501, column); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_32$$52); ZEPHIR_CONCAT_VV(&_32$$52, &_30$$52, &_31$$52); @@ -1877,7 +1877,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnDefinition) zephir_check_call_status(); ZEPHIR_INIT_VAR(&_36$$75); ZVAL_STRING(&_36$$75, "MySQL"); - ZEPHIR_CALL_METHOD(NULL, &_34$$75, "__construct", NULL, 492, &_36$$75, &_35$$75); + ZEPHIR_CALL_METHOD(NULL, &_34$$75, "__construct", NULL, 503, &_36$$75, &_35$$75); zephir_check_call_status(); zephir_throw_exception_debug(&_34$$75, "phalcon/Db/Dialect/Mysql.zep", 788); ZEPHIR_MM_RESTORE(); @@ -1897,7 +1897,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnDefinition) ZVAL_COPY(&value$$77, _37$$77); ZEPHIR_INIT_NVAR(&_38$$78); ZVAL_STRING(&_38$$78, "\""); - ZEPHIR_CALL_FUNCTION(&_39$$78, "addcslashes", &_40, 489, &value$$77, &_38$$78); + ZEPHIR_CALL_FUNCTION(&_39$$78, "addcslashes", &_40, 500, &value$$77, &_38$$78); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_41$$78); ZEPHIR_CONCAT_SVS(&_41$$78, "\"", &_39$$78, "\", "); @@ -1923,7 +1923,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnDefinition) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_44$$79); ZVAL_STRING(&_44$$79, "\""); - ZEPHIR_CALL_FUNCTION(&_45$$79, "addcslashes", &_40, 489, &value$$77, &_44$$79); + ZEPHIR_CALL_FUNCTION(&_45$$79, "addcslashes", &_40, 500, &value$$77, &_44$$79); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_46$$79); ZEPHIR_CONCAT_SVS(&_46$$79, "\"", &_45$$79, "\", "); @@ -1941,7 +1941,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnDefinition) } else { ZEPHIR_INIT_VAR(&_51$$80); ZVAL_STRING(&_51$$80, "\""); - ZEPHIR_CALL_FUNCTION(&_52$$80, "addcslashes", &_40, 489, &typeValues, &_51$$80); + ZEPHIR_CALL_FUNCTION(&_52$$80, "addcslashes", &_40, 500, &typeValues, &_51$$80); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_53$$80); ZEPHIR_CONCAT_SVS(&_53$$80, "(\"", &_52$$80, "\")"); @@ -2190,7 +2190,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Mysql, modifyColumn) } else { ZEPHIR_INIT_VAR(&_23$$14); ZVAL_STRING(&_23$$14, "\""); - ZEPHIR_CALL_FUNCTION(&_24$$14, "addcslashes", NULL, 489, &defaultValue, &_23$$14); + ZEPHIR_CALL_FUNCTION(&_24$$14, "addcslashes", NULL, 500, &defaultValue, &_23$$14); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_25$$14); ZEPHIR_CONCAT_SVS(&_25$$14, " DEFAULT \"", &_24$$14, "\""); @@ -2263,7 +2263,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Mysql, onConflictUpdate) zephir_get_arrval(&updateColumns, updateColumns_param); ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, phalcon_db_exceptions_mysqlonconflictnotsupported_ce); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 493); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 504); zephir_check_call_status(); zephir_throw_exception_debug(&_0, "phalcon/Db/Dialect/Mysql.zep", 936); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/db/dialect/postgresql.zep.c b/ext/phalcon/db/dialect/postgresql.zep.c index 406297f51f..f2e5a6bfca 100644 --- a/ext/phalcon/db/dialect/postgresql.zep.c +++ b/ext/phalcon/db/dialect/postgresql.zep.c @@ -1840,7 +1840,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Postgresql, getColumnDefinition) zephir_check_call_status(); ZEPHIR_INIT_VAR(&_7$$74); ZVAL_STRING(&_7$$74, "PostgreSQL"); - ZEPHIR_CALL_METHOD(NULL, &_5$$74, "__construct", NULL, 492, &_7$$74, &_6$$74); + ZEPHIR_CALL_METHOD(NULL, &_5$$74, "__construct", NULL, 503, &_7$$74, &_6$$74); zephir_check_call_status(); zephir_throw_exception_debug(&_5$$74, "phalcon/Db/Dialect/Postgresql.zep", 786); ZEPHIR_MM_RESTORE(); @@ -1860,7 +1860,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Postgresql, getColumnDefinition) ZVAL_COPY(&value$$76, _8$$76); ZEPHIR_INIT_NVAR(&_9$$77); ZVAL_STRING(&_9$$77, "\'"); - ZEPHIR_CALL_FUNCTION(&_10$$77, "addcslashes", &_11, 489, &value$$76, &_9$$77); + ZEPHIR_CALL_FUNCTION(&_10$$77, "addcslashes", &_11, 500, &value$$76, &_9$$77); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_12$$77); ZEPHIR_CONCAT_SVS(&_12$$77, "'", &_10$$77, "', "); @@ -1886,7 +1886,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Postgresql, getColumnDefinition) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_15$$78); ZVAL_STRING(&_15$$78, "\'"); - ZEPHIR_CALL_FUNCTION(&_16$$78, "addcslashes", &_11, 489, &value$$76, &_15$$78); + ZEPHIR_CALL_FUNCTION(&_16$$78, "addcslashes", &_11, 500, &value$$76, &_15$$78); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_17$$78); ZEPHIR_CONCAT_SVS(&_17$$78, "'", &_16$$78, "', "); @@ -1904,7 +1904,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Postgresql, getColumnDefinition) } else { ZEPHIR_INIT_VAR(&_22$$79); ZVAL_STRING(&_22$$79, "\'"); - ZEPHIR_CALL_FUNCTION(&_23$$79, "addcslashes", &_11, 489, &typeValues, &_22$$79); + ZEPHIR_CALL_FUNCTION(&_23$$79, "addcslashes", &_11, 500, &typeValues, &_22$$79); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_24$$79); ZEPHIR_CONCAT_SVS(&_24$$79, "('", &_23$$79, "')"); @@ -2215,7 +2215,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Postgresql, returning) if (UNEXPECTED(ZEPHIR_IS_EMPTY(&columns))) { ZEPHIR_INIT_VAR(&_0$$3); object_init_ex(&_0$$3, phalcon_db_exceptions_returningrequirescolumn_ce); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 494); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 505); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$3, "phalcon/Db/Dialect/Postgresql.zep", 910); ZEPHIR_MM_RESTORE(); @@ -2557,7 +2557,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Postgresql, castDefault) } else { ZEPHIR_INIT_VAR(&_12$$7); ZVAL_STRING(&_12$$7, "\'"); - ZEPHIR_CALL_FUNCTION(&_13$$7, "addcslashes", NULL, 489, &defaultValue, &_12$$7); + ZEPHIR_CALL_FUNCTION(&_13$$7, "addcslashes", NULL, 500, &defaultValue, &_12$$7); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_14$$7); ZEPHIR_CONCAT_SVS(&_14$$7, "'", &_13$$7, "'"); diff --git a/ext/phalcon/db/dialect/sqlite.zep.c b/ext/phalcon/db/dialect/sqlite.zep.c index 65cfcd5c8c..3c0230093b 100644 --- a/ext/phalcon/db/dialect/sqlite.zep.c +++ b/ext/phalcon/db/dialect/sqlite.zep.c @@ -140,7 +140,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, addColumn) } else { ZEPHIR_INIT_VAR(&_13$$6); ZVAL_STRING(&_13$$6, "\""); - ZEPHIR_CALL_FUNCTION(&_14$$6, "addcslashes", NULL, 489, &defaultValue, &_13$$6); + ZEPHIR_CALL_FUNCTION(&_14$$6, "addcslashes", NULL, 500, &defaultValue, &_13$$6); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_15$$6); ZEPHIR_CONCAT_SVS(&_15$$6, " DEFAULT \"", &_14$$6, "\""); @@ -198,7 +198,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, addCheck) ZVAL_STR_COPY(&schemaName_zv, schemaName); ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, phalcon_db_exceptions_sqlitealterchecknotsupported_ce); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 495); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 506); zephir_check_call_status(); zephir_throw_exception_debug(&_0, "phalcon/Db/Dialect/Sqlite.zep", 93); ZEPHIR_MM_RESTORE(); @@ -233,7 +233,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, addForeignKey) ZVAL_STR_COPY(&schemaName_zv, schemaName); ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, phalcon_db_exceptions_sqlitealterforeignkeynotsupported_ce); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 496); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 507); zephir_check_call_status(); zephir_throw_exception_debug(&_0, "phalcon/Db/Dialect/Sqlite.zep", 101); ZEPHIR_MM_RESTORE(); @@ -349,7 +349,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, addPrimaryKey) ZVAL_STR_COPY(&schemaName_zv, schemaName); ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, phalcon_db_exceptions_sqlitealterprimarykeynotsupported_ce); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 497); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 508); zephir_check_call_status(); zephir_throw_exception_debug(&_0, "phalcon/Db/Dialect/Sqlite.zep", 141); ZEPHIR_MM_RESTORE(); @@ -563,7 +563,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, createTable) } else { ZEPHIR_INIT_NVAR(&_18$$14); ZVAL_STRING(&_18$$14, "\""); - ZEPHIR_CALL_FUNCTION(&_19$$14, "addcslashes", &_20, 489, &defaultValue, &_18$$14); + ZEPHIR_CALL_FUNCTION(&_19$$14, "addcslashes", &_20, 500, &defaultValue, &_18$$14); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_21$$14); ZEPHIR_CONCAT_SVS(&_21$$14, " DEFAULT \"", &_19$$14, "\""); @@ -652,7 +652,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, createTable) } else { ZEPHIR_INIT_NVAR(&_38$$24); ZVAL_STRING(&_38$$24, "\""); - ZEPHIR_CALL_FUNCTION(&_39$$24, "addcslashes", &_20, 489, &defaultValue, &_38$$24); + ZEPHIR_CALL_FUNCTION(&_39$$24, "addcslashes", &_20, 500, &defaultValue, &_38$$24); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_40$$24); ZEPHIR_CONCAT_SVS(&_40$$24, " DEFAULT \"", &_39$$24, "\""); @@ -1134,7 +1134,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, dropCheck) ZVAL_STR_COPY(&checkName_zv, checkName); ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, phalcon_db_exceptions_sqlitedropchecknotsupported_ce); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 498); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 509); zephir_check_call_status(); zephir_throw_exception_debug(&_0, "phalcon/Db/Dialect/Sqlite.zep", 366); ZEPHIR_MM_RESTORE(); @@ -1170,7 +1170,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, dropForeignKey) ZVAL_STR_COPY(&referenceName_zv, referenceName); ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, phalcon_db_exceptions_sqlitedropforeignkeynotsupported_ce); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 499); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 510); zephir_check_call_status(); zephir_throw_exception_debug(&_0, "phalcon/Db/Dialect/Sqlite.zep", 374); ZEPHIR_MM_RESTORE(); @@ -1229,7 +1229,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, dropPrimaryKey) ZVAL_STR_COPY(&schemaName_zv, schemaName); ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, phalcon_db_exceptions_sqlitedropprimarykeynotsupported_ce); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 500); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 511); zephir_check_call_status(); zephir_throw_exception_debug(&_0, "phalcon/Db/Dialect/Sqlite.zep", 394); ZEPHIR_MM_RESTORE(); @@ -1541,7 +1541,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, getColumnDefinition) zephir_check_call_status(); ZEPHIR_INIT_VAR(&_7$$38); ZVAL_STRING(&_7$$38, "SQLite"); - ZEPHIR_CALL_METHOD(NULL, &_5$$38, "__construct", NULL, 492, &_7$$38, &_6$$38); + ZEPHIR_CALL_METHOD(NULL, &_5$$38, "__construct", NULL, 503, &_7$$38, &_6$$38); zephir_check_call_status(); zephir_throw_exception_debug(&_5$$38, "phalcon/Db/Dialect/Sqlite.zep", 583); ZEPHIR_MM_RESTORE(); @@ -1561,7 +1561,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, getColumnDefinition) ZVAL_COPY(&value$$40, _8$$40); ZEPHIR_INIT_NVAR(&_9$$41); ZVAL_STRING(&_9$$41, "\""); - ZEPHIR_CALL_FUNCTION(&_10$$41, "addcslashes", &_11, 489, &value$$40, &_9$$41); + ZEPHIR_CALL_FUNCTION(&_10$$41, "addcslashes", &_11, 500, &value$$40, &_9$$41); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_12$$41); ZEPHIR_CONCAT_SVS(&_12$$41, "\"", &_10$$41, "\", "); @@ -1587,7 +1587,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, getColumnDefinition) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_15$$42); ZVAL_STRING(&_15$$42, "\""); - ZEPHIR_CALL_FUNCTION(&_16$$42, "addcslashes", &_11, 489, &value$$40, &_15$$42); + ZEPHIR_CALL_FUNCTION(&_16$$42, "addcslashes", &_11, 500, &value$$40, &_15$$42); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_17$$42); ZEPHIR_CONCAT_SVS(&_17$$42, "\"", &_16$$42, "\", "); @@ -1605,7 +1605,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, getColumnDefinition) } else { ZEPHIR_INIT_VAR(&_22$$43); ZVAL_STRING(&_22$$43, "\""); - ZEPHIR_CALL_FUNCTION(&_23$$43, "addcslashes", &_11, 489, &typeValues, &_22$$43); + ZEPHIR_CALL_FUNCTION(&_23$$43, "addcslashes", &_11, 500, &typeValues, &_22$$43); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_24$$43); ZEPHIR_CONCAT_SVS(&_24$$43, "(\"", &_23$$43, "\")"); @@ -1779,7 +1779,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, modifyColumn) } ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, phalcon_db_exceptions_sqlitealtercolumnnotsupported_ce); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 501); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 0); zephir_check_call_status(); zephir_throw_exception_debug(&_0, "phalcon/Db/Dialect/Sqlite.zep", 656); ZEPHIR_MM_RESTORE(); @@ -1821,7 +1821,7 @@ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, returning) if (UNEXPECTED(ZEPHIR_IS_EMPTY(&columns))) { ZEPHIR_INIT_VAR(&_0$$3); object_init_ex(&_0$$3, phalcon_db_exceptions_returningrequirescolumn_ce); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 494); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 505); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$3, "phalcon/Db/Dialect/Sqlite.zep", 669); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/db/geometry/geometrycollection.zep.c b/ext/phalcon/db/geometry/geometrycollection.zep.c index 09182c3b9c..3b989d87e1 100644 --- a/ext/phalcon/db/geometry/geometrycollection.zep.c +++ b/ext/phalcon/db/geometry/geometrycollection.zep.c @@ -72,10 +72,10 @@ PHP_METHOD(Phalcon_Db_Geometry_GeometryCollection, __construct) srid = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 597, &geometries); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 606, &geometries); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 598, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 607, &_0); ZEPHIR_MM_RESTORE(); } @@ -115,7 +115,7 @@ PHP_METHOD(Phalcon_Db_Geometry_GeometryCollection, toWkt) ZEPHIR_INIT_VAR(&parts); array_init(&parts); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 597, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 606, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "phalcon/Db/Geometry/GeometryCollection.zep", 46); if (Z_TYPE_P(&_0) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1) diff --git a/ext/phalcon/db/geometry/linestring.zep.c b/ext/phalcon/db/geometry/linestring.zep.c index 1a6c181593..c52a912b26 100644 --- a/ext/phalcon/db/geometry/linestring.zep.c +++ b/ext/phalcon/db/geometry/linestring.zep.c @@ -72,10 +72,10 @@ PHP_METHOD(Phalcon_Db_Geometry_LineString, __construct) srid = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 599, &points); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 608, &points); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 600, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 609, &_0); ZEPHIR_MM_RESTORE(); } @@ -131,7 +131,7 @@ PHP_METHOD(Phalcon_Db_Geometry_LineString, pointsWkt) ZEPHIR_INIT_VAR(&parts); array_init(&parts); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 599, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 608, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "phalcon/Db/Geometry/LineString.zep", 51); if (Z_TYPE_P(&_0) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1) diff --git a/ext/phalcon/db/geometry/multilinestring.zep.c b/ext/phalcon/db/geometry/multilinestring.zep.c index 18ef507b08..42a2875bc4 100644 --- a/ext/phalcon/db/geometry/multilinestring.zep.c +++ b/ext/phalcon/db/geometry/multilinestring.zep.c @@ -72,10 +72,10 @@ PHP_METHOD(Phalcon_Db_Geometry_MultiLineString, __construct) srid = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 601, &lineStrings); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 610, &lineStrings); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 602, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 611, &_0); ZEPHIR_MM_RESTORE(); } @@ -117,7 +117,7 @@ PHP_METHOD(Phalcon_Db_Geometry_MultiLineString, toWkt) ZEPHIR_INIT_VAR(&parts); array_init(&parts); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 601, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 610, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "phalcon/Db/Geometry/MultiLineString.zep", 46); if (Z_TYPE_P(&_0) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1) diff --git a/ext/phalcon/db/geometry/multipoint.zep.c b/ext/phalcon/db/geometry/multipoint.zep.c index 7da0e62c52..821bc2baac 100644 --- a/ext/phalcon/db/geometry/multipoint.zep.c +++ b/ext/phalcon/db/geometry/multipoint.zep.c @@ -72,10 +72,10 @@ PHP_METHOD(Phalcon_Db_Geometry_MultiPoint, __construct) srid = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 603, &points); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 612, &points); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 604, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 613, &_0); ZEPHIR_MM_RESTORE(); } @@ -115,7 +115,7 @@ PHP_METHOD(Phalcon_Db_Geometry_MultiPoint, toWkt) ZEPHIR_INIT_VAR(&parts); array_init(&parts); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 603, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 612, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "phalcon/Db/Geometry/MultiPoint.zep", 46); if (Z_TYPE_P(&_0) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1) diff --git a/ext/phalcon/db/geometry/multipolygon.zep.c b/ext/phalcon/db/geometry/multipolygon.zep.c index 038a2f7f7e..411dd18dc0 100644 --- a/ext/phalcon/db/geometry/multipolygon.zep.c +++ b/ext/phalcon/db/geometry/multipolygon.zep.c @@ -72,10 +72,10 @@ PHP_METHOD(Phalcon_Db_Geometry_MultiPolygon, __construct) srid = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 605, &polygons); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 614, &polygons); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 606, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 615, &_0); ZEPHIR_MM_RESTORE(); } @@ -117,7 +117,7 @@ PHP_METHOD(Phalcon_Db_Geometry_MultiPolygon, toWkt) ZEPHIR_INIT_VAR(&parts); array_init(&parts); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 605, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 614, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "phalcon/Db/Geometry/MultiPolygon.zep", 46); if (Z_TYPE_P(&_0) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1) diff --git a/ext/phalcon/db/geometry/point.zep.c b/ext/phalcon/db/geometry/point.zep.c index 27433e12ef..010c3fb2e8 100644 --- a/ext/phalcon/db/geometry/point.zep.c +++ b/ext/phalcon/db/geometry/point.zep.c @@ -78,13 +78,13 @@ PHP_METHOD(Phalcon_Db_Geometry_Point, __construct) } ZVAL_UNDEF(&_0); ZVAL_DOUBLE(&_0, x); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 607, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 616, &_0); ZVAL_UNDEF(&_0); ZVAL_DOUBLE(&_0, y); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 608, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 617, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 609, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 618, &_0); } PHP_METHOD(Phalcon_Db_Geometry_Point, getType) @@ -137,8 +137,8 @@ PHP_METHOD(Phalcon_Db_Geometry_Point, coordsWkt) if (UNEXPECTED(!_zephir_prop_1)) { _zephir_prop_1 = zend_string_init("y", 1, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 607, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 608, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 616, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 617, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_VSV(return_value, &_0, " ", &_1); return; } diff --git a/ext/phalcon/db/geometry/polygon.zep.c b/ext/phalcon/db/geometry/polygon.zep.c index 489351da10..d322aa17df 100644 --- a/ext/phalcon/db/geometry/polygon.zep.c +++ b/ext/phalcon/db/geometry/polygon.zep.c @@ -72,10 +72,10 @@ PHP_METHOD(Phalcon_Db_Geometry_Polygon, __construct) srid = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 610, &rings); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 619, &rings); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 611, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 620, &_0); ZEPHIR_MM_RESTORE(); } @@ -141,7 +141,7 @@ PHP_METHOD(Phalcon_Db_Geometry_Polygon, ringsWkt) ZEPHIR_INIT_VAR(&parts); array_init(&parts); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 610, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 619, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "phalcon/Db/Geometry/Polygon.zep", 57); if (Z_TYPE_P(&_0) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1) diff --git a/ext/phalcon/db/geometry/wkbparser.zep.c b/ext/phalcon/db/geometry/wkbparser.zep.c index cdfaae54d4..683c0ed814 100644 --- a/ext/phalcon/db/geometry/wkbparser.zep.c +++ b/ext/phalcon/db/geometry/wkbparser.zep.c @@ -103,7 +103,7 @@ PHP_METHOD(Phalcon_Db_Geometry_WkbParser, parse) } _0 = zephir_safe_mod_long_long(zephir_fast_strlen_ev(&raw_zv), 2) == 0; if (_0) { - ZEPHIR_CALL_FUNCTION(&_1, "ctype_xdigit", NULL, 502, &raw_zv); + ZEPHIR_CALL_FUNCTION(&_1, "ctype_xdigit", NULL, 0, &raw_zv); zephir_check_call_status(); _0 = zephir_is_true(&_1); } @@ -121,7 +121,7 @@ PHP_METHOD(Phalcon_Db_Geometry_WkbParser, parse) zephir_substr(&_4$$5, &raw_zv, 0 , 4 , 0); ZEPHIR_INIT_VAR(&_5$$5); ZVAL_STRING(&_5$$5, "V"); - ZEPHIR_CALL_FUNCTION(&arr, "unpack", NULL, 503, &_5$$5, &_4$$5); + ZEPHIR_CALL_FUNCTION(&arr, "unpack", NULL, 0, &_5$$5, &_4$$5); zephir_check_call_status(); zephir_memory_observe(&_6$$5); zephir_array_fetch_long(&_6$$5, &arr, 1, PH_NOISY, "phalcon/Db/Geometry/WkbParser.zep", 59); @@ -130,13 +130,13 @@ PHP_METHOD(Phalcon_Db_Geometry_WkbParser, parse) ZEPHIR_INIT_NVAR(&body); zephir_substr(&body, &raw_zv, 4 , 0, ZEPHIR_SUBSTR_NO_LENGTH); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 612, &body); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 621, &body); ZVAL_UNDEF(&_8); ZVAL_LONG(&_8, zephir_fast_strlen_ev(&body)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 613, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 622, &_8); ZVAL_UNDEF(&_8); ZVAL_LONG(&_8, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 614, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 623, &_8); ZVAL_LONG(&_8, srid); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "readgeometry", NULL, 0, &_8); zephir_check_call_status(); @@ -263,7 +263,7 @@ PHP_METHOD(Phalcon_Db_Geometry_WkbParser, readGeometry) } ZEPHIR_CALL_METHOD(&_5$$9, this_ptr, "readpointlist", NULL, 0, &_6$$9, &_7$$9, &_8$$9); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 504, &_5$$9, &srid); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &_5$$9, &srid); zephir_check_call_status(); RETURN_MM(); } @@ -286,7 +286,7 @@ PHP_METHOD(Phalcon_Db_Geometry_WkbParser, readGeometry) } ZEPHIR_CALL_METHOD(&_9$$10, this_ptr, "readringlist", NULL, 0, &_10$$10, &_11$$10, &_12$$10); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 505, &_9$$10, &srid); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &_9$$10, &srid); zephir_check_call_status(); RETURN_MM(); } @@ -305,31 +305,31 @@ PHP_METHOD(Phalcon_Db_Geometry_WkbParser, readGeometry) if (!(ZEPHIR_GT_LONG(&count, i))) { break; } - ZEPHIR_CALL_METHOD(&_14$$12, this_ptr, "readgeometry", &_15, 506, &srid); + ZEPHIR_CALL_METHOD(&_14$$12, this_ptr, "readgeometry", &_15, 0, &srid); zephir_check_call_status(); zephir_array_append(&items, &_14$$12, PH_SEPARATE, "phalcon/Db/Geometry/WkbParser.zep", 118); i = (i + 1); } if (ZEPHIR_IS_LONG_IDENTICAL(&baseType, 4)) { object_init_ex(return_value, phalcon_db_geometry_multipoint_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 507, &items, &srid); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &items, &srid); zephir_check_call_status(); RETURN_MM(); } if (ZEPHIR_IS_LONG_IDENTICAL(&baseType, 5)) { object_init_ex(return_value, phalcon_db_geometry_multilinestring_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 508, &items, &srid); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &items, &srid); zephir_check_call_status(); RETURN_MM(); } if (ZEPHIR_IS_LONG_IDENTICAL(&baseType, 6)) { object_init_ex(return_value, phalcon_db_geometry_multipolygon_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 509, &items, &srid); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &items, &srid); zephir_check_call_status(); RETURN_MM(); } object_init_ex(return_value, phalcon_db_geometry_geometrycollection_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 510, &items, &srid); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &items, &srid); zephir_check_call_status(); RETURN_MM(); } @@ -337,7 +337,7 @@ PHP_METHOD(Phalcon_Db_Geometry_WkbParser, readGeometry) object_init_ex(&_16$$16, phalcon_db_exceptions_invalidwkb_ce); ZEPHIR_INIT_VAR(&_17$$16); ZEPHIR_CONCAT_SV(&_17$$16, "unknown geometry type ", &baseType); - ZEPHIR_CALL_METHOD(NULL, &_16$$16, "__construct", NULL, 511, &_17$$16); + ZEPHIR_CALL_METHOD(NULL, &_16$$16, "__construct", NULL, 0, &_17$$16); zephir_check_call_status(); zephir_throw_exception_debug(&_16$$16, "phalcon/Db/Geometry/WkbParser.zep", 137); ZEPHIR_MM_RESTORE(); @@ -625,25 +625,25 @@ PHP_METHOD(Phalcon_Db_Geometry_WkbParser, readByte) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 614, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 613, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 623, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 622, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_LT_LONG(&_1, (zephir_get_numberval(&_0) + 1))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exceptions_invalidwkb_ce, "truncated buffer", "phalcon/Db/Geometry/WkbParser.zep", 204); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 612, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 621, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 623, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_4, 1); ZEPHIR_INIT_VAR(&_5); zephir_substr(&_5, &_2, zephir_get_intval(&_3), 1 , 0); ZEPHIR_INIT_VAR(&_6); ZVAL_STRING(&_6, "C"); - ZEPHIR_CALL_FUNCTION(&arr, "unpack", NULL, 503, &_6, &_5); + ZEPHIR_CALL_FUNCTION(&arr, "unpack", NULL, 0, &_6, &_5); zephir_check_call_status(); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 623, PH_NOISY_CC | PH_READONLY); ZVAL_UNDEF(&_8); ZVAL_LONG(&_8, (zephir_get_numberval(&_7) + 1)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 614, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 623, &_8); zephir_memory_observe(&_9); zephir_array_fetch_long(&_9, &arr, 1, PH_NOISY, "phalcon/Db/Geometry/WkbParser.zep", 210); RETURN_MM_LONG(zephir_get_intval(&_9)); @@ -687,8 +687,8 @@ PHP_METHOD(Phalcon_Db_Geometry_WkbParser, readUint32) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &little_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 614, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 613, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 623, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 622, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_LT_LONG(&_1, (zephir_get_numberval(&_0) + 4))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exceptions_invalidwkb_ce, "truncated buffer", "phalcon/Db/Geometry/WkbParser.zep", 218); return; @@ -700,17 +700,17 @@ PHP_METHOD(Phalcon_Db_Geometry_WkbParser, readUint32) ZEPHIR_INIT_NVAR(&fmt); ZVAL_STRING(&fmt, "N"); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 612, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 621, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 623, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_4, 4); ZEPHIR_INIT_VAR(&_5); zephir_substr(&_5, &_2, zephir_get_intval(&_3), 4 , 0); - ZEPHIR_CALL_FUNCTION(&arr, "unpack", NULL, 503, &fmt, &_5); + ZEPHIR_CALL_FUNCTION(&arr, "unpack", NULL, 0, &fmt, &_5); zephir_check_call_status(); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 623, PH_NOISY_CC | PH_READONLY); ZVAL_UNDEF(&_7); ZVAL_LONG(&_7, (zephir_get_numberval(&_6) + 4)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 614, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 623, &_7); zephir_memory_observe(&_8); zephir_array_fetch_long(&_8, &arr, 1, PH_NOISY, "phalcon/Db/Geometry/WkbParser.zep", 225); RETURN_MM_LONG(zephir_get_intval(&_8)); @@ -754,8 +754,8 @@ PHP_METHOD(Phalcon_Db_Geometry_WkbParser, readDouble) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &little_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 614, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 613, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 623, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 622, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_LT_LONG(&_1, (zephir_get_numberval(&_0) + 8))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exceptions_invalidwkb_ce, "truncated buffer", "phalcon/Db/Geometry/WkbParser.zep", 233); return; @@ -767,17 +767,17 @@ PHP_METHOD(Phalcon_Db_Geometry_WkbParser, readDouble) ZEPHIR_INIT_NVAR(&fmt); ZVAL_STRING(&fmt, "E"); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 612, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 621, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 623, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_4, 8); ZEPHIR_INIT_VAR(&_5); zephir_substr(&_5, &_2, zephir_get_intval(&_3), 8 , 0); - ZEPHIR_CALL_FUNCTION(&arr, "unpack", NULL, 503, &fmt, &_5); + ZEPHIR_CALL_FUNCTION(&arr, "unpack", NULL, 0, &fmt, &_5); zephir_check_call_status(); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 623, PH_NOISY_CC | PH_READONLY); ZVAL_UNDEF(&_7); ZVAL_LONG(&_7, (zephir_get_numberval(&_6) + 8)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 614, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 623, &_7); zephir_memory_observe(&_8); zephir_array_fetch_long(&_8, &arr, 1, PH_NOISY, "phalcon/Db/Geometry/WkbParser.zep", 240); RETURN_MM_DOUBLE(zephir_get_doubleval(&_8)); diff --git a/ext/phalcon/db/index.zep.c b/ext/phalcon/db/index.zep.c index 4c8fb7e581..729e09f921 100644 --- a/ext/phalcon/db/index.zep.c +++ b/ext/phalcon/db/index.zep.c @@ -219,7 +219,7 @@ PHP_METHOD(Phalcon_Db_Index, __construct) zephir_memory_observe(&type_zv); ZVAL_STR_COPY(&type_zv, type); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 615, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 624, &name_zv); if (zephir_array_isset_value_string(&columnsOrDefinition, SL("columns"))) { zephir_memory_observe(&_0$$3); zephir_array_fetch_string(&_0$$3, &columnsOrDefinition, SL("columns"), PH_NOISY, "phalcon/Db/Index.zep", 139); @@ -233,18 +233,18 @@ PHP_METHOD(Phalcon_Db_Index, __construct) return; } zephir_array_fetch_string(&_2$$3, &columnsOrDefinition, SL("columns"), PH_NOISY | PH_READONLY, "phalcon/Db/Index.zep", 143); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 616, &_2$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 625, &_2$$3); zephir_memory_observe(&definitionType); if (zephir_array_isset_string_fetch(&definitionType, &columnsOrDefinition, SL("type"), 0)) { zephir_cast_to_string(&_3$$5, &definitionType); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 617, &_3$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 626, &_3$$5); } zephir_memory_observe(&invisible); if (zephir_array_isset_string_fetch(&invisible, &columnsOrDefinition, SL("invisible"), 0)) { if (zephir_get_boolval(&invisible)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 618, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 627, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 618, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 627, &__$false); } } zephir_memory_observe(&directions); @@ -258,7 +258,7 @@ PHP_METHOD(Phalcon_Db_Index, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 619, &directions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 628, &directions); } zephir_memory_observe(&where); if (zephir_array_isset_string_fetch(&where, &columnsOrDefinition, SL("where"), 0)) { @@ -271,18 +271,18 @@ PHP_METHOD(Phalcon_Db_Index, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 620, &where); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 629, &where); } if (zephir_array_isset_string_fetch(&concurrent, &columnsOrDefinition, SL("concurrently"), 1)) { if (zephir_get_boolval(&concurrent)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 621, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 630, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 621, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 630, &__$false); } } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 616, &columnsOrDefinition); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 617, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 625, &columnsOrDefinition); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 626, &type_zv); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/db/profiler.zep.c b/ext/phalcon/db/profiler.zep.c index 5558631927..75a4c1d502 100644 --- a/ext/phalcon/db/profiler.zep.c +++ b/ext/phalcon/db/profiler.zep.c @@ -143,7 +143,7 @@ PHP_METHOD(Phalcon_Db_Profiler, getNumberTotalStatements) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("allProfiles", 11, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 622, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 631, PH_NOISY_CC | PH_READONLY); RETURN_LONG(zephir_fast_count_int(&_0)); } @@ -184,7 +184,7 @@ PHP_METHOD(Phalcon_Db_Profiler, reset) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 622, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 631, &_0); RETURN_THIS(); } @@ -210,7 +210,7 @@ PHP_METHOD(Phalcon_Db_Profiler, setMaxProfiles) zephir_fetch_params_without_memory_grow(1, 0, &maxProfiles_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, maxProfiles); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 623, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 632, &_0); RETURN_THISW(); } @@ -278,7 +278,7 @@ PHP_METHOD(Phalcon_Db_Profiler, startProfile) zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &activeProfile, "setsqlbindtypes", NULL, 0, &sqlBindTypes); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&_0, "hrtime", NULL, 467, &__$true); + ZEPHIR_CALL_FUNCTION(&_0, "hrtime", NULL, 478, &__$true); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &activeProfile, "setinitialtime", NULL, 0, &_0); zephir_check_call_status(); @@ -286,7 +286,7 @@ PHP_METHOD(Phalcon_Db_Profiler, startProfile) ZEPHIR_CALL_METHOD(NULL, this_ptr, "beforestartprofile", NULL, 0, &activeProfile); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 624, &activeProfile); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 633, &activeProfile); RETURN_THIS(); } @@ -332,35 +332,35 @@ PHP_METHOD(Phalcon_Db_Profiler, stopProfile) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 624, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 633, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&activeProfile, &_0); - ZEPHIR_CALL_FUNCTION(&_1, "hrtime", NULL, 467, &__$true); + ZEPHIR_CALL_FUNCTION(&_1, "hrtime", NULL, 478, &__$true); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &activeProfile, "setfinaltime", NULL, 0, &_1); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 623, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 632, PH_NOISY_CC | PH_READONLY); _2 = ZEPHIR_GT_LONG(&_0, 0); if (_2) { - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 622, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 623, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 631, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 632, PH_NOISY_CC | PH_READONLY); _2 = ZEPHIR_LE_LONG(&_4, zephir_fast_count_int(&_3)); } if (_2) { - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 622, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 631, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&firstKey, "array_key_first", NULL, 17, &_5$$3); zephir_check_call_status(); if (Z_TYPE_P(&firstKey) != IS_NULL) { zephir_unset_property_array(this_ptr, ZEND_STRL("allProfiles"), &firstKey); - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_2, 622, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_2, 631, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_6$$4, &firstKey, PH_SEPARATE); } } - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_3, 625, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_3, 634, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_8, &activeProfile, "gettotalelapsednanoseconds", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_9); zephir_add_function(&_9, &_7, &_8); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 625, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 634, &_9); zephir_update_property_array_append(this_ptr, SL("allProfiles"), &activeProfile); if ((zephir_method_exists_ex(this_ptr, ZEND_STRL("afterendprofile")) == SUCCESS)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "afterendprofile", NULL, 0, &activeProfile); diff --git a/ext/phalcon/db/profiler/item.zep.c b/ext/phalcon/db/profiler/item.zep.c index 7f33e18c31..edd23d0973 100644 --- a/ext/phalcon/db/profiler/item.zep.c +++ b/ext/phalcon/db/profiler/item.zep.c @@ -129,8 +129,8 @@ PHP_METHOD(Phalcon_Db_Profiler_Item, getTotalElapsedNanoseconds) if (UNEXPECTED(!_zephir_prop_1)) { _zephir_prop_1 = zend_string_init("initialTime", 11, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 626, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 627, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 635, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 636, PH_NOISY_CC | PH_READONLY); zephir_sub_function(return_value, &_0, &_1); return; } @@ -157,7 +157,7 @@ PHP_METHOD(Phalcon_Db_Profiler_Item, setFinalTime) finalTime = zephir_get_doubleval(finalTime_param); ZVAL_UNDEF(&_0); ZVAL_DOUBLE(&_0, finalTime); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 626, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 635, &_0); RETURN_THISW(); } @@ -183,7 +183,7 @@ PHP_METHOD(Phalcon_Db_Profiler_Item, setInitialTime) initialTime = zephir_get_doubleval(initialTime_param); ZVAL_UNDEF(&_0); ZVAL_DOUBLE(&_0, initialTime); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 627, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 636, &_0); RETURN_THISW(); } @@ -210,7 +210,7 @@ PHP_METHOD(Phalcon_Db_Profiler_Item, setSqlBindTypes) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &sqlBindTypes_param); zephir_get_arrval(&sqlBindTypes, sqlBindTypes_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 628, &sqlBindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 637, &sqlBindTypes); RETURN_THIS(); } @@ -233,7 +233,7 @@ PHP_METHOD(Phalcon_Db_Profiler_Item, setSqlStatement) Z_PARAM_STR(sqlStatement) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&sqlStatement_zv, sqlStatement); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 629, &sqlStatement_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 638, &sqlStatement_zv); RETURN_THISW(); } @@ -260,7 +260,7 @@ PHP_METHOD(Phalcon_Db_Profiler_Item, setSqlVariables) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &sqlVariables_param); zephir_get_arrval(&sqlVariables, sqlVariables_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 630, &sqlVariables); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 639, &sqlVariables); RETURN_THIS(); } diff --git a/ext/phalcon/db/rawvalue.zep.c b/ext/phalcon/db/rawvalue.zep.c index 42f80ca833..79a6ccd750 100644 --- a/ext/phalcon/db/rawvalue.zep.c +++ b/ext/phalcon/db/rawvalue.zep.c @@ -81,15 +81,15 @@ PHP_METHOD(Phalcon_Db_RawValue, __construct) ZEPHIR_INIT_VAR(&_0$$3); ZEPHIR_INIT_NVAR(&_0$$3); ZVAL_STRING(&_0$$3, "''"); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 631, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 640, &_0$$3); } else if (Z_TYPE_P(value) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$4); ZEPHIR_INIT_NVAR(&_1$$4); ZVAL_STRING(&_1$$4, "NULL"); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 631, &_1$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 640, &_1$$4); } else { zephir_cast_to_string(&_2$$5, value); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 631, &_2$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 640, &_2$$5); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/db/reference.zep.c b/ext/phalcon/db/reference.zep.c index f7dde39b17..4232dfb47d 100644 --- a/ext/phalcon/db/reference.zep.c +++ b/ext/phalcon/db/reference.zep.c @@ -173,7 +173,7 @@ PHP_METHOD(Phalcon_Db_Reference, __construct) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); zephir_get_arrval(&definition, definition_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 632, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 641, &name_zv); zephir_memory_observe(&referencedTable); if (UNEXPECTED(!(zephir_array_isset_string_fetch(&referencedTable, &definition, SL("referencedTable"), 0)))) { ZEPHIR_INIT_VAR(&_0$$3); @@ -184,7 +184,7 @@ PHP_METHOD(Phalcon_Db_Reference, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 633, &referencedTable); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 642, &referencedTable); zephir_memory_observe(&columns); if (UNEXPECTED(!(zephir_array_isset_string_fetch(&columns, &definition, SL("columns"), 0)))) { ZEPHIR_INIT_VAR(&_1$$4); @@ -195,7 +195,7 @@ PHP_METHOD(Phalcon_Db_Reference, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 634, &columns); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 643, &columns); zephir_memory_observe(&referencedColumns); if (UNEXPECTED(!(zephir_array_isset_string_fetch(&referencedColumns, &definition, SL("referencedColumns"), 0)))) { ZEPHIR_INIT_VAR(&_2$$5); @@ -206,22 +206,22 @@ PHP_METHOD(Phalcon_Db_Reference, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 635, &referencedColumns); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 644, &referencedColumns); zephir_memory_observe(&schema); if (zephir_array_isset_string_fetch(&schema, &definition, SL("schema"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 636, &schema); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 645, &schema); } zephir_memory_observe(&referencedSchema); if (zephir_array_isset_string_fetch(&referencedSchema, &definition, SL("referencedSchema"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 637, &referencedSchema); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 646, &referencedSchema); } zephir_memory_observe(&onDelete); if (zephir_array_isset_string_fetch(&onDelete, &definition, SL("onDelete"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 638, &onDelete); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 647, &onDelete); } zephir_memory_observe(&onUpdate); if (zephir_array_isset_string_fetch(&onUpdate, &definition, SL("onUpdate"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 639, &onUpdate); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 648, &onUpdate); } if (UNEXPECTED(zephir_fast_count_int(&columns) != zephir_fast_count_int(&referencedColumns))) { ZEPHIR_INIT_VAR(&_3$$10); diff --git a/ext/phalcon/db/result/pdoresult.zep.c b/ext/phalcon/db/result/pdoresult.zep.c index 6bbdf694cc..5fb1c68f52 100644 --- a/ext/phalcon/db/result/pdoresult.zep.c +++ b/ext/phalcon/db/result/pdoresult.zep.c @@ -152,11 +152,11 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, __construct) bindTypes = &bindTypes_sub; bindTypes = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 640, connection); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 641, result); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 642, sqlStatement); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 643, bindParams); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 644, bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 649, connection); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 650, result); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 651, sqlStatement); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 652, bindParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 653, bindTypes); } /** @@ -228,19 +228,19 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, dataSeek) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &number_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 640, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 649, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&connection, &_0); ZEPHIR_CALL_METHOD(&pdo, &connection, "getinternalhandler", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 642, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 651, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlStatement, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 643, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 652, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&bindParams, &_0); if (Z_TYPE_P(&bindParams) == IS_ARRAY) { ZEPHIR_CALL_METHOD(&statement, &pdo, "prepare", NULL, 0, &sqlStatement); zephir_check_call_status(); if (Z_TYPE_P(&statement) == IS_OBJECT) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 644, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 653, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1$$4, &connection, "executeprepared", NULL, 0, &statement, &bindParams, &_2$$4); zephir_check_call_status(); ZEPHIR_CPY_WRT(&statement, &_1$$4); @@ -249,14 +249,14 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, dataSeek) ZEPHIR_CALL_METHOD(&statement, &pdo, "query", NULL, 0, &sqlStatement); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 641, &statement); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 650, &statement); n = -1; number--; while (1) { if (!(n != number)) { break; } - zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_5, 645, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_5, 654, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &statement, "fetch", &_4, 0, &_3$$6); zephir_check_call_status(); n++; @@ -289,8 +289,8 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, execute) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 646, &__$null); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 641, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 655, &__$null); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 650, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "execute", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -360,9 +360,9 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, fetch) ZVAL_LONG(&mode, fetchStyle); } else { ZEPHIR_OBS_NVAR(&mode); - zephir_read_property_cached(&mode, this_ptr, _zephir_prop_0, 645, PH_NOISY_CC); + zephir_read_property_cached(&mode, this_ptr, _zephir_prop_0, 654, PH_NOISY_CC); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 641, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 650, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1, cursorOrientation); ZVAL_LONG(&_2, cursorOffset); ZEPHIR_RETURN_CALL_METHOD(&_0, "fetch", NULL, 0, &mode, &_1, &_2); @@ -433,7 +433,7 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, fetchAll) constructorArgs = &__$null; } if (mode == 8) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 641, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 650, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1$$3, mode); ZEPHIR_RETURN_CALL_METHOD(&_0$$3, "fetchall", NULL, 0, &_1$$3, fetchArgument, constructorArgs); zephir_check_call_status(); @@ -444,13 +444,13 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, fetchAll) _2 = mode == 10; } if (_2) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 641, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 650, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_4$$4, mode); ZEPHIR_RETURN_CALL_METHOD(&_3$$4, "fetchall", NULL, 0, &_4$$4, fetchArgument); zephir_check_call_status(); RETURN_MM(); } - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 641, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 650, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_6, mode); ZEPHIR_RETURN_CALL_METHOD(&_5, "fetchall", NULL, 0, &_6); zephir_check_call_status(); @@ -494,8 +494,8 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, fetchArray) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 641, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 645, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 650, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 654, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "fetch", NULL, 0, &_1); zephir_check_call_status(); RETURN_MM(); @@ -575,10 +575,10 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, numRows) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 646, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 655, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&rowCount, &_0); if (Z_TYPE_P(&rowCount) == IS_NULL) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 640, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 649, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&connection, &_1$$3); ZEPHIR_CALL_METHOD(&type, &connection, "gettype", NULL, 0); zephir_check_call_status(); @@ -587,13 +587,13 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, numRows) _2$$3 = ZEPHIR_IS_STRING_IDENTICAL(&type, "pgsql"); } if (_2$$3) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_2, 641, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_2, 650, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&pdoStatement, &_3$$4); ZEPHIR_CALL_METHOD(&rowCount, &pdoStatement, "rowcount", NULL, 0); zephir_check_call_status(); } if (Z_TYPE_P(&rowCount) == IS_NULL) { - zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_3, 642, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_3, 651, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlStatement, &_4$$5); if (!(zephir_start_with_str(&sqlStatement, SL("SELECT COUNT(*) ")))) { ZEPHIR_INIT_VAR(&matches); @@ -608,8 +608,8 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, numRows) zephir_array_fetch_long(&_8$$7, &matches, 1, PH_NOISY | PH_READONLY, "phalcon/Db/Result/PdoResult.zep", 316); ZEPHIR_INIT_VAR(&_9$$7); ZEPHIR_CONCAT_SVS(&_9$$7, "SELECT COUNT(*) \"numrows\" FROM (SELECT ", &_8$$7, ")"); - zephir_read_property_cached(&_10$$7, this_ptr, _zephir_prop_4, 643, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11$$7, this_ptr, _zephir_prop_5, 644, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$7, this_ptr, _zephir_prop_4, 652, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$7, this_ptr, _zephir_prop_5, 653, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&result, &connection, "query", NULL, 0, &_9$$7, &_10$$7, &_11$$7); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&row, &result, "fetch", NULL, 0); @@ -622,7 +622,7 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, numRows) ZVAL_LONG(&rowCount, 1); } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 646, &rowCount); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 655, &rowCount); } RETURN_CCTOR(&rowCount); } @@ -698,7 +698,7 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, setFetchMode) ctorargs = &ctorargs_sub; ctorargs = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 641, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 650, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&pdoStatement, &_0); _1 = fetchMode == 8; if (!(_1)) { @@ -728,7 +728,7 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, setFetchMode) } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, fetchMode); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 645, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 654, &_0); RETURN_MM_BOOL(1); } diff --git a/ext/phalcon/di/factorydefault.zep.c b/ext/phalcon/di/factorydefault.zep.c index 89159352e3..4fea3f4350 100644 --- a/ext/phalcon/di/factorydefault.zep.c +++ b/ext/phalcon/di/factorydefault.zep.c @@ -161,7 +161,7 @@ PHP_METHOD(Phalcon_Di_FactoryDefault, __construct) zephir_array_update_string(&_0, SL("flashSession"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); object_init_ex(&_1, phalcon_di_service_ce); - ZEPHIR_CALL_METHOD(&_7, &filter, "newinstance", NULL, 239); + ZEPHIR_CALL_METHOD(&_7, &filter, "newinstance", NULL, 245); zephir_check_call_status(); ZVAL_BOOL(&_3, 1); ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 176, &_7, &_3); @@ -272,7 +272,7 @@ PHP_METHOD(Phalcon_Di_FactoryDefault, __construct) ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 176, &_2, &_3); zephir_check_call_status(); zephir_array_update_string(&_0, SL("url"), &_1, PH_COPY | PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 262, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 263, &_0); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/di/factorydefault/cli.zep.c b/ext/phalcon/di/factorydefault/cli.zep.c index 7d8cca6963..019acd8e08 100644 --- a/ext/phalcon/di/factorydefault/cli.zep.c +++ b/ext/phalcon/di/factorydefault/cli.zep.c @@ -113,7 +113,7 @@ PHP_METHOD(Phalcon_Di_FactoryDefault_Cli, __construct) zephir_array_update_string(&_0, SL("eventsManager"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); object_init_ex(&_1, phalcon_di_service_ce); - ZEPHIR_CALL_METHOD(&_4, &filter, "newinstance", NULL, 239); + ZEPHIR_CALL_METHOD(&_4, &filter, "newinstance", NULL, 245); zephir_check_call_status(); ZVAL_BOOL(&_3, 1); ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 176, &_4, &_3); @@ -200,7 +200,7 @@ PHP_METHOD(Phalcon_Di_FactoryDefault_Cli, __construct) ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 176, &_2, &_3); zephir_check_call_status(); zephir_array_update_string(&_0, SL("transactionManager"), &_1, PH_COPY | PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 647, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 656, &_0); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/di/service.zep.c b/ext/phalcon/di/service.zep.c index d3b030dfc6..d50a275917 100644 --- a/ext/phalcon/di/service.zep.c +++ b/ext/phalcon/di/service.zep.c @@ -96,11 +96,11 @@ PHP_METHOD(Phalcon_Di_Service, __construct) shared = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 648, definition); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 657, definition); if (shared) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 649, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 658, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 649, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 658, &__$false); } } @@ -142,7 +142,7 @@ PHP_METHOD(Phalcon_Di_Service, getParameter) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &position_param); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 648, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 657, PH_NOISY_CC); if (UNEXPECTED(Z_TYPE_P(&_0) != IS_ARRAY)) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_di_exceptions_definitionmustbearrayforread_ce); @@ -152,7 +152,7 @@ PHP_METHOD(Phalcon_Di_Service, getParameter) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 648, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 657, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_string_fetch(&arguments, &_2, SL("arguments"), 1)) { if (zephir_array_isset_long_fetch(¶meter, &arguments, position, 1)) { RETURN_CTOR(¶meter); @@ -240,10 +240,10 @@ PHP_METHOD(Phalcon_Di_Service, resolve) container = &container_sub; container = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 649, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 658, PH_NOISY_CC | PH_READONLY); _1 = zephir_is_true(&_0); if (_1) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 650, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 659, PH_NOISY_CC | PH_READONLY); _1 = Z_TYPE_P(&_2) != IS_NULL; } if (_1) { @@ -252,7 +252,7 @@ PHP_METHOD(Phalcon_Di_Service, resolve) found = 1; ZEPHIR_INIT_VAR(&instance); ZVAL_NULL(&instance); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 648, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 657, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&definition, &_3); if (Z_TYPE_P(&definition) == IS_STRING) { if (zephir_class_exists(&definition, 1)) { @@ -318,14 +318,14 @@ PHP_METHOD(Phalcon_Di_Service, resolve) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 649, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 658, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_3)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 650, &instance); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 659, &instance); } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 651, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 660, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 651, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 660, &__$false); } RETURN_CCTOR(&instance); } @@ -348,7 +348,7 @@ PHP_METHOD(Phalcon_Di_Service, setDefinition) Z_PARAM_ZVAL(definition) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &definition); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 648, definition); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 657, definition); } /** @@ -383,7 +383,7 @@ PHP_METHOD(Phalcon_Di_Service, setParameter) zephir_fetch_params(1, 2, 0, &position_param, ¶meter_param); zephir_get_arrval(¶meter, parameter_param); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 648, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 657, PH_NOISY_CC); if (UNEXPECTED(Z_TYPE_P(&_0) != IS_ARRAY)) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_di_exceptions_definitionmustbearrayforupdate_ce); @@ -394,7 +394,7 @@ PHP_METHOD(Phalcon_Di_Service, setParameter) return; } zephir_memory_observe(&arguments); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 648, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 657, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_string_fetch(&arguments, &_2, SL("arguments"), 0)) { zephir_array_update_long(&arguments, position, ¶meter, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY); } else { @@ -430,9 +430,9 @@ PHP_METHOD(Phalcon_Di_Service, setShared) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &shared_param); if (shared) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 649, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 658, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 649, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 658, &__$false); } } @@ -454,6 +454,6 @@ PHP_METHOD(Phalcon_Di_Service, setSharedInstance) Z_PARAM_ZVAL(sharedInstance) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &sharedInstance); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 650, sharedInstance); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 659, sharedInstance); } diff --git a/ext/phalcon/domain/payload/payload.zep.c b/ext/phalcon/domain/payload/payload.zep.c index 0a912d6af8..2a0c499a16 100644 --- a/ext/phalcon/domain/payload/payload.zep.c +++ b/ext/phalcon/domain/payload/payload.zep.c @@ -171,7 +171,7 @@ PHP_METHOD(Phalcon_Domain_Payload_Payload, setException) Z_PARAM_OBJECT_OF_CLASS(exception, zend_ce_throwable) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &exception); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 652, exception); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 661, exception); RETURN_THISW(); } @@ -193,7 +193,7 @@ PHP_METHOD(Phalcon_Domain_Payload_Payload, setExtras) Z_PARAM_ZVAL(extras) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &extras); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 653, extras); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 662, extras); RETURN_THISW(); } @@ -215,7 +215,7 @@ PHP_METHOD(Phalcon_Domain_Payload_Payload, setInput) Z_PARAM_ZVAL(input) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &input); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 654, input); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 663, input); RETURN_THISW(); } @@ -237,7 +237,7 @@ PHP_METHOD(Phalcon_Domain_Payload_Payload, setMessages) Z_PARAM_ZVAL(messages) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &messages); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 655, messages); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 664, messages); RETURN_THISW(); } @@ -259,7 +259,7 @@ PHP_METHOD(Phalcon_Domain_Payload_Payload, setOutput) Z_PARAM_ZVAL(output) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &output); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 656, output); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 665, output); RETURN_THISW(); } @@ -285,7 +285,7 @@ PHP_METHOD(Phalcon_Domain_Payload_Payload, setStatus) Z_PARAM_ZVAL(status) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &status); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 657, status); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 666, status); RETURN_THISW(); } diff --git a/ext/phalcon/encryption/crypt.zep.c b/ext/phalcon/encryption/crypt.zep.c index 4e59b9fcd5..6280e7a3fc 100644 --- a/ext/phalcon/encryption/crypt.zep.c +++ b/ext/phalcon/encryption/crypt.zep.c @@ -232,11 +232,11 @@ PHP_METHOD(Phalcon_Encryption_Crypt, __construct) ZEPHIR_CALL_METHOD(NULL, padFactory, "__construct", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 658, padFactory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 667, padFactory); ZEPHIR_INIT_VAR(&_0); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "sha256"); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 659, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 668, &_0); ZEPHIR_CALL_METHOD(&_1, this_ptr, "initializeavailableciphers", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_2, &_1, "setcipher", NULL, 0, &cipher); @@ -345,7 +345,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, decrypt) ZVAL_STR_COPY(&key_zv, key); } zephir_memory_observe(&decryptKey); - zephir_read_property_cached(&decryptKey, this_ptr, _zephir_prop_0, 660, PH_NOISY_CC); + zephir_read_property_cached(&decryptKey, this_ptr, _zephir_prop_0, 669, PH_NOISY_CC); if (1 != ZEPHIR_IS_EMPTY(&key_zv)) { ZEPHIR_CPY_WRT(&decryptKey, &key_zv); } @@ -358,9 +358,9 @@ PHP_METHOD(Phalcon_Encryption_Crypt, decrypt) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 661, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 670, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cipher, &_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 662, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 671, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&ivLength, &_1); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "cipher"); @@ -384,16 +384,16 @@ PHP_METHOD(Phalcon_Encryption_Crypt, decrypt) ZVAL_LONG(&_1, 0); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "8bit"); - ZEPHIR_CALL_FUNCTION(&iv, "mb_substr", NULL, 290, &input_zv, &_1, &ivLength, &_2); + ZEPHIR_CALL_FUNCTION(&iv, "mb_substr", NULL, 296, &input_zv, &_1, &ivLength, &_2); zephir_check_call_status(); ZEPHIR_INIT_VAR(&digest); ZVAL_STRING(&digest, ""); ZEPHIR_CALL_METHOD(&hashAlgorithm, this_ptr, "gethashalgorithm", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 663, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 672, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_1)) { zephir_memory_observe(&hashLength); - zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_4, 664, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_4, 673, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&hashLength, &_5$$6, &hashAlgorithm, 0))) { ZEPHIR_INIT_VAR(&_7$$7); ZVAL_STRING(&_7$$7, ""); @@ -406,23 +406,23 @@ PHP_METHOD(Phalcon_Encryption_Crypt, decrypt) } ZEPHIR_INIT_VAR(&_9$$6); ZVAL_STRING(&_9$$6, "8bit"); - ZEPHIR_CALL_FUNCTION(&digest, "mb_substr", NULL, 290, &input_zv, &ivLength, &hashLength, &_9$$6); + ZEPHIR_CALL_FUNCTION(&digest, "mb_substr", NULL, 296, &input_zv, &ivLength, &hashLength, &_9$$6); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_10$$6); zephir_add_function(&_10$$6, &ivLength, &hashLength); ZEPHIR_INIT_NVAR(&_9$$6); ZVAL_STRING(&_9$$6, "8bit"); - ZEPHIR_CALL_FUNCTION(&cipherText, "mb_substr", NULL, 290, &input_zv, &_10$$6, &__$null, &_9$$6); + ZEPHIR_CALL_FUNCTION(&cipherText, "mb_substr", NULL, 296, &input_zv, &_10$$6, &__$null, &_9$$6); zephir_check_call_status(); } else { ZEPHIR_INIT_VAR(&_11$$8); ZVAL_STRING(&_11$$8, "8bit"); - ZEPHIR_CALL_FUNCTION(&cipherText, "mb_substr", NULL, 290, &input_zv, &ivLength, &__$null, &_11$$8); + ZEPHIR_CALL_FUNCTION(&cipherText, "mb_substr", NULL, 296, &input_zv, &ivLength, &__$null, &_11$$8); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(&decrypted, this_ptr, "decryptgcmccmauth", NULL, 0, &mode, &cipherText, &decryptKey, &iv); zephir_check_call_status(); - zephir_read_property_cached(&_12, this_ptr, _zephir_prop_3, 663, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12, this_ptr, _zephir_prop_3, 672, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_12)) { ZVAL_BOOL(&_15$$9, 1); ZEPHIR_CALL_METHOD(&_14$$9, this_ptr, "phphashhmac", NULL, 0, &hashAlgorithm, &decrypted, &decryptKey, &_15$$9); @@ -577,7 +577,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, encrypt) ZVAL_STR_COPY(&key_zv, key); } zephir_memory_observe(&encryptKey); - zephir_read_property_cached(&encryptKey, this_ptr, _zephir_prop_0, 660, PH_NOISY_CC); + zephir_read_property_cached(&encryptKey, this_ptr, _zephir_prop_0, 669, PH_NOISY_CC); if (1 != ZEPHIR_IS_EMPTY(&key_zv)) { ZEPHIR_CPY_WRT(&encryptKey, &key_zv); } @@ -590,9 +590,9 @@ PHP_METHOD(Phalcon_Encryption_Crypt, encrypt) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 661, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 670, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cipher, &_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 662, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 671, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&ivLength, &_1); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "cipher"); @@ -631,7 +631,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, encrypt) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&encrypted, this_ptr, "encryptgcmccm", NULL, 0, &mode, &padded, &encryptKey, &iv); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 663, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 672, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_1)) { ZEPHIR_CALL_METHOD(&_5$$7, this_ptr, "gethashalgorithm", NULL, 0); zephir_check_call_status(); @@ -858,7 +858,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, isValidDecryptLength) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&input_zv); ZVAL_STR_COPY(&input_zv, input); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 661, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 670, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&length, this_ptr, "phpopensslcipherivlength", NULL, 0, &_0); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&length)) { @@ -888,7 +888,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, setAuthData) Z_PARAM_STR(data) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&data_zv, data); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 665, &data_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 674, &data_zv); RETURN_THISW(); } @@ -913,7 +913,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, setAuthTag) Z_PARAM_STR(tag) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&tag_zv, tag); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 666, &tag_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 675, &tag_zv); RETURN_THISW(); } @@ -959,7 +959,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, setAuthTagLength) } ZVAL_UNDEF(&_2); ZVAL_LONG(&_2, length); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 667, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 676, &_2); RETURN_THIS(); } @@ -1004,8 +1004,8 @@ PHP_METHOD(Phalcon_Encryption_Crypt, setCipher) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getivlength", NULL, 0, &cipher_zv); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 662, &_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 661, &cipher_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 671, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 670, &cipher_zv); RETURN_THIS(); } @@ -1044,7 +1044,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, setKey) Z_PARAM_STR(key) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&key_zv, key); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 660, &key_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 669, &key_zv); RETURN_THISW(); } @@ -1082,7 +1082,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, setHashAlgorithm) ZVAL_STRING(&_0, "hash"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkcipherhashisavailable", NULL, 0, &hashAlgorithm_zv, &_0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 659, &hashAlgorithm_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 668, &hashAlgorithm_zv); RETURN_THIS(); } @@ -1111,7 +1111,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, setPadding) zephir_fetch_params_without_memory_grow(1, 0, &scheme_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, scheme); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 668, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 677, &_0); RETURN_THISW(); } @@ -1140,9 +1140,9 @@ PHP_METHOD(Phalcon_Encryption_Crypt, useSigning) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &useSigning_param); if (useSigning) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 663, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 672, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 663, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 672, &__$false); } RETURN_THISW(); } @@ -1284,11 +1284,11 @@ PHP_METHOD(Phalcon_Encryption_Crypt, cryptPadText) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 658, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 667, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_6$$3, paddingType); ZEPHIR_CALL_METHOD(&service, &_5$$3, "padnumbertoservice", NULL, 0, &_6$$3); zephir_check_call_status(); - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 658, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 667, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_7$$3, &_6$$3, "newinstance", NULL, 0, &service); zephir_check_call_status(); ZVAL_LONG(&_8$$3, paddingSize); @@ -1383,11 +1383,11 @@ PHP_METHOD(Phalcon_Encryption_Crypt, cryptUnpadText) _1 = ZEPHIR_IS_TRUE_IDENTICAL(&_2); } if (_1) { - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 658, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 667, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_6$$3, paddingType); ZEPHIR_CALL_METHOD(&service, &_5$$3, "padnumbertoservice", NULL, 0, &_6$$3); zephir_check_call_status(); - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 658, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 667, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_7$$3, &_6$$3, "newinstance", NULL, 0, &service); zephir_check_call_status(); ZVAL_LONG(&_8$$3, blockSize); @@ -1464,7 +1464,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, decryptGetUnpadded) ZEPHIR_CALL_METHOD(&_0, this_ptr, "checkismode", NULL, 0, &_1, &mode_zv); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 668, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 677, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&padding, &_3$$3); ZVAL_LONG(&_3$$3, blockSize); ZEPHIR_CALL_METHOD(&localDecrypted, this_ptr, "cryptunpadtext", NULL, 0, &decrypted_zv, &mode_zv, &_3$$3, &padding); @@ -1541,7 +1541,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, decryptGcmCcmAuth) ZVAL_STR_COPY(&decryptKey_zv, decryptKey); zephir_memory_observe(&iv_zv); ZVAL_STR_COPY(&iv_zv, iv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 661, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 670, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cipher, &_0); ZEPHIR_INIT_VAR(&_2); zephir_create_array(&_2, 2, 0); @@ -1554,9 +1554,9 @@ PHP_METHOD(Phalcon_Encryption_Crypt, decryptGcmCcmAuth) ZEPHIR_CALL_METHOD(&_1, this_ptr, "checkismode", NULL, 0, &_2, &mode_zv); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_1)) { - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 665, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 674, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&authData, &_4$$3); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 667, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 676, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&authTagLength, &_4$$3); ZEPHIR_INIT_VAR(&cipherLength); ZVAL_LONG(&cipherLength, zephir_fast_strlen_ev(&cipherText_zv)); @@ -1632,7 +1632,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, encryptGetPadded) ZVAL_STR_COPY(&mode_zv, mode); zephir_memory_observe(&input_zv); ZVAL_STR_COPY(&input_zv, input); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 668, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 677, PH_NOISY_CC | PH_READONLY); _1 = !ZEPHIR_IS_LONG_IDENTICAL(&_0, 0); if (_1) { ZEPHIR_INIT_VAR(&_3); @@ -1645,7 +1645,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, encryptGetPadded) _1 = ZEPHIR_IS_TRUE_IDENTICAL(&_2); } if (_1) { - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 668, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 677, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_6$$3, blockSize); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "cryptpadtext", NULL, 0, &input_zv, &mode_zv, &_6$$3, &_5$$3); zephir_check_call_status(); @@ -1722,7 +1722,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, encryptGcmCcm) ZVAL_STR_COPY(&encryptKey_zv, encryptKey); zephir_memory_observe(&iv_zv); ZVAL_STR_COPY(&iv_zv, iv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 661, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 670, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cipher, &_0); ZEPHIR_INIT_VAR(&authTag); ZVAL_STRING(&authTag, ""); @@ -1737,7 +1737,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, encryptGcmCcm) ZEPHIR_CALL_METHOD(&_1, this_ptr, "checkismode", NULL, 0, &_2, &mode_zv); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_1)) { - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 665, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 674, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&authData, &_4$$3); if (1 == ZEPHIR_IS_EMPTY(&authData)) { ZEPHIR_INIT_VAR(&_5$$4); @@ -1748,16 +1748,16 @@ PHP_METHOD(Phalcon_Encryption_Crypt, encryptGcmCcm) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 666, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 675, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&authTag, &_4$$3); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_3, 667, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_3, 676, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&authTagLength, &_4$$3); ZVAL_LONG(&_4$$3, 1); ZEPHIR_MAKE_REF(&authTag); ZEPHIR_CALL_FUNCTION(&encrypted, "openssl_encrypt", NULL, 0, &padded_zv, &cipher, &encryptKey_zv, &_4$$3, &iv_zv, &authTag, &authData, &authTagLength); ZEPHIR_UNREF(&authTag); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 666, &authTag); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 675, &authTag); } else { ZVAL_LONG(&_6$$5, 1); ZEPHIR_CALL_FUNCTION(&encrypted, "openssl_encrypt", NULL, 0, &padded_zv, &cipher, &encryptKey_zv, &_6$$5, &iv_zv); @@ -1881,7 +1881,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, initializeAvailableCiphers) } } ZEPHIR_INIT_NVAR(&cipher); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 669, &allowed); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 678, &allowed); RETURN_THIS(); } @@ -1954,13 +1954,13 @@ PHP_METHOD(Phalcon_Encryption_Crypt, getBlockSize) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&mode_zv); ZVAL_STR_COPY(&mode_zv, mode); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 662, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 671, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_GT_LONG(&_0, 0)) { RETURN_MM_MEMBER_TYPED(getThis(), "ivLength", IS_LONG); } ZEPHIR_INIT_VAR(&_1); ZEPHIR_CONCAT_SV(&_1, "-", &mode_zv); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 661, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 670, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_3); ZVAL_STRING(&_3, ""); ZEPHIR_CALL_FUNCTION(&_4, "str_ireplace", NULL, 0, &_1, &_3, &_2); @@ -2035,15 +2035,15 @@ PHP_METHOD(Phalcon_Encryption_Crypt, getMode) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 661, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 670, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "-"); ZEPHIR_CALL_FUNCTION(&_2, "strrpos", NULL, 0, &_0, &_1); zephir_check_call_status(); ZEPHIR_INIT_VAR(&position); ZVAL_LONG(&position, zephir_get_intval(&_2)); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 661, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 661, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 670, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 670, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_5, ((zephir_get_numberval(&position) - zephir_fast_strlen_ev(&_4)) + 1)); ZEPHIR_INIT_NVAR(&_1); zephir_substr(&_1, &_3, zephir_get_intval(&_5), 0, ZEPHIR_SUBSTR_NO_LENGTH); @@ -2362,7 +2362,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, phpExtensionLoaded) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 431, &name_zv); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/encryption/security.zep.c b/ext/phalcon/encryption/security.zep.c index 34e5d48b1b..79b8a6e902 100644 --- a/ext/phalcon/encryption/security.zep.c +++ b/ext/phalcon/encryption/security.zep.c @@ -232,9 +232,9 @@ PHP_METHOD(Phalcon_Encryption_Security, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 670, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 671, request); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 672, session); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 679, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 680, request); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 681, session); ZEPHIR_MM_RESTORE(); } @@ -506,16 +506,16 @@ PHP_METHOD(Phalcon_Encryption_Security, destroyToken) ZEPHIR_CALL_METHOD(&session, this_ptr, "getlocalservice", NULL, 0, &_0, &_1); zephir_check_call_status(); if (UNEXPECTED(zephir_is_true(&session))) { - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 673, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 682, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &session, "remove", NULL, 0, &_2$$3); zephir_check_call_status(); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_1, 674, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_1, 683, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &session, "remove", NULL, 0, &_3$$3); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 675, &__$null); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 676, &__$null); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 677, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 684, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 685, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 686, &__$null); RETURN_THIS(); } @@ -594,7 +594,7 @@ PHP_METHOD(Phalcon_Encryption_Security, getRequestToken) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 677, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_0)) { ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getsessiontoken", NULL, 0); zephir_check_call_status(); @@ -633,7 +633,7 @@ PHP_METHOD(Phalcon_Encryption_Security, getSessionToken) ZEPHIR_CALL_METHOD(&session, this_ptr, "getlocalservice", NULL, 0, &_0, &_1); zephir_check_call_status(); if (UNEXPECTED(zephir_is_true(&session))) { - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 674, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 683, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&session, "get", NULL, 0, &_2$$3); zephir_check_call_status(); RETURN_MM(); @@ -683,11 +683,11 @@ PHP_METHOD(Phalcon_Encryption_Security, getSaltBytes) } else { } if (!(numberBytes)) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 678, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 687, PH_NOISY_CC | PH_READONLY); numberBytes = zephir_get_numberval(&_0$$3); } while (1) { - zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_1, 670, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_1, 679, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2$$4, numberBytes); ZEPHIR_CALL_METHOD(&safeBytes, &_1$$4, "base64safe", NULL, 0, &_2$$4); zephir_check_call_status(); @@ -757,7 +757,7 @@ PHP_METHOD(Phalcon_Encryption_Security, getToken) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 675, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 684, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); ZVAL_STRING(&_1$$3, "session"); @@ -765,32 +765,32 @@ PHP_METHOD(Phalcon_Encryption_Security, getToken) ZVAL_STRING(&_2$$3, "localSession"); ZEPHIR_CALL_METHOD(&session, this_ptr, "getlocalservice", NULL, 0, &_1$$3, &_2$$3); zephir_check_call_status(); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_1, 679, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_1, 688, PH_NOISY_CC | PH_READONLY); _4$$3 = ZEPHIR_IS_FALSE_IDENTICAL(&_3$$3); if (_4$$3) { _4$$3 = Z_TYPE_P(&session) != IS_NULL; } if (_4$$3) { - zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_2, 674, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_2, 683, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&sessionToken, &session, "get", NULL, 0, &_5$$4); zephir_check_call_status(); if (Z_TYPE_P(&sessionToken) != IS_NULL) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 675, &sessionToken); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 677, &sessionToken); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 684, &sessionToken); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 686, &sessionToken); RETURN_MM_MEMBER(getThis(), "token"); } } ZEPHIR_CALL_METHOD(&_6$$3, this_ptr, "getsessiontoken", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 677, &_6$$3); - zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_4, 670, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_5, 678, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 686, &_6$$3); + zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_4, 679, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_5, 687, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_8$$3, &_7$$3, "base64safe", NULL, 0, &_9$$3); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 675, &_8$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 684, &_8$$3); if (Z_TYPE_P(&session) != IS_NULL) { - zephir_read_property_cached(&_10$$6, this_ptr, _zephir_prop_2, 674, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_0, 675, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$6, this_ptr, _zephir_prop_2, 683, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_0, 684, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &session, "set", NULL, 0, &_10$$6, &_11$$6); zephir_check_call_status(); } @@ -847,7 +847,7 @@ PHP_METHOD(Phalcon_Encryption_Security, getTokenKey) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 676, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 685, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); ZVAL_STRING(&_1$$3, "session"); @@ -856,23 +856,23 @@ PHP_METHOD(Phalcon_Encryption_Security, getTokenKey) ZEPHIR_CALL_METHOD(&session, this_ptr, "getlocalservice", NULL, 0, &_1$$3, &_2$$3); zephir_check_call_status(); if (Z_TYPE_P(&session) != IS_NULL) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 679, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 688, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_FALSE_IDENTICAL(&_3$$4)) { - zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_2, 673, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_2, 682, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&sessionTokenKey, &session, "get", NULL, 0, &_4$$5); zephir_check_call_status(); if (Z_TYPE_P(&sessionTokenKey) != IS_NULL) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 676, &sessionTokenKey); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 685, &sessionTokenKey); RETURN_MM_MEMBER(getThis(), "tokenKey"); } } - zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_3, 670, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_4, 678, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_3, 679, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_4, 687, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_6$$4, &_5$$4, "base64safe", NULL, 0, &_7$$4); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 676, &_6$$4); - zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_2, 673, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 676, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 685, &_6$$4); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_2, 682, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 685, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &session, "set", NULL, 0, &_8$$4, &_9$$4); zephir_check_call_status(); } @@ -958,7 +958,7 @@ PHP_METHOD(Phalcon_Encryption_Security, hash) bytes = 22; legacy = 1; zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 680, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 689, PH_NOISY_CC); do { if (ZEPHIR_IS_LONG(&_1, 3)) { ZEPHIR_INIT_NVAR(&prefix); @@ -1096,17 +1096,17 @@ PHP_METHOD(Phalcon_Encryption_Security, refreshToken) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 670, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 678, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 679, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 687, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "base64safe", NULL, 0, &_2); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 675, &_1); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 670, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 678, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 684, &_1); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 679, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 687, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_4, &_3, "base64safe", NULL, 0, &_5); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 676, &_4); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 677, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 685, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 686, &__$null); ZEPHIR_INIT_VAR(&_6); ZVAL_STRING(&_6, "session"); ZEPHIR_INIT_VAR(&_7); @@ -1114,12 +1114,12 @@ PHP_METHOD(Phalcon_Encryption_Security, refreshToken) ZEPHIR_CALL_METHOD(&session, this_ptr, "getlocalservice", NULL, 0, &_6, &_7); zephir_check_call_status(); if (Z_TYPE_P(&session) != IS_NULL) { - zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_5, 674, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_2, 675, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_5, 683, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_2, 684, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &session, "set", NULL, 0, &_8$$3, &_9$$3); zephir_check_call_status(); - zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_6, 673, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_3, 676, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_6, 682, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_3, 685, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &session, "set", NULL, 0, &_10$$3, &_11$$3); zephir_check_call_status(); } @@ -1154,9 +1154,9 @@ PHP_METHOD(Phalcon_Encryption_Security, setAutoRefresh) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &autoRefresh_param); if (autoRefresh) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 679, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 688, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 679, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 688, &__$false); } RETURN_THISW(); } @@ -1186,7 +1186,7 @@ PHP_METHOD(Phalcon_Encryption_Security, setDefaultHash) zephir_fetch_params_without_memory_grow(1, 0, &defaultHash_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, defaultHash); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 680, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 689, &_0); RETURN_THISW(); } @@ -1216,7 +1216,7 @@ PHP_METHOD(Phalcon_Encryption_Security, setRandomBytes) zephir_fetch_params_without_memory_grow(1, 0, &randomBytes_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, randomBytes); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 678, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 687, &_0); RETURN_THISW(); } @@ -1245,7 +1245,7 @@ PHP_METHOD(Phalcon_Encryption_Security, setWorkFactor) zephir_fetch_params_without_memory_grow(1, 0, &workFactor_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, workFactor); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 681, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 690, &_0); RETURN_THISW(); } @@ -1292,18 +1292,18 @@ PHP_METHOD(Phalcon_Encryption_Security, getLocalService) zephir_read_property_zval(&_0, this_ptr, &property_zv, PH_NOISY_CC); _1 = Z_TYPE_P(&_0) == IS_NULL; if (_1) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 682, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 691, PH_NOISY_CC | PH_READONLY); _1 = Z_TYPE_P(&_2) != IS_NULL; } _3 = _1; if (_3) { - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 682, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 691, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5, &_4, "has", NULL, 0, &name_zv); zephir_check_call_status(); _3 = ZEPHIR_IS_TRUE_IDENTICAL(&_5); } if (_3) { - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 682, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 691, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_7$$3, &_6$$3, "getshared", NULL, 0, &name_zv); zephir_check_call_status(); zephir_update_property_zval_zval(this_ptr, &property_zv, &_7$$3); @@ -1337,12 +1337,12 @@ PHP_METHOD(Phalcon_Encryption_Security, processAlgorithm) ZEPHIR_INIT_VAR(&algorithm); ZVAL_STRING(&algorithm, "2y"); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 680, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 689, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_LONG_IDENTICAL(&_0, 10)) { ZEPHIR_INIT_NVAR(&algorithm); ZVAL_STRING(&algorithm, "argon2i"); } else { - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 680, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 689, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_LONG_IDENTICAL(&_1, 11)) { ZEPHIR_INIT_NVAR(&algorithm); ZVAL_STRING(&algorithm, "argon2id"); @@ -1383,10 +1383,10 @@ PHP_METHOD(Phalcon_Encryption_Security, processArgonOptions) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &options_param); zephir_get_arrval(&options, options_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 680, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 689, PH_NOISY_CC | PH_READONLY); _1 = ZEPHIR_IS_LONG_IDENTICAL(&_0, 10); if (!(_1)) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 680, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 689, PH_NOISY_CC | PH_READONLY); _1 = ZEPHIR_IS_LONG_IDENTICAL(&_2, 11); } if (_1) { @@ -1450,7 +1450,7 @@ PHP_METHOD(Phalcon_Encryption_Security, processCost) zephir_memory_observe(&cost); if (!(zephir_array_isset_string_fetch(&cost, &options, SL("cost"), 0))) { ZEPHIR_OBS_NVAR(&cost); - zephir_read_property_cached(&cost, this_ptr, _zephir_prop_0, 681, PH_NOISY_CC); + zephir_read_property_cached(&cost, this_ptr, _zephir_prop_0, 690, PH_NOISY_CC); } if (ZEPHIR_LT_LONG(&cost, 4)) { ZEPHIR_INIT_NVAR(&cost); @@ -1513,7 +1513,7 @@ PHP_METHOD(Phalcon_Encryption_Security, processTokenKey) _2 = 1 == ZEPHIR_IS_EMPTY(&key); } if (_2) { - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 673, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 682, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&key, &session, "get", NULL, 0, &_3$$3); zephir_check_call_status(); } diff --git a/ext/phalcon/encryption/security/jwt/builder.zep.c b/ext/phalcon/encryption/security/jwt/builder.zep.c index 9b8862a092..0f1769e6d6 100644 --- a/ext/phalcon/encryption/security/jwt/builder.zep.c +++ b/ext/phalcon/encryption/security/jwt/builder.zep.c @@ -102,7 +102,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, __construct) zephir_fetch_params(1, 1, 0, &signer); ZEPHIR_CALL_METHOD(NULL, this_ptr, "init", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 683, signer); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 692, signer); ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, phalcon_support_helper_json_encode_ce); if (zephir_has_constructor(&_0)) { @@ -110,9 +110,9 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 684, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 685, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 683, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 693, &_0); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 694, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 692, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_3, &_2, "getalgheader", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_4); @@ -155,7 +155,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, addClaim) value = ZEND_CALL_ARG(execute_data, 2); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &name_zv, value); zephir_check_call_status(); RETURN_THIS(); @@ -194,7 +194,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, addHeader) value = ZEND_CALL_ARG(execute_data, 2); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 685, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 694, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &name_zv, value); zephir_check_call_status(); RETURN_THIS(); @@ -220,7 +220,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, getAudience) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); array_init(&_1); ZEPHIR_INIT_VAR(&_2); @@ -248,7 +248,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, getClaims) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "toarray", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -275,7 +275,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, getContentType) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 685, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 694, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "cty"); ZVAL_NULL(&_2); @@ -307,7 +307,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, getExpirationTime) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "exp"); ZVAL_NULL(&_2); @@ -336,7 +336,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, getHeaders) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 685, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 694, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "toarray", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -363,7 +363,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, getId) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "jti"); ZVAL_NULL(&_2); @@ -395,7 +395,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, getIssuedAt) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "iat"); ZVAL_NULL(&_2); @@ -427,7 +427,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, getIssuer) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "iss"); ZVAL_NULL(&_2); @@ -459,7 +459,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, getNotBefore) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "nbf"); ZVAL_NULL(&_2); @@ -500,7 +500,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, getSubject) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "sub"); ZVAL_NULL(&_2); @@ -557,7 +557,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, getToken) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 687, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 696, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_0)) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_encryption_security_jwt_exceptions_emptypassphrase_ce); @@ -567,7 +567,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, getToken) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 684, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 693, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_4, this_ptr, "getclaims", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_3, &_2, "__invoke", NULL, 0, &_4); @@ -580,7 +580,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, getToken) zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &claims, "__construct", NULL, 0, &_5, &encodedClaims); zephir_check_call_status(); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 684, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 693, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_8, this_ptr, "getheaders", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_7, &_6, "__invoke", NULL, 0, &_8); @@ -593,10 +593,10 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, getToken) zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &headers, "__construct", NULL, 0, &_9, &encodedHeaders); zephir_check_call_status(); - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 683, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 692, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_11); ZEPHIR_CONCAT_VSV(&_11, &encodedHeaders, ".", &encodedClaims); - zephir_read_property_cached(&_12, this_ptr, _zephir_prop_0, 687, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12, this_ptr, _zephir_prop_0, 696, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&signatureHash, &_10, "sign", NULL, 0, &_11, &_12); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&encodedSignature, this_ptr, "doencodeurl", NULL, 0, &signatureHash); @@ -643,12 +643,12 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, init) ZEPHIR_INIT_VAR(&_0); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 687, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 696, &_0); ZEPHIR_INIT_NVAR(&_0); object_init_ex(&_0, phalcon_support_collection_ce); ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 41); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 686, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 695, &_0); ZEPHIR_INIT_VAR(&_1); object_init_ex(&_1, phalcon_support_collection_ce); ZEPHIR_INIT_VAR(&_2); @@ -657,7 +657,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, init) add_assoc_stringl_ex(&_2, SL("alg"), SL("none")); ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 41, &_2); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 685, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 694, &_1); RETURN_THIS(); } @@ -754,7 +754,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, setContentType) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&contentType_zv); ZVAL_STR_COPY(&contentType_zv, contentType); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 685, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 694, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "cty"); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &_1, &contentType_zv); @@ -1015,7 +1015,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, setPassphrase) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 687, &passphrase_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 696, &passphrase_zv); RETURN_THIS(); } @@ -1089,7 +1089,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, setClaim) value = ZEND_CALL_ARG(execute_data, 2); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &name_zv, value); zephir_check_call_status(); RETURN_THIS(); diff --git a/ext/phalcon/encryption/security/jwt/signer/hmac.zep.c b/ext/phalcon/encryption/security/jwt/signer/hmac.zep.c index f94cf2c0cd..501411b98a 100644 --- a/ext/phalcon/encryption/security/jwt/signer/hmac.zep.c +++ b/ext/phalcon/encryption/security/jwt/signer/hmac.zep.c @@ -92,7 +92,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Signer_Hmac, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 688, &algo_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 697, &algo_zv); ZEPHIR_MM_RESTORE(); } @@ -119,7 +119,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Signer_Hmac, getAlgHeader) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 688, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 697, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "sha"); ZEPHIR_INIT_VAR(&_3); diff --git a/ext/phalcon/encryption/security/jwt/token/item.zep.c b/ext/phalcon/encryption/security/jwt/token/item.zep.c index 330d59e9d6..b8306f6b68 100644 --- a/ext/phalcon/encryption/security/jwt/token/item.zep.c +++ b/ext/phalcon/encryption/security/jwt/token/item.zep.c @@ -123,7 +123,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Item, get) RETVAL_ZVAL(defaultValue, 1, 0); RETURN_MM(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 689, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 698, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_2, &_1, SL("payload"), PH_NOISY | PH_READONLY, "phalcon/Encryption/Security/JWT/Token/Item.zep", 42); zephir_array_fetch(&_3, &_2, &name_zv, PH_NOISY | PH_READONLY, "phalcon/Encryption/Security/JWT/Token/Item.zep", 42); RETURN_CTOR(&_3); @@ -143,7 +143,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Item, getPayload) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("data", 4, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 689, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 698, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_1, &_0, SL("payload"), PH_NOISY | PH_READONLY, "phalcon/Encryption/Security/JWT/Token/Item.zep", 50); RETURN_CTORW(&_1); } @@ -171,7 +171,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Item, has) Z_PARAM_STR(name) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 689, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 698, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_1, &_0, SL("payload"), PH_READONLY, "phalcon/Encryption/Security/JWT/Token/Item.zep", 60); RETURN_BOOL(zephir_array_isset_value(&_1, &name_zv)); } diff --git a/ext/phalcon/encryption/security/jwt/token/parser.zep.c b/ext/phalcon/encryption/security/jwt/token/parser.zep.c index 8c9563ae0a..d417e60a44 100644 --- a/ext/phalcon/encryption/security/jwt/token/parser.zep.c +++ b/ext/phalcon/encryption/security/jwt/token/parser.zep.c @@ -84,7 +84,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Parser, __construct) } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 690, &service); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 699, &service); ZEPHIR_MM_RESTORE(); } @@ -181,7 +181,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Parser, decodeClaims) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&claims_zv); ZVAL_STR_COPY(&claims_zv, claims); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 690, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 699, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "dodecodeurl", NULL, 0, &claims_zv); zephir_check_call_status(); ZVAL_BOOL(&_2, 1); @@ -250,7 +250,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Parser, decodeHeaders) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&headers_zv); ZVAL_STR_COPY(&headers_zv, headers); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 690, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 699, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "dodecodeurl", NULL, 0, &headers_zv); zephir_check_call_status(); ZVAL_BOOL(&_2, 1); diff --git a/ext/phalcon/encryption/security/jwt/token/signature.zep.c b/ext/phalcon/encryption/security/jwt/token/signature.zep.c index 5e97a6d570..cdabf5f779 100644 --- a/ext/phalcon/encryption/security/jwt/token/signature.zep.c +++ b/ext/phalcon/encryption/security/jwt/token/signature.zep.c @@ -98,7 +98,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Signature, getHash) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("data", 4, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 691, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 700, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_1, &_0, SL("hash"), PH_NOISY | PH_READONLY, "phalcon/Encryption/Security/JWT/Token/Signature.zep", 35); RETURN_CTORW(&_1); } diff --git a/ext/phalcon/encryption/security/jwt/token/token.zep.c b/ext/phalcon/encryption/security/jwt/token/token.zep.c index a4174fa040..f46a8bbf70 100644 --- a/ext/phalcon/encryption/security/jwt/token/token.zep.c +++ b/ext/phalcon/encryption/security/jwt/token/token.zep.c @@ -93,9 +93,9 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Token, __construct) Z_PARAM_OBJECT_OF_CLASS(signature, phalcon_encryption_security_jwt_token_signature_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(3, 0, &headers, &claims, &signature); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 692, headers); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 693, claims); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 694, signature); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 701, headers); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 702, claims); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 703, signature); } /** @@ -147,10 +147,10 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Token, getPayload) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 692, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 701, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "getencoded", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 693, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 702, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_3, &_2, "getencoded", NULL, 0); zephir_check_call_status(); ZEPHIR_CONCAT_VSV(return_value, &_1, ".", &_3); @@ -192,7 +192,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Token, getToken) ZEPHIR_CALL_METHOD(&_0, this_ptr, "getpayload", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 694, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 703, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "getencoded", NULL, 0); zephir_check_call_status(); ZEPHIR_CONCAT_VSV(return_value, &_0, ".", &_2); @@ -340,7 +340,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Token, verify) if (!ZEPHIR_IS_IDENTICAL(&_0, &_2)) { RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 694, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 703, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5, &_4, "gethash", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_6, this_ptr, "getpayload", NULL, 0); diff --git a/ext/phalcon/encryption/security/jwt/validator.zep.c b/ext/phalcon/encryption/security/jwt/validator.zep.c index 5958c2a483..1f47b861f1 100644 --- a/ext/phalcon/encryption/security/jwt/validator.zep.c +++ b/ext/phalcon/encryption/security/jwt/validator.zep.c @@ -124,10 +124,10 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, __construct) ZEPHIR_CALL_METHOD(&now, &_0$$3, "gettimestamp", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 695, token); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 704, token); ZVAL_UNDEF(&_1); ZVAL_LONG(&_1, timeShift); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 696, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 705, &_1); ZEPHIR_INIT_VAR(&_2); zephir_create_array(&_2, 7, 0); zephir_array_update_string(&_2, SL("aud"), &__$null, PH_COPY | PH_SEPARATE); @@ -137,7 +137,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, __construct) zephir_array_update_string(&_2, SL("iss"), &__$null, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_2, SL("nbf"), &now, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_2, SL("sub"), &__$null, PH_COPY | PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 697, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 706, &_2); ZEPHIR_MM_RESTORE(); } @@ -178,9 +178,9 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, get) Z_PARAM_STR(claim) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&claim_zv, claim); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 697, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 706, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, &claim_zv)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 697, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 706, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_2$$3, &_1$$3, &claim_zv, PH_NOISY | PH_READONLY, "phalcon/Encryption/Security/JWT/Validator.zep", 103); RETURN_CTORW(&_2$$3); } @@ -235,7 +235,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, setToken) Z_PARAM_OBJECT_OF_CLASS(token, phalcon_encryption_security_jwt_token_token_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &token); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 695, token); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 704, token); RETURN_THISW(); } @@ -276,7 +276,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, validateClaim) value = ZEND_CALL_ARG(execute_data, 2); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 704, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "getclaims", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&claimValue, &_1, "get", NULL, 0, &name_zv); @@ -348,7 +348,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, validateAudience) zephir_array_fast_append(&_2$$4, audience); ZEPHIR_CPY_WRT(audience, &_2$$4); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 704, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_4, &_3, "getclaims", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_5); @@ -436,7 +436,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, validateExpiration) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, ×tamp_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 704, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "getclaims", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_3); @@ -444,7 +444,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, validateExpiration) ZEPHIR_CALL_METHOD(&_2, &_1, "get", NULL, 0, &_3); zephir_check_call_status(); tokenExpirationTime = zephir_get_intval(&_2); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 704, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5, &_4, "getclaims", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_3); @@ -514,7 +514,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, validateId) if (Z_TYPE_P(&id_zv) == IS_NULL) { RETURN_THIS(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 704, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "getclaims", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_3); @@ -567,7 +567,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, validateIssuedAt) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, ×tamp_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 704, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "getclaims", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_3); @@ -634,7 +634,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, validateIssuer) if (Z_TYPE_P(&issuer_zv) == IS_NULL) { RETURN_THIS(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 704, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "getclaims", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_3); @@ -687,7 +687,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, validateNotBefore) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, ×tamp_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 704, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "getclaims", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_3); @@ -746,12 +746,12 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, validateSignature) signer = ZEND_CALL_ARG(execute_data, 1); zephir_memory_observe(&passphrase_zv); ZVAL_STR_COPY(&passphrase_zv, passphrase); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 704, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "getsignature", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_3, &_2, "gethash", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 704, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5, &_4, "getpayload", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_0, signer, "verify", NULL, 0, &_3, &_5, &passphrase_zv); @@ -812,7 +812,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, validateSubject) if (Z_TYPE_P(&subject_zv) == IS_NULL) { RETURN_THIS(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 704, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "getclaims", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_3); @@ -851,7 +851,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, getTimestamp) Z_PARAM_LONG(timestamp) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, ×tamp_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 696, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 705, PH_NOISY_CC | PH_READONLY); RETURN_LONG((timestamp + (zend_long) zephir_get_numberval(&_0))); } diff --git a/ext/phalcon/encryption/security/random.zep.c b/ext/phalcon/encryption/security/random.zep.c index e81bca7300..5709cb0e54 100644 --- a/ext/phalcon/encryption/security/random.zep.c +++ b/ext/phalcon/encryption/security/random.zep.c @@ -363,7 +363,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Random, bytes) len = 16; } ZVAL_LONG(&_0, len); - ZEPHIR_RETURN_CALL_FUNCTION("random_bytes", NULL, 303, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("random_bytes", NULL, 312, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -408,7 +408,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Random, hex) zephir_check_call_status(); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "H*"); - ZEPHIR_CALL_FUNCTION(&_3, "unpack", NULL, 503, &_2, &_0); + ZEPHIR_CALL_FUNCTION(&_3, "unpack", NULL, 0, &_2, &_0); zephir_check_call_status(); ZEPHIR_MAKE_REF(&_3); ZEPHIR_RETURN_CALL_FUNCTION("array_shift", NULL, 40, &_3); @@ -559,7 +559,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Random, base) zephir_check_call_status(); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "C*"); - ZEPHIR_CALL_FUNCTION(&bytes, "unpack", NULL, 503, &_1, &_0); + ZEPHIR_CALL_FUNCTION(&bytes, "unpack", NULL, 0, &_1, &_0); zephir_check_call_status(); zephir_is_iterable(&bytes, 0, "phalcon/Encryption/Security/Random.zep", 330); if (Z_TYPE_P(&bytes) == IS_ARRAY) { diff --git a/ext/phalcon/encryption/security/uuid/randomnodeprovider.zep.c b/ext/phalcon/encryption/security/uuid/randomnodeprovider.zep.c index 493c16470f..f809075459 100644 --- a/ext/phalcon/encryption/security/uuid/randomnodeprovider.zep.c +++ b/ext/phalcon/encryption/security/uuid/randomnodeprovider.zep.c @@ -68,7 +68,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_RandomNodeProvider, getNode) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); ZVAL_LONG(&_0, 6); - ZEPHIR_CALL_FUNCTION(&nodeBytes, "random_bytes", NULL, 303, &_0); + ZEPHIR_CALL_FUNCTION(&nodeBytes, "random_bytes", NULL, 312, &_0); zephir_check_call_status(); ZVAL_LONG(&_0, 0); ZVAL_LONG(&_1, 1); @@ -85,7 +85,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_RandomNodeProvider, getNode) ZEPHIR_INIT_VAR(&_7); ZEPHIR_CONCAT_VV(&_7, &_5, &_6); ZEPHIR_CPY_WRT(&nodeBytes, &_7); - ZEPHIR_RETURN_CALL_FUNCTION("bin2hex", NULL, 304, &nodeBytes); + ZEPHIR_RETURN_CALL_FUNCTION("bin2hex", NULL, 313, &nodeBytes); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/encryption/security/uuid/sysnodeprovider.zep.c b/ext/phalcon/encryption/security/uuid/sysnodeprovider.zep.c index d0ca4f0dc2..1b22fefe8b 100644 --- a/ext/phalcon/encryption/security/uuid/sysnodeprovider.zep.c +++ b/ext/phalcon/encryption/security/uuid/sysnodeprovider.zep.c @@ -133,7 +133,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_SysNodeProvider, getNode) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 698, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 707, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { RETURN_MM_MEMBER_TYPED(getThis(), "node", IS_STRING); } @@ -144,10 +144,10 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_SysNodeProvider, getNode) if (zephir_is_true(&_1)) { ZEPHIR_INIT_VAR(&_3$$4); ZVAL_STRING(&_3$$4, "__phalcon_uuid_node"); - ZEPHIR_CALL_FUNCTION(&cached, "apcu_fetch", NULL, 268, &_3$$4); + ZEPHIR_CALL_FUNCTION(&cached, "apcu_fetch", NULL, 274, &_3$$4); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&cached)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 698, &cached); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 707, &cached); RETURN_MM_MEMBER_TYPED(getThis(), "node", IS_STRING); } } @@ -353,16 +353,16 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_SysNodeProvider, getNode) ZEPHIR_CALL_METHOD(&node, &_52$$20, "getnode", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 698, &node); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 707, &node); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "apcu_store"); ZEPHIR_CALL_METHOD(&_53, this_ptr, "phpfunctionexists", NULL, 0, &_2); zephir_check_call_status(); if (zephir_is_true(&_53)) { - zephir_read_property_cached(&_54$$21, this_ptr, _zephir_prop_0, 698, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_54$$21, this_ptr, _zephir_prop_0, 707, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_55$$21); ZVAL_STRING(&_55$$21, "__phalcon_uuid_node"); - ZEPHIR_CALL_FUNCTION(NULL, "apcu_store", NULL, 270, &_55$$21, &_54$$21); + ZEPHIR_CALL_FUNCTION(NULL, "apcu_store", NULL, 276, &_55$$21, &_54$$21); zephir_check_call_status(); } RETURN_MM_MEMBER_TYPED(getThis(), "node", IS_STRING); @@ -391,7 +391,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_SysNodeProvider, isValidNode) if (zephir_fast_strlen_ev(&node_zv) != 12) { RETURN_MM_BOOL(0); } - ZEPHIR_CALL_FUNCTION(&_0, "ctype_xdigit", NULL, 502, &node_zv); + ZEPHIR_CALL_FUNCTION(&_0, "ctype_xdigit", NULL, 0, &node_zv); zephir_check_call_status(); if (!(zephir_is_true(&_0))) { RETURN_MM_BOOL(0); @@ -870,7 +870,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_SysNodeProvider, phpExtensionLoaded) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 431, &name_zv); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/encryption/security/uuid/version1.zep.c b/ext/phalcon/encryption/security/uuid/version1.zep.c index 3d4a0e7f07..b5ad29ff86 100644 --- a/ext/phalcon/encryption/security/uuid/version1.zep.c +++ b/ext/phalcon/encryption/security/uuid/version1.zep.c @@ -143,7 +143,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version1, __construct) ZEPHIR_INIT_VAR(&timeHi); ZVAL_LONG(&timeHi, (((((timestamp >> 48)) & 0x0fff)) | 0x1000)); ZVAL_LONG(&_5, 2); - ZEPHIR_CALL_FUNCTION(&clockSeqBytes, "random_bytes", NULL, 303, &_5); + ZEPHIR_CALL_FUNCTION(&clockSeqBytes, "random_bytes", NULL, 312, &_5); zephir_check_call_status(); ZVAL_LONG(&_5, 0); ZVAL_LONG(&_6, 1); @@ -171,7 +171,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version1, __construct) ZVAL_STRING(&_13, "%08x-%04x-%04x-%02x%02x-%s"); ZEPHIR_CALL_FUNCTION(&_14, "sprintf", NULL, 145, &_13, &timeLow, &timeMid, &timeHi, &clockSeqHiRes, &clockSeqLow, &nodeStr); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 699, &_14); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 708, &_14); ZEPHIR_MM_RESTORE(); } @@ -202,7 +202,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version1, getDateTime) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 699, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 708, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&parts); zephir_fast_explode_str(&parts, SL("-"), &_0, LONG_MAX); zephir_array_fetch_long(&_1, &parts, 0, PH_NOISY | PH_READONLY, "phalcon/Encryption/Security/Uuid/Version1.zep", 82); @@ -240,7 +240,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version1, getNode) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("uid", 3, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 699, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 708, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1, 24); zephir_substr(return_value, &_0, 24 , 0, ZEPHIR_SUBSTR_NO_LENGTH); return; diff --git a/ext/phalcon/encryption/security/uuid/version3.zep.c b/ext/phalcon/encryption/security/uuid/version3.zep.c index 642ad9c53c..9db3a538ad 100644 --- a/ext/phalcon/encryption/security/uuid/version3.zep.c +++ b/ext/phalcon/encryption/security/uuid/version3.zep.c @@ -123,11 +123,11 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version3, __construct) ZEPHIR_CALL_FUNCTION(&_14, "substr_replace", NULL, 0, &hash, &_12, &_11, &_13); zephir_check_call_status(); ZEPHIR_CPY_WRT(&hash, &_14); - ZEPHIR_CALL_FUNCTION(&_15, "bin2hex", NULL, 304, &hash); + ZEPHIR_CALL_FUNCTION(&_15, "bin2hex", NULL, 313, &hash); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_14, this_ptr, "format", NULL, 0, &_15); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 700, &_14); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 709, &_14); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/encryption/security/uuid/version4.zep.c b/ext/phalcon/encryption/security/uuid/version4.zep.c index 2ffc968347..dcbf15ad2b 100644 --- a/ext/phalcon/encryption/security/uuid/version4.zep.c +++ b/ext/phalcon/encryption/security/uuid/version4.zep.c @@ -70,11 +70,11 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version4, __construct) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); ZVAL_LONG(&_0, 16); - ZEPHIR_CALL_FUNCTION(&_1, "random_bytes", NULL, 303, &_0); + ZEPHIR_CALL_FUNCTION(&_1, "random_bytes", NULL, 312, &_0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "N1a/n1b/n1c/n1d/n1e/N1f"); - ZEPHIR_CALL_FUNCTION(&_3, "unpack", NULL, 503, &_2, &_1); + ZEPHIR_CALL_FUNCTION(&_3, "unpack", NULL, 0, &_2, &_1); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&ary, "array_values", NULL, 27, &_3); zephir_check_call_status(); @@ -97,7 +97,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version4, __construct) ZVAL_STRING(&_8, "sprintf"); ZEPHIR_CALL_USER_FUNC_ARRAY(&_7, &_8, &ary); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 701, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 710, &_7); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/encryption/security/uuid/version5.zep.c b/ext/phalcon/encryption/security/uuid/version5.zep.c index 9cc4c789bd..81e24f59af 100644 --- a/ext/phalcon/encryption/security/uuid/version5.zep.c +++ b/ext/phalcon/encryption/security/uuid/version5.zep.c @@ -131,11 +131,11 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version5, __construct) ZEPHIR_CALL_FUNCTION(&_17, "substr_replace", NULL, 0, &hash, &_15, &_14, &_16); zephir_check_call_status(); ZEPHIR_CPY_WRT(&hash, &_17); - ZEPHIR_CALL_FUNCTION(&_18, "bin2hex", NULL, 304, &hash); + ZEPHIR_CALL_FUNCTION(&_18, "bin2hex", NULL, 313, &hash); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_17, this_ptr, "format", NULL, 0, &_18); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 702, &_17); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 711, &_17); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/encryption/security/uuid/version6.zep.c b/ext/phalcon/encryption/security/uuid/version6.zep.c index e3d81f0fbf..e988200486 100644 --- a/ext/phalcon/encryption/security/uuid/version6.zep.c +++ b/ext/phalcon/encryption/security/uuid/version6.zep.c @@ -106,7 +106,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version6, __construct) ZEPHIR_INIT_VAR(&timeLow12); ZVAL_LONG(&timeLow12, (0x6000 | ((timestamp & 0x0fff)))); ZVAL_LONG(&_3, 2); - ZEPHIR_CALL_FUNCTION(&clockSeqBytes, "random_bytes", NULL, 303, &_3); + ZEPHIR_CALL_FUNCTION(&clockSeqBytes, "random_bytes", NULL, 312, &_3); zephir_check_call_status(); ZVAL_LONG(&_3, 0); ZVAL_LONG(&_4, 1); @@ -130,7 +130,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version6, __construct) ZVAL_STRING(&_11, "%08x-%04x-%04x-%02x%02x-%s"); ZEPHIR_CALL_FUNCTION(&_12, "sprintf", NULL, 145, &_11, &timeHigh32, &timeMid16, &timeLow12, &clockSeqHiRes, &clockSeqLow, &nodeStr); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 703, &_12); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 712, &_12); ZEPHIR_MM_RESTORE(); } @@ -161,7 +161,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version6, getDateTime) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 703, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 712, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&parts); zephir_fast_explode_str(&parts, SL("-"), &_0, LONG_MAX); zephir_array_fetch_long(&_1, &parts, 0, PH_NOISY | PH_READONLY, "phalcon/Encryption/Security/Uuid/Version6.zep", 69); @@ -199,7 +199,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version6, getNode) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("uid", 3, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 703, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 712, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1, 24); zephir_substr(return_value, &_0, 24 , 0, ZEPHIR_SUBSTR_NO_LENGTH); return; diff --git a/ext/phalcon/encryption/security/uuid/version7.zep.c b/ext/phalcon/encryption/security/uuid/version7.zep.c index 4f030f177f..d2c7d16bca 100644 --- a/ext/phalcon/encryption/security/uuid/version7.zep.c +++ b/ext/phalcon/encryption/security/uuid/version7.zep.c @@ -96,13 +96,13 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version7, __construct) ZEPHIR_INIT_VAR(&timeLow16); ZVAL_LONG(&timeLow16, (msInt & 0xffff)); ZVAL_LONG(&_2, 10); - ZEPHIR_CALL_FUNCTION(&randBytes, "random_bytes", NULL, 303, &_2); + ZEPHIR_CALL_FUNCTION(&randBytes, "random_bytes", NULL, 312, &_2); zephir_check_call_status(); ZVAL_LONG(&_2, 0); ZVAL_LONG(&_3, 2); ZEPHIR_INIT_VAR(&_4); zephir_substr(&_4, &randBytes, 0 , 2 , 0); - ZEPHIR_CALL_FUNCTION(&_5, "bin2hex", NULL, 304, &_4); + ZEPHIR_CALL_FUNCTION(&_5, "bin2hex", NULL, 313, &_4); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&_6, "hexdec", NULL, 0, &_5); zephir_check_call_status(); @@ -112,7 +112,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version7, __construct) ZVAL_LONG(&_8, 2); ZEPHIR_INIT_VAR(&_9); zephir_substr(&_9, &randBytes, 2 , 2 , 0); - ZEPHIR_CALL_FUNCTION(&_10, "bin2hex", NULL, 304, &_9); + ZEPHIR_CALL_FUNCTION(&_10, "bin2hex", NULL, 313, &_9); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&_11, "hexdec", NULL, 0, &_10); zephir_check_call_status(); @@ -122,13 +122,13 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version7, __construct) ZVAL_LONG(&_13, 6); ZEPHIR_INIT_VAR(&_14); zephir_substr(&_14, &randBytes, 4 , 6 , 0); - ZEPHIR_CALL_FUNCTION(&_15, "bin2hex", NULL, 304, &_14); + ZEPHIR_CALL_FUNCTION(&_15, "bin2hex", NULL, 313, &_14); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_16); ZVAL_STRING(&_16, "%08x-%04x-%04x-%04x-%s"); ZEPHIR_CALL_FUNCTION(&_17, "sprintf", NULL, 145, &_16, &timeHigh32, &timeLow16, &verRandA, &varRandB, &_15); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 704, &_17); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 713, &_17); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/events/event.zep.c b/ext/phalcon/events/event.zep.c index f6a1911a1d..fa3982d125 100644 --- a/ext/phalcon/events/event.zep.c +++ b/ext/phalcon/events/event.zep.c @@ -166,13 +166,13 @@ PHP_METHOD(Phalcon_Events_Event, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 705, &type_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 706, source); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 707, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 714, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 715, source); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 716, data); if (cancelable) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 708, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 717, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 708, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 717, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -254,7 +254,7 @@ PHP_METHOD(Phalcon_Events_Event, setData) data = &data_sub; data = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 707, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 716, data); RETURN_THISW(); } @@ -277,7 +277,7 @@ PHP_METHOD(Phalcon_Events_Event, setType) Z_PARAM_STR(type) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&type_zv, type); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 705, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 714, &type_zv); RETURN_THISW(); } @@ -312,7 +312,7 @@ PHP_METHOD(Phalcon_Events_Event, stop) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 708, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 717, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(!zephir_is_true(&_0))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_events_exceptions_eventnotcancelable_ce); @@ -323,9 +323,9 @@ PHP_METHOD(Phalcon_Events_Event, stop) return; } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 709, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 718, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 709, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 718, &__$false); } RETURN_THIS(); } diff --git a/ext/phalcon/events/manager.zep.c b/ext/phalcon/events/manager.zep.c index c21b738a85..4bfde2913c 100644 --- a/ext/phalcon/events/manager.zep.c +++ b/ext/phalcon/events/manager.zep.c @@ -213,7 +213,7 @@ PHP_METHOD(Phalcon_Events_Manager, addSubscriber) ZEPHIR_INIT_VAR(&className); zephir_get_class(&className, subscriber, 0); zephir_memory_observe(&events); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 710, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 719, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&events, &_1, &className, 0))) { _2$$3 = zephir_fetch_class(&className); ZEPHIR_CALL_CE_STATIC(&events, _2$$3, "getsubscribedevents", NULL, 0); @@ -400,7 +400,7 @@ PHP_METHOD(Phalcon_Events_Manager, clearSubscribers) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&snapshot); - zephir_read_property_cached(&snapshot, this_ptr, _zephir_prop_0, 711, PH_NOISY_CC); + zephir_read_property_cached(&snapshot, this_ptr, _zephir_prop_0, 720, PH_NOISY_CC); zephir_is_iterable(&snapshot, 0, "phalcon/Events/Manager.zep", 272); if (Z_TYPE_P(&snapshot) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&snapshot), _0) @@ -458,9 +458,9 @@ PHP_METHOD(Phalcon_Events_Manager, collectResponses) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &collect_param); if (collect) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 712, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 721, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 712, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 721, &__$false); } } @@ -516,7 +516,7 @@ PHP_METHOD(Phalcon_Events_Manager, detach) return; } zephir_memory_observe(&queue); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&queue, &_2, &eventType_zv, 0)) { ZEPHIR_INIT_VAR(&newQueue); array_init(&newQueue); @@ -560,7 +560,7 @@ PHP_METHOD(Phalcon_Events_Manager, detach) zephir_update_property_array(this_ptr, SL("events"), &eventType_zv, &newQueue); } else { zephir_unset_property_array(this_ptr, ZEND_STRL("events"), &eventType_zv); - zephir_read_property_cached(&_8$$10, this_ptr, _zephir_prop_0, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$10, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_8$$10, &eventType_zv, PH_SEPARATE); } } @@ -602,12 +602,12 @@ PHP_METHOD(Phalcon_Events_Manager, detachAll) if (ZEPHIR_IS_NULL(&type_zv)) { ZEPHIR_INIT_VAR(&_0$$3); array_init(&_0$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 713, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 722, &_0$$3); } else { - zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_0, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_1$$4, &type_zv)) { zephir_unset_property_array(this_ptr, ZEND_STRL("events"), &type_zv); - zephir_read_property_cached(&_2$$5, this_ptr, _zephir_prop_0, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$5, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_2$$5, &type_zv, PH_SEPARATE); } } @@ -674,7 +674,7 @@ PHP_METHOD(Phalcon_Events_Manager, dispatch) source = &source_sub; source = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_0)) { RETURN_MM_NULL(); } @@ -705,7 +705,7 @@ PHP_METHOD(Phalcon_Events_Manager, dispatch) _4 = Z_TYPE_P(name) != IS_NULL; if (_4) { zephir_memory_observe(&queue); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); _4 = zephir_array_isset_fetch(&queue, &_5, name, 0); } if (_4) { @@ -716,7 +716,7 @@ PHP_METHOD(Phalcon_Events_Manager, dispatch) ZEPHIR_INIT_VAR(&eventClassName); zephir_get_class(&eventClassName, event, 0); ZEPHIR_OBS_NVAR(&queue); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&queue, &_6, &eventClassName, 0)) { ZEPHIR_RETURN_CALL_METHOD(this_ptr, "runobjectqueue", NULL, 0, &queue, event, &methodName); zephir_check_call_status(); @@ -754,9 +754,9 @@ PHP_METHOD(Phalcon_Events_Manager, enablePriorities) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &enablePriorities_param); if (enablePriorities) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 714, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 723, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 714, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 723, &__$false); } } @@ -885,7 +885,7 @@ PHP_METHOD(Phalcon_Events_Manager, fire) cancelable = 1; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 715, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 724, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { RETURN_MM_NULL(); } @@ -899,9 +899,9 @@ PHP_METHOD(Phalcon_Events_Manager, fire) if (ZEPHIR_IS_FALSE_IDENTICAL(&_1)) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 722, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_3)) { - zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_2, 716, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_2, 725, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(zephir_is_true(&_4$$5))) { ZEPHIR_INIT_VAR(&_5$$6); object_init_ex(&_5$$6, phalcon_events_exceptions_nolistenersforevent_ce); @@ -914,7 +914,7 @@ PHP_METHOD(Phalcon_Events_Manager, fire) RETURN_MM_NULL(); } zephir_memory_observe(&cached); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_3, 717, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_3, 726, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&cached, &_6, &eventType_zv, 0)) { zephir_memory_observe(&type); zephir_array_fetch_long(&type, &cached, 0, PH_NOISY, "phalcon/Events/Manager.zep", 445); @@ -946,16 +946,16 @@ PHP_METHOD(Phalcon_Events_Manager, fire) zephir_array_fast_append(&_11$$8, &eventName); zephir_update_property_array(this_ptr, SL("eventNameCache"), &eventType_zv, &_11$$8); } - zephir_read_property_cached(&_12, this_ptr, _zephir_prop_1, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12, this_ptr, _zephir_prop_1, 722, PH_NOISY_CC | PH_READONLY); hasTypeQueue = zephir_array_isset_value(&_12, &type); - zephir_read_property_cached(&_13, this_ptr, _zephir_prop_1, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13, this_ptr, _zephir_prop_1, 722, PH_NOISY_CC | PH_READONLY); hasFullQueue = zephir_array_isset_value(&_13, &eventType_zv); _14 = !hasTypeQueue; if (_14) { _14 = !hasFullQueue; } if (_14) { - zephir_read_property_cached(&_15$$10, this_ptr, _zephir_prop_2, 716, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$10, this_ptr, _zephir_prop_2, 725, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(zephir_is_true(&_15$$10))) { ZEPHIR_INIT_VAR(&_16$$11); object_init_ex(&_16$$11, phalcon_events_exceptions_nolistenersforevent_ce); @@ -968,20 +968,20 @@ PHP_METHOD(Phalcon_Events_Manager, fire) RETURN_MM_NULL(); } zephir_memory_observe(&wasDepth); - zephir_read_property_cached(&wasDepth, this_ptr, _zephir_prop_4, 718, PH_NOISY_CC); + zephir_read_property_cached(&wasDepth, this_ptr, _zephir_prop_4, 727, PH_NOISY_CC); ZVAL_UNDEF(&_17); ZVAL_LONG(&_17, (zephir_get_numberval(&wasDepth) + 1)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 718, &_17); - zephir_read_property_cached(&_17, this_ptr, _zephir_prop_5, 712, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 727, &_17); + zephir_read_property_cached(&_17, this_ptr, _zephir_prop_5, 721, PH_NOISY_CC | PH_READONLY); collect = zephir_is_true(&_17); if (collect) { if (ZEPHIR_GT_LONG(&wasDepth, 0)) { zephir_memory_observe(&stashed); - zephir_read_property_cached(&stashed, this_ptr, _zephir_prop_6, 719, PH_NOISY_CC); + zephir_read_property_cached(&stashed, this_ptr, _zephir_prop_6, 728, PH_NOISY_CC); } ZEPHIR_INIT_VAR(&_18$$12); array_init(&_18$$12); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 719, &_18$$12); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 728, &_18$$12); } /* try_start_1: */ @@ -998,7 +998,7 @@ PHP_METHOD(Phalcon_Events_Manager, fire) ZEPHIR_INIT_VAR(&status); ZVAL_NULL(&status); if (hasTypeQueue) { - zephir_read_property_cached(&_20$$15, this_ptr, _zephir_prop_1, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$15, this_ptr, _zephir_prop_1, 722, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&fireEvents); zephir_array_fetch(&fireEvents, &_20$$15, &type, PH_NOISY, "phalcon/Events/Manager.zep", 498); if (cancelable) { @@ -1015,7 +1015,7 @@ PHP_METHOD(Phalcon_Events_Manager, fire) zephir_check_call_status_or_jump(try_end_1); } zephir_memory_observe(&_23$$14); - zephir_read_property_cached(&_23$$14, this_ptr, _zephir_prop_7, 720, PH_NOISY_CC); + zephir_read_property_cached(&_23$$14, this_ptr, _zephir_prop_7, 729, PH_NOISY_CC); _24$$14 = zephir_is_true(&_23$$14); if (_24$$14) { _24$$14 = cancelable; @@ -1039,7 +1039,7 @@ PHP_METHOD(Phalcon_Events_Manager, fire) _27$$14 = _28$$14; } if (_27$$14) { - zephir_read_property_cached(&_30$$16, this_ptr, _zephir_prop_1, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_30$$16, this_ptr, _zephir_prop_1, 722, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&fireEvents); zephir_array_fetch(&fireEvents, &_30$$16, &eventType_zv, PH_NOISY, "phalcon/Events/Manager.zep", 517); if (cancelable) { @@ -1070,9 +1070,9 @@ PHP_METHOD(Phalcon_Events_Manager, fire) _34$$17 = ZEPHIR_GT_LONG(&wasDepth, 0); } if (_34$$17) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 719, &stashed); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 728, &stashed); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 718, &wasDepth); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 727, &wasDepth); zephir_throw_exception_debug(&ex, "phalcon/Events/Manager.zep", 534); ZEPHIR_MM_RESTORE(); return; @@ -1083,9 +1083,9 @@ PHP_METHOD(Phalcon_Events_Manager, fire) _35 = ZEPHIR_GT_LONG(&wasDepth, 0); } if (_35) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 719, &stashed); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 728, &stashed); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 718, &wasDepth); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 727, &wasDepth); if (cancelable) { ZVAL_BOOL(&_36, 1); } else { @@ -1213,14 +1213,14 @@ PHP_METHOD(Phalcon_Events_Manager, fireAll) cancelable = 1; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 715, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 724, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { array_init(return_value); RETURN_MM(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 722, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_1)) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 716, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 725, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(zephir_is_true(&_2$$4))) { ZEPHIR_INIT_VAR(&_3$$5); object_init_ex(&_3$$5, phalcon_events_exceptions_nolistenersforevent_ce); @@ -1234,7 +1234,7 @@ PHP_METHOD(Phalcon_Events_Manager, fireAll) RETURN_MM(); } zephir_memory_observe(&cached); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 717, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 726, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&cached, &_4, &eventType_zv, 0)) { zephir_memory_observe(&type); zephir_array_fetch_long(&type, &cached, 0, PH_NOISY, "phalcon/Events/Manager.zep", 582); @@ -1266,16 +1266,16 @@ PHP_METHOD(Phalcon_Events_Manager, fireAll) zephir_array_fast_append(&_9$$7, &eventName); zephir_update_property_array(this_ptr, SL("eventNameCache"), &eventType_zv, &_9$$7); } - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_1, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_1, 722, PH_NOISY_CC | PH_READONLY); hasTypeQueue = zephir_array_isset_value(&_10, &type); - zephir_read_property_cached(&_11, this_ptr, _zephir_prop_1, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11, this_ptr, _zephir_prop_1, 722, PH_NOISY_CC | PH_READONLY); hasFullQueue = zephir_array_isset_value(&_11, &eventType_zv); _12 = !hasTypeQueue; if (_12) { _12 = !hasFullQueue; } if (_12) { - zephir_read_property_cached(&_13$$9, this_ptr, _zephir_prop_2, 716, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$9, this_ptr, _zephir_prop_2, 725, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(zephir_is_true(&_13$$9))) { ZEPHIR_INIT_VAR(&_14$$10); object_init_ex(&_14$$10, phalcon_events_exceptions_nolistenersforevent_ce); @@ -1289,15 +1289,15 @@ PHP_METHOD(Phalcon_Events_Manager, fireAll) RETURN_MM(); } zephir_memory_observe(&wasDepth); - zephir_read_property_cached(&wasDepth, this_ptr, _zephir_prop_4, 718, PH_NOISY_CC); + zephir_read_property_cached(&wasDepth, this_ptr, _zephir_prop_4, 727, PH_NOISY_CC); ZVAL_UNDEF(&_15); ZVAL_LONG(&_15, (zephir_get_numberval(&wasDepth) + 1)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 718, &_15); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 727, &_15); zephir_memory_observe(&stashed); - zephir_read_property_cached(&stashed, this_ptr, _zephir_prop_5, 719, PH_NOISY_CC); + zephir_read_property_cached(&stashed, this_ptr, _zephir_prop_5, 728, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_16); array_init(&_16); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 719, &_16); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 728, &_16); /* try_start_1: */ @@ -1313,7 +1313,7 @@ PHP_METHOD(Phalcon_Events_Manager, fireAll) ZEPHIR_INIT_VAR(&dispatchStatus); ZVAL_NULL(&dispatchStatus); if (hasTypeQueue) { - zephir_read_property_cached(&_18$$12, this_ptr, _zephir_prop_1, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$12, this_ptr, _zephir_prop_1, 722, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&fireEvents); zephir_array_fetch(&fireEvents, &_18$$12, &type, PH_NOISY, "phalcon/Events/Manager.zep", 620); if (cancelable) { @@ -1326,7 +1326,7 @@ PHP_METHOD(Phalcon_Events_Manager, fireAll) zephir_check_call_status_or_jump(try_end_1); } zephir_memory_observe(&_21$$11); - zephir_read_property_cached(&_21$$11, this_ptr, _zephir_prop_6, 720, PH_NOISY_CC); + zephir_read_property_cached(&_21$$11, this_ptr, _zephir_prop_6, 729, PH_NOISY_CC); _22$$11 = zephir_is_true(&_21$$11); if (_22$$11) { _22$$11 = cancelable; @@ -1350,7 +1350,7 @@ PHP_METHOD(Phalcon_Events_Manager, fireAll) _25$$11 = _26$$11; } if (_25$$11) { - zephir_read_property_cached(&_28$$13, this_ptr, _zephir_prop_1, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$13, this_ptr, _zephir_prop_1, 722, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&fireEvents); zephir_array_fetch(&fireEvents, &_28$$13, &eventType_zv, PH_NOISY, "phalcon/Events/Manager.zep", 637); if (cancelable) { @@ -1372,17 +1372,17 @@ PHP_METHOD(Phalcon_Events_Manager, fireAll) if (zephir_is_instance_of(&_31, SL("Throwable"))) { zend_clear_exception(); ZEPHIR_CPY_WRT(&ex, &_31); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 719, &stashed); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 718, &wasDepth); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 728, &stashed); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 727, &wasDepth); zephir_throw_exception_debug(&ex, "phalcon/Events/Manager.zep", 651); ZEPHIR_MM_RESTORE(); return; } } - zephir_read_property_cached(&_15, this_ptr, _zephir_prop_5, 719, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15, this_ptr, _zephir_prop_5, 728, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&responses, &_15); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 719, &stashed); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 718, &wasDepth); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 728, &stashed); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 727, &wasDepth); RETURN_CCTOR(&responses); } @@ -1429,7 +1429,7 @@ PHP_METHOD(Phalcon_Events_Manager, fireQueue) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 2, 0, &queue_param, &event); zephir_get_arrval(&queue, queue_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 715, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 724, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { RETURN_MM_NULL(); } @@ -1441,7 +1441,7 @@ PHP_METHOD(Phalcon_Events_Manager, fireQueue) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_4, event, "iscancelable", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 712, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 721, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "runqueue", NULL, 0, &queue, event, &_1, &_2, &_3, &_4, &_5); zephir_check_call_status(); RETURN_MM(); @@ -1466,9 +1466,9 @@ PHP_METHOD(Phalcon_Events_Manager, halt) _zephir_prop_0 = zend_string_init("halted", 6, 1); } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 715, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 724, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 715, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 724, &__$false); } } @@ -1508,7 +1508,7 @@ PHP_METHOD(Phalcon_Events_Manager, getListeners) ZEPHIR_INIT_VAR(&listeners); array_init(&listeners); zephir_memory_observe(&queue); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&queue, &_0, &type_zv, 0)) { zephir_is_iterable(&queue, 0, "phalcon/Events/Manager.zep", 714); if (Z_TYPE_P(&queue) == IS_ARRAY) { @@ -1585,7 +1585,7 @@ PHP_METHOD(Phalcon_Events_Manager, getSubscribers) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 711, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 720, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_FUNCTION("array_values", NULL, 27, &_0); zephir_check_call_status(); RETURN_MM(); @@ -1611,7 +1611,7 @@ PHP_METHOD(Phalcon_Events_Manager, hasListeners) Z_PARAM_STR(type) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&type_zv, type); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &type_zv)); } @@ -1721,17 +1721,17 @@ PHP_METHOD(Phalcon_Events_Manager, removeSubscriber) zephir_fetch_params(1, 1, 0, &subscriber); ZEPHIR_CALL_FUNCTION(&key, "spl_object_id", NULL, 52, subscriber); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 711, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 720, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_0, &key))) { RETURN_MM_NULL(); } zephir_unset_property_array(this_ptr, ZEND_STRL("subscribers"), &key); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 711, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 720, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_1, &key, PH_SEPARATE); ZEPHIR_INIT_VAR(&className); zephir_get_class(&className, subscriber, 0); zephir_memory_observe(&events); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 710, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 719, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&events, &_2, &className, 0))) { _3$$4 = zephir_fetch_class(&className); ZEPHIR_CALL_CE_STATIC(&events, _3$$4, "getsubscribedevents", NULL, 0); @@ -1800,9 +1800,9 @@ PHP_METHOD(Phalcon_Events_Manager, resume) _zephir_prop_0 = zend_string_init("halted", 6, 1); } if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 715, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 724, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 715, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 724, &__$false); } } @@ -1831,7 +1831,7 @@ PHP_METHOD(Phalcon_Events_Manager, setMethodExistsCacheLimit) zephir_fetch_params_without_memory_grow(1, 0, &methodExistsCacheLimit_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, methodExistsCacheLimit); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 721, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 730, &_0); } /** @@ -1861,9 +1861,9 @@ PHP_METHOD(Phalcon_Events_Manager, setStopOnFalse) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &flag_param); if (flag) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 720, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 729, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 720, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 729, &__$false); } } @@ -1889,9 +1889,9 @@ PHP_METHOD(Phalcon_Events_Manager, setStrict) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &strict_param); if (strict) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 716, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 725, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 716, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 725, &__$false); } } @@ -2041,7 +2041,7 @@ PHP_METHOD(Phalcon_Events_Manager, runObjectQueue) zephir_get_arrval(&queue, queue_param); ZEPHIR_INIT_VAR(&status); ZVAL_NULL(&status); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 712, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 721, PH_NOISY_CC | PH_READONLY); collect = zephir_is_true(&_0); zephir_is_iterable(&queue, 0, "phalcon/Events/Manager.zep", 965); if (Z_TYPE_P(&queue) == IS_ARRAY) { @@ -2309,31 +2309,31 @@ PHP_METHOD(Phalcon_Events_Manager, runQueue) } else if (ZEPHIR_IS_LONG(&type, 2)) { zephir_memory_observe(&handlerClass); zephir_array_fetch_long(&handlerClass, &tuple, 3, PH_NOISY, "phalcon/Events/Manager.zep", 1022); - zephir_read_property_cached(&_0$$6, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$6, this_ptr, _zephir_prop_0, 731, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_1$$6, &_0$$6, &handlerClass, PH_READONLY, "phalcon/Events/Manager.zep", 1024); if (!(zephir_array_isset_value(&_1$$6, &eventName_zv))) { - zephir_read_property_cached(&_2$$7, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$7, this_ptr, _zephir_prop_0, 731, PH_NOISY_CC | PH_READONLY); _3$$7 = !(zephir_array_isset_value(&_2$$7, &handlerClass)); if (_3$$7) { - zephir_read_property_cached(&_4$$7, this_ptr, _zephir_prop_1, 721, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$7, this_ptr, _zephir_prop_1, 730, PH_NOISY_CC | PH_READONLY); _3$$7 = ZEPHIR_GT_LONG(&_4$$7, 0); } _5$$7 = _3$$7; if (_5$$7) { - zephir_read_property_cached(&_6$$7, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$7, this_ptr, _zephir_prop_1, 721, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$7, this_ptr, _zephir_prop_0, 731, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$7, this_ptr, _zephir_prop_1, 730, PH_NOISY_CC | PH_READONLY); _5$$7 = ZEPHIR_LE_LONG(&_7$$7, zephir_fast_count_int(&_6$$7)); } if (_5$$7) { ZEPHIR_INIT_VAR(&_8$$8); array_init(&_8$$8); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 722, &_8$$8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 731, &_8$$8); } ZEPHIR_INIT_VAR(&_9$$7); ZVAL_BOOL(&_9$$7, (zephir_method_exists(&handler, &eventName_zv) == SUCCESS)); zephir_update_property_array_multi(this_ptr, SL("methodExistsCache"), &_9$$7, SL("zz"), 2, &handlerClass, &eventName_zv); } - zephir_read_property_cached(&_10$$6, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$6, this_ptr, _zephir_prop_0, 731, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_11$$6, &_10$$6, &handlerClass, PH_NOISY | PH_READONLY, "phalcon/Events/Manager.zep", 1033); zephir_array_fetch(&_12$$6, &_11$$6, &eventName_zv, PH_NOISY | PH_READONLY, "phalcon/Events/Manager.zep", 1033); if (!(zephir_is_true(&_12$$6))) { @@ -2354,7 +2354,7 @@ PHP_METHOD(Phalcon_Events_Manager, runQueue) if (collect) { zephir_update_property_array_append(this_ptr, SL("responses"), &ret); } - zephir_read_property_cached(&_14$$3, this_ptr, _zephir_prop_2, 720, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$3, this_ptr, _zephir_prop_2, 729, PH_NOISY_CC | PH_READONLY); _15$$3 = zephir_is_true(&_14$$3); if (_15$$3) { _15$$3 = cancelable; @@ -2391,31 +2391,31 @@ PHP_METHOD(Phalcon_Events_Manager, runQueue) } else if (ZEPHIR_IS_LONG(&type, 2)) { ZEPHIR_OBS_NVAR(&handlerClass); zephir_array_fetch_long(&handlerClass, &tuple, 3, PH_NOISY, "phalcon/Events/Manager.zep", 1076); - zephir_read_property_cached(&_18$$16, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$16, this_ptr, _zephir_prop_0, 731, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_19$$16, &_18$$16, &handlerClass, PH_READONLY, "phalcon/Events/Manager.zep", 1078); if (!(zephir_array_isset_value(&_19$$16, &eventName_zv))) { - zephir_read_property_cached(&_20$$17, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$17, this_ptr, _zephir_prop_0, 731, PH_NOISY_CC | PH_READONLY); _21$$17 = !(zephir_array_isset_value(&_20$$17, &handlerClass)); if (_21$$17) { - zephir_read_property_cached(&_22$$17, this_ptr, _zephir_prop_1, 721, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$17, this_ptr, _zephir_prop_1, 730, PH_NOISY_CC | PH_READONLY); _21$$17 = ZEPHIR_GT_LONG(&_22$$17, 0); } _23$$17 = _21$$17; if (_23$$17) { - zephir_read_property_cached(&_24$$17, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_25$$17, this_ptr, _zephir_prop_1, 721, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24$$17, this_ptr, _zephir_prop_0, 731, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$17, this_ptr, _zephir_prop_1, 730, PH_NOISY_CC | PH_READONLY); _23$$17 = ZEPHIR_LE_LONG(&_25$$17, zephir_fast_count_int(&_24$$17)); } if (_23$$17) { ZEPHIR_INIT_NVAR(&_26$$18); array_init(&_26$$18); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 722, &_26$$18); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 731, &_26$$18); } ZEPHIR_INIT_NVAR(&_27$$17); ZVAL_BOOL(&_27$$17, (zephir_method_exists(&handler, &eventName_zv) == SUCCESS)); zephir_update_property_array_multi(this_ptr, SL("methodExistsCache"), &_27$$17, SL("zz"), 2, &handlerClass, &eventName_zv); } - zephir_read_property_cached(&_28$$16, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$16, this_ptr, _zephir_prop_0, 731, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_29$$16, &_28$$16, &handlerClass, PH_NOISY | PH_READONLY, "phalcon/Events/Manager.zep", 1087); zephir_array_fetch(&_30$$16, &_29$$16, &eventName_zv, PH_NOISY | PH_READONLY, "phalcon/Events/Manager.zep", 1087); if (!(zephir_is_true(&_30$$16))) { @@ -2436,7 +2436,7 @@ PHP_METHOD(Phalcon_Events_Manager, runQueue) if (collect) { zephir_update_property_array_append(this_ptr, SL("responses"), &ret); } - zephir_read_property_cached(&_32$$13, this_ptr, _zephir_prop_2, 720, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_32$$13, this_ptr, _zephir_prop_2, 729, PH_NOISY_CC | PH_READONLY); _33$$13 = zephir_is_true(&_32$$13); if (_33$$13) { _33$$13 = cancelable; @@ -2496,31 +2496,31 @@ PHP_METHOD(Phalcon_Events_Manager, runQueue) } else if (ZEPHIR_IS_LONG(&type, 2)) { ZEPHIR_OBS_NVAR(&handlerClass); zephir_array_fetch_long(&handlerClass, &tuple, 3, PH_NOISY, "phalcon/Events/Manager.zep", 1076); - zephir_read_property_cached(&_39$$28, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_39$$28, this_ptr, _zephir_prop_0, 731, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_40$$28, &_39$$28, &handlerClass, PH_READONLY, "phalcon/Events/Manager.zep", 1078); if (!(zephir_array_isset_value(&_40$$28, &eventName_zv))) { - zephir_read_property_cached(&_41$$29, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_41$$29, this_ptr, _zephir_prop_0, 731, PH_NOISY_CC | PH_READONLY); _42$$29 = !(zephir_array_isset_value(&_41$$29, &handlerClass)); if (_42$$29) { - zephir_read_property_cached(&_43$$29, this_ptr, _zephir_prop_1, 721, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_43$$29, this_ptr, _zephir_prop_1, 730, PH_NOISY_CC | PH_READONLY); _42$$29 = ZEPHIR_GT_LONG(&_43$$29, 0); } _44$$29 = _42$$29; if (_44$$29) { - zephir_read_property_cached(&_45$$29, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_46$$29, this_ptr, _zephir_prop_1, 721, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_45$$29, this_ptr, _zephir_prop_0, 731, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_46$$29, this_ptr, _zephir_prop_1, 730, PH_NOISY_CC | PH_READONLY); _44$$29 = ZEPHIR_LE_LONG(&_46$$29, zephir_fast_count_int(&_45$$29)); } if (_44$$29) { ZEPHIR_INIT_NVAR(&_47$$30); array_init(&_47$$30); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 722, &_47$$30); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 731, &_47$$30); } ZEPHIR_INIT_NVAR(&_48$$29); ZVAL_BOOL(&_48$$29, (zephir_method_exists(&handler, &eventName_zv) == SUCCESS)); zephir_update_property_array_multi(this_ptr, SL("methodExistsCache"), &_48$$29, SL("zz"), 2, &handlerClass, &eventName_zv); } - zephir_read_property_cached(&_49$$28, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_49$$28, this_ptr, _zephir_prop_0, 731, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_50$$28, &_49$$28, &handlerClass, PH_NOISY | PH_READONLY, "phalcon/Events/Manager.zep", 1087); zephir_array_fetch(&_51$$28, &_50$$28, &eventName_zv, PH_NOISY | PH_READONLY, "phalcon/Events/Manager.zep", 1087); if (!(zephir_is_true(&_51$$28))) { @@ -2541,7 +2541,7 @@ PHP_METHOD(Phalcon_Events_Manager, runQueue) if (collect) { zephir_update_property_array_append(this_ptr, SL("responses"), &ret); } - zephir_read_property_cached(&_53$$25, this_ptr, _zephir_prop_2, 720, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_53$$25, this_ptr, _zephir_prop_2, 729, PH_NOISY_CC | PH_READONLY); _54$$25 = zephir_is_true(&_53$$25); if (_54$$25) { _54$$25 = cancelable; @@ -2645,7 +2645,7 @@ PHP_METHOD(Phalcon_Events_Manager, insertHandlerEntry) className = &__$null; } zephir_memory_observe(&prioritiesOn); - zephir_read_property_cached(&prioritiesOn, this_ptr, _zephir_prop_0, 714, PH_NOISY_CC); + zephir_read_property_cached(&prioritiesOn, this_ptr, _zephir_prop_0, 723, PH_NOISY_CC); if (!(zephir_is_true(&prioritiesOn))) { priority = 100; } @@ -2675,7 +2675,7 @@ PHP_METHOD(Phalcon_Events_Manager, insertHandlerEntry) ZEPHIR_CPY_WRT(&tuple, &_2$$5); } zephir_memory_observe(&queue); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 722, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&queue, &_4, &eventType_zv, 0))) { ZEPHIR_INIT_VAR(&_5$$6); zephir_create_array(&_5$$6, 1, 0); diff --git a/ext/phalcon/filter/filter.zep.c b/ext/phalcon/filter/filter.zep.c index ddfc58514d..fbdfa20278 100644 --- a/ext/phalcon/filter/filter.zep.c +++ b/ext/phalcon/filter/filter.zep.c @@ -311,7 +311,7 @@ PHP_METHOD(Phalcon_Filter_Filter, get) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 723, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 732, PH_NOISY_CC | PH_READONLY); if (1 != zephir_array_isset_value(&_0, &name_zv)) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_filter_exceptions_filternotregistered_ce); @@ -321,16 +321,16 @@ PHP_METHOD(Phalcon_Filter_Filter, get) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 724, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 733, PH_NOISY_CC | PH_READONLY); if (1 != zephir_array_isset_value(&_2, &name_zv)) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 723, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 732, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&definition); zephir_array_fetch(&definition, &_3$$4, &name_zv, PH_NOISY, "phalcon/Filter/Filter.zep", 196); ZEPHIR_CALL_METHOD(&_4$$4, this_ptr, "createinstance", NULL, 0, &definition); zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("services"), &name_zv, &_4$$4); } - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 724, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 733, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_6, &_5, &name_zv, PH_NOISY | PH_READONLY, "phalcon/Filter/Filter.zep", 200); RETURN_CTOR(&_6); } @@ -396,7 +396,7 @@ PHP_METHOD(Phalcon_Filter_Filter, has) Z_PARAM_STR(name) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 723, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 732, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &name_zv)); } @@ -494,7 +494,7 @@ PHP_METHOD(Phalcon_Filter_Filter, set) ZVAL_STR(&name_zv, name); zephir_update_property_array(this_ptr, SL("mapper"), &name_zv, service); zephir_unset_property_array(this_ptr, ZEND_STRL("services"), &name_zv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 724, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 733, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_0, &name_zv, PH_SEPARATE); } diff --git a/ext/phalcon/filter/validation.zep.c b/ext/phalcon/filter/validation.zep.c index ba61a52a3c..0cef0e60d7 100644 --- a/ext/phalcon/filter/validation.zep.c +++ b/ext/phalcon/filter/validation.zep.c @@ -141,19 +141,19 @@ PHP_METHOD(Phalcon_Filter_Validation, __construct) object_init_ex(&_0, phalcon_messages_messages_ce); ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 13); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 725, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 734, &_0); ZEPHIR_INIT_VAR(&_1); ZEPHIR_INIT_NVAR(&_1); - zephir_create_closure_ex(&_1, NULL, phalcon_16__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_1, NULL, phalcon_18__closure_ce, SL("__invoke")); ZEPHIR_CALL_FUNCTION(&_2, "array_filter", NULL, 30, &validators, &_1); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 726, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 735, &_2); ZEPHIR_INIT_VAR(&_3); ZEPHIR_INIT_NVAR(&_3); - zephir_create_closure_ex(&_3, NULL, phalcon_17__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_3, NULL, phalcon_19__closure_ce, SL("__invoke")); ZEPHIR_CALL_FUNCTION(&_4, "array_filter", NULL, 30, &validators, &_3); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 727, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 736, &_4); if ((zephir_method_exists_ex(this_ptr, ZEND_STRL("initialize")) == SUCCESS)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0); zephir_check_call_status(); @@ -269,7 +269,7 @@ PHP_METHOD(Phalcon_Filter_Validation, appendMessage) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &message); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 725, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 734, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "appendmessage", NULL, 0, message); zephir_check_call_status(); RETURN_THIS(); @@ -364,7 +364,7 @@ PHP_METHOD(Phalcon_Filter_Validation, bind) } else { zephir_get_arrval(&whitelist, whitelist_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 728, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 737, data); ZEPHIR_CALL_METHOD(NULL, this_ptr, "setentity", NULL, 0, entity); zephir_check_call_status(); _0 = Z_TYPE_P(data) != IS_ARRAY; @@ -412,10 +412,10 @@ PHP_METHOD(Phalcon_Filter_Validation, bind) return; } if (ZEPHIR_IS_EMPTY(&whitelist)) { - zephir_read_property_cached(&_7$$7, this_ptr, _zephir_prop_1, 729, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$7, this_ptr, _zephir_prop_1, 738, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&whitelist, &_7$$7); } - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 730, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 739, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&filters, &_8); zephir_is_iterable(data, 0, "phalcon/Filter/Validation.zep", 251); if (Z_TYPE_P(data) == IS_ARRAY) { @@ -449,17 +449,17 @@ PHP_METHOD(Phalcon_Filter_Validation, bind) zephir_camelize(&_15$$8, &field, NULL ); ZEPHIR_INIT_NVAR(&method); ZEPHIR_CONCAT_SV(&method, "set", &_15$$8); - zephir_read_property_cached(&_16$$8, this_ptr, _zephir_prop_3, 731, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$8, this_ptr, _zephir_prop_3, 740, PH_NOISY_CC | PH_READONLY); if ((zephir_method_exists(&_16$$8, &method) == SUCCESS)) { ZEPHIR_CALL_METHOD_ZVAL(NULL, entity, &method, NULL, 0, &value); zephir_check_call_status(); } else { - zephir_read_property_cached(&_17$$8, this_ptr, _zephir_prop_3, 731, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$8, this_ptr, _zephir_prop_3, 740, PH_NOISY_CC | PH_READONLY); if ((zephir_method_exists_ex(&_17$$8, ZEND_STRL("writeattribute")) == SUCCESS)) { ZEPHIR_CALL_METHOD(NULL, entity, "writeattribute", NULL, 0, &field, &value); zephir_check_call_status(); } else { - zephir_read_property_cached(&_18$$8, this_ptr, _zephir_prop_3, 731, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$8, this_ptr, _zephir_prop_3, 740, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_19$$8, "property_exists", &_20, 9, &_18$$8, &field); zephir_check_call_status(); if (zephir_is_true(&_19$$8)) { @@ -508,17 +508,17 @@ PHP_METHOD(Phalcon_Filter_Validation, bind) zephir_camelize(&_26$$15, &field, NULL ); ZEPHIR_INIT_NVAR(&method); ZEPHIR_CONCAT_SV(&method, "set", &_26$$15); - zephir_read_property_cached(&_27$$15, this_ptr, _zephir_prop_3, 731, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_27$$15, this_ptr, _zephir_prop_3, 740, PH_NOISY_CC | PH_READONLY); if ((zephir_method_exists(&_27$$15, &method) == SUCCESS)) { ZEPHIR_CALL_METHOD_ZVAL(NULL, entity, &method, NULL, 0, &value); zephir_check_call_status(); } else { - zephir_read_property_cached(&_28$$15, this_ptr, _zephir_prop_3, 731, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$15, this_ptr, _zephir_prop_3, 740, PH_NOISY_CC | PH_READONLY); if ((zephir_method_exists_ex(&_28$$15, ZEND_STRL("writeattribute")) == SUCCESS)) { ZEPHIR_CALL_METHOD(NULL, entity, "writeattribute", NULL, 0, &field, &value); zephir_check_call_status(); } else { - zephir_read_property_cached(&_29$$15, this_ptr, _zephir_prop_3, 731, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$15, this_ptr, _zephir_prop_3, 740, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_30$$15, "property_exists", &_20, 9, &_29$$15, &field); zephir_check_call_status(); if (zephir_is_true(&_30$$15)) { @@ -617,7 +617,7 @@ PHP_METHOD(Phalcon_Filter_Validation, getFilters) zephir_memory_observe(&field_zv); ZVAL_STR_COPY(&field_zv, field); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 730, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 739, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&filters, &_0); if (!(!(ZEPHIR_IS_EMPTY(&field_zv)))) { RETURN_CCTOR(&filters); @@ -655,7 +655,7 @@ PHP_METHOD(Phalcon_Filter_Validation, getLabel) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &field); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 732, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 741, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&labels, &_0); if (Z_TYPE_P(field) == IS_ARRAY) { zephir_fast_join_str(return_value, SL(", "), field); @@ -772,7 +772,7 @@ PHP_METHOD(Phalcon_Filter_Validation, getValueByData) data = ZEND_CALL_ARG(execute_data, 1); zephir_memory_observe(&field_zv); ZVAL_STR_COPY(&field_zv, field); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 733, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 742, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&values, &_0); zephir_memory_observe(&value); if (zephir_array_isset_fetch(&value, &values, &field_zv, 0)) { @@ -846,9 +846,9 @@ PHP_METHOD(Phalcon_Filter_Validation, getValue) zephir_memory_observe(&field_zv); ZVAL_STR_COPY(&field_zv, field); isRawFetched = 0; - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 731, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 740, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&entity, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 728, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 737, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&data, &_0); if (Z_TYPE_P(&entity) == IS_OBJECT) { ZEPHIR_CALL_METHOD(&value, this_ptr, "getvaluebyentity", NULL, 0, &entity, &field_zv); @@ -878,7 +878,7 @@ PHP_METHOD(Phalcon_Filter_Validation, getValue) if (Z_TYPE_P(&value) == IS_NULL) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 730, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 739, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&filters, &_0); zephir_memory_observe(&fieldFilters); if (zephir_array_isset_fetch(&fieldFilters, &filters, &field_zv, 0)) { @@ -1116,7 +1116,7 @@ PHP_METHOD(Phalcon_Filter_Validation, setEntity) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 731, entity); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 740, entity); ZEPHIR_MM_RESTORE(); } @@ -1214,7 +1214,7 @@ PHP_METHOD(Phalcon_Filter_Validation, setLabels) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &labels_param); zephir_get_arrval(&labels, labels_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 732, &labels); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 741, &labels); ZEPHIR_MM_RESTORE(); } @@ -1238,7 +1238,7 @@ PHP_METHOD(Phalcon_Filter_Validation, setValidators) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &validators_param); zephir_get_arrval(&validators, validators_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 726, &validators); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 735, &validators); RETURN_THIS(); } @@ -1388,8 +1388,8 @@ PHP_METHOD(Phalcon_Filter_Validation, validate) ZEPHIR_INIT_VAR(&inputData); ZVAL_NULL(&inputData); zephir_memory_observe(&validatorData); - zephir_read_property_cached(&validatorData, this_ptr, _zephir_prop_0, 726, PH_NOISY_CC); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 727, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&validatorData, this_ptr, _zephir_prop_0, 735, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 736, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&combinedFieldsValidators, &_0); if (UNEXPECTED(Z_TYPE_P(&validatorData) != IS_ARRAY)) { ZEPHIR_INIT_VAR(&_1$$3); @@ -1402,12 +1402,12 @@ PHP_METHOD(Phalcon_Filter_Validation, validate) } ZEPHIR_INIT_VAR(&_2); array_init(&_2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 733, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 742, &_2); ZEPHIR_INIT_VAR(&_3); object_init_ex(&_3, phalcon_messages_messages_ce); ZEPHIR_CALL_METHOD(NULL, &_3, "__construct", NULL, 13); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 725, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 734, &_3); if (Z_TYPE_P(data) != IS_NULL) { _4$$4 = Z_TYPE_P(data) != IS_ARRAY; if (_4$$4) { @@ -1422,13 +1422,13 @@ PHP_METHOD(Phalcon_Filter_Validation, validate) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 728, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 737, data); ZEPHIR_CPY_WRT(&inputData, data); } else { - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 728, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 737, PH_NOISY_CC | PH_READONLY); if (!(ZEPHIR_IS_EMPTY(&_0))) { ZEPHIR_OBS_NVAR(&inputData); - zephir_read_property_cached(&inputData, this_ptr, _zephir_prop_4, 728, PH_NOISY_CC); + zephir_read_property_cached(&inputData, this_ptr, _zephir_prop_4, 737, PH_NOISY_CC); } } if (Z_TYPE_P(entity) != IS_NULL) { @@ -1436,8 +1436,8 @@ PHP_METHOD(Phalcon_Filter_Validation, validate) zephir_check_call_status(); } if ((zephir_method_exists_ex(this_ptr, ZEND_STRL("beforevalidation")) == SUCCESS)) { - zephir_read_property_cached(&_6$$8, this_ptr, _zephir_prop_5, 731, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$8, this_ptr, _zephir_prop_3, 725, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$8, this_ptr, _zephir_prop_5, 740, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$8, this_ptr, _zephir_prop_3, 734, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&status, this_ptr, "beforevalidation", NULL, 0, &inputData, &_6$$8, &_7$$8); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&status)) { @@ -1742,8 +1742,8 @@ PHP_METHOD(Phalcon_Filter_Validation, validate) } ZEPHIR_INIT_NVAR(&scope); if ((zephir_method_exists_ex(this_ptr, ZEND_STRL("aftervalidation")) == SUCCESS)) { - zephir_read_property_cached(&_57$$44, this_ptr, _zephir_prop_5, 731, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_58$$44, this_ptr, _zephir_prop_3, 725, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_57$$44, this_ptr, _zephir_prop_5, 740, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_58$$44, this_ptr, _zephir_prop_3, 734, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, this_ptr, "aftervalidation", NULL, 0, &inputData, &_57$$44, &_58$$44); zephir_check_call_status(); } @@ -1769,7 +1769,7 @@ PHP_METHOD(Phalcon_Filter_Validation, fails) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 725, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 734, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "count", NULL, 0); zephir_check_call_status(); if (ZEPHIR_GT_LONG(&_1, 0)) { diff --git a/ext/phalcon/filter/validation/traits/validatorcompositetrait.zep.c b/ext/phalcon/filter/validation/traits/validatorcompositetrait.zep.c index a4ca87df96..27a453f7ef 100644 --- a/ext/phalcon/filter/validation/traits/validatorcompositetrait.zep.c +++ b/ext/phalcon/filter/validation/traits/validatorcompositetrait.zep.c @@ -64,7 +64,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Traits_ValidatorCompositeTrait, getValidato zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 734, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 743, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } diff --git a/ext/phalcon/filter/validation/validator/callback.zep.c b/ext/phalcon/filter/validation/validator/callback.zep.c index e79d66b87e..a3da762144 100644 --- a/ext/phalcon/filter/validation/validator/callback.zep.c +++ b/ext/phalcon/filter/validation/validator/callback.zep.c @@ -171,11 +171,11 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Callback, validate) zephir_check_call_status(); } zephir_memory_observe(&savedTemplate); - zephir_read_property_cached(&savedTemplate, this_ptr, _zephir_prop_0, 735, PH_NOISY_CC); + zephir_read_property_cached(&savedTemplate, this_ptr, _zephir_prop_0, 744, PH_NOISY_CC); zephir_memory_observe(&savedChanged); - zephir_read_property_cached(&savedChanged, this_ptr, _zephir_prop_1, 736, PH_NOISY_CC); + zephir_read_property_cached(&savedChanged, this_ptr, _zephir_prop_1, 745, PH_NOISY_CC); zephir_memory_observe(&savedTemplates); - zephir_read_property_cached(&savedTemplates, this_ptr, _zephir_prop_2, 737, PH_NOISY_CC); + zephir_read_property_cached(&savedTemplates, this_ptr, _zephir_prop_2, 746, PH_NOISY_CC); if (zephir_is_instance_of(&callback, SL("Closure"))) { _2$$5 = zephir_fetch_class_str_ex(SL("Closure"), ZEND_FETCH_CLASS_AUTO); ZEPHIR_CALL_CE_STATIC(&_1$$5, _2$$5, "bind", NULL, 0, &callback, this_ptr); @@ -194,9 +194,9 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Callback, validate) ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_4$$6); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 735, &savedTemplate); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 736, &savedChanged); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 737, &savedTemplates); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 744, &savedTemplate); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 745, &savedChanged); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 746, &savedTemplates); if (((Z_TYPE_P(&returnedValue) == IS_TRUE || Z_TYPE_P(&returnedValue) == IS_FALSE) == 1)) { RETURN_CCTOR(&returnedValue); } diff --git a/ext/phalcon/filter/validation/validator/confirmation.zep.c b/ext/phalcon/filter/validation/validator/confirmation.zep.c index b5a64f493d..be7bcf63e1 100644 --- a/ext/phalcon/filter/validation/validator/confirmation.zep.c +++ b/ext/phalcon/filter/validation/validator/confirmation.zep.c @@ -276,7 +276,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Confirmation, phpExtensionLoaded) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 431, &name_zv); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/filter/validation/validator/creditcard.zep.c b/ext/phalcon/filter/validation/validator/creditcard.zep.c index ccd31480b9..d74e997278 100644 --- a/ext/phalcon/filter/validation/validator/creditcard.zep.c +++ b/ext/phalcon/filter/validation/validator/creditcard.zep.c @@ -189,7 +189,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_CreditCard, verifyByLuhnAlgorithm } ZEPHIR_CALL_FUNCTION(&_1, "str_split", NULL, 206, &number_zv); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&digits, "array_reverse", NULL, 255, &_1); + ZEPHIR_CALL_FUNCTION(&digits, "array_reverse", NULL, 261, &_1); zephir_check_call_status(); zephir_is_iterable(&digits, 0, "phalcon/Filter/Validation/Validator/CreditCard.zep", 112); if (Z_TYPE_P(&digits) == IS_ARRAY) { diff --git a/ext/phalcon/filter/validation/validator/file/mimetype.zep.c b/ext/phalcon/filter/validation/validator/file/mimetype.zep.c index b09b46b9b7..04abce43f9 100644 --- a/ext/phalcon/filter/validation/validator/file/mimetype.zep.c +++ b/ext/phalcon/filter/validation/validator/file/mimetype.zep.c @@ -285,7 +285,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File_MimeType, phpExtensionLoaded zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 431, &name_zv); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/filter/validation/validator/files.zep.c b/ext/phalcon/filter/validation/validator/files.zep.c index a16adafec0..b0532db65f 100644 --- a/ext/phalcon/filter/validation/validator/files.zep.c +++ b/ext/phalcon/filter/validation/validator/files.zep.c @@ -209,7 +209,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Files, validate) zephir_check_call_status(); ZEPHIR_INIT_VAR(&validator); object_init_ex(&validator, phalcon_filter_validation_validator_file_ce); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 738, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 747, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", NULL, 0, &_0); zephir_check_call_status(); zephir_is_iterable(&files, 0, "phalcon/Filter/Validation/Validator/Files.zep", 114); diff --git a/ext/phalcon/filter/validation/validator/stringlength/max.zep.c b/ext/phalcon/filter/validation/validator/stringlength/max.zep.c index 3c0ca67fb3..bf0694f7ab 100644 --- a/ext/phalcon/filter/validation/validator/stringlength/max.zep.c +++ b/ext/phalcon/filter/validation/validator/stringlength/max.zep.c @@ -239,7 +239,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_StringLength_Max, phpExtensionLoa zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 431, &name_zv); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/filter/validation/validator/stringlength/min.zep.c b/ext/phalcon/filter/validation/validator/stringlength/min.zep.c index 3a13f44d4f..dde92419f5 100644 --- a/ext/phalcon/filter/validation/validator/stringlength/min.zep.c +++ b/ext/phalcon/filter/validation/validator/stringlength/min.zep.c @@ -239,7 +239,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_StringLength_Min, phpExtensionLoa zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 431, &name_zv); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/filter/validation/validator/uniqueness.zep.c b/ext/phalcon/filter/validation/validator/uniqueness.zep.c index 81af321b90..525485e934 100644 --- a/ext/phalcon/filter/validation/validator/uniqueness.zep.c +++ b/ext/phalcon/filter/validation/validator/uniqueness.zep.c @@ -292,7 +292,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Uniqueness, getColumnNameReal) zephir_check_call_status(); _2 = zephir_is_true(&_0); if (_2) { - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 739, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 748, PH_NOISY_CC | PH_READONLY); _2 = !zephir_is_true(&_3); } if (_2) { @@ -304,17 +304,17 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Uniqueness, getColumnNameReal) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_7$$3, &_5$$3, "getcolumnmap", NULL, 0, record); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 739, &_7$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 748, &_7$$3); } zephir_memory_observe(&_8); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 739, PH_NOISY_CC); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 748, PH_NOISY_CC); _9 = Z_TYPE_P(&_8) == IS_ARRAY; if (_9) { - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 739, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 748, PH_NOISY_CC | PH_READONLY); _9 = zephir_array_isset_value(&_10, &field_zv); } if (_9) { - zephir_read_property_cached(&_11$$4, this_ptr, _zephir_prop_0, 739, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$4, this_ptr, _zephir_prop_0, 748, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_12$$4, &_11$$4, &field_zv, PH_NOISY | PH_READONLY, "phalcon/Filter/Validation/Validator/Uniqueness.zep", 182); RETURN_CTOR(&_12$$4); } diff --git a/ext/phalcon/filter/validation/validator/url.zep.c b/ext/phalcon/filter/validation/validator/url.zep.c index 8c68b51031..fd0bd3520b 100644 --- a/ext/phalcon/filter/validation/validator/url.zep.c +++ b/ext/phalcon/filter/validation/validator/url.zep.c @@ -145,7 +145,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Url, validate) RETURN_MM_BOOL(1); } zephir_memory_observe(&options); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 740, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 749, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_string_fetch(&options, &_1, SL("options"), 0)) { ZVAL_LONG(&_2$$4, 273); ZEPHIR_CALL_FUNCTION(&result, "filter_var", NULL, 0, &value, &_2$$4, &options); diff --git a/ext/phalcon/flash/direct.zep.c b/ext/phalcon/flash/direct.zep.c index 92721ee0f0..884d267f3d 100644 --- a/ext/phalcon/flash/direct.zep.c +++ b/ext/phalcon/flash/direct.zep.c @@ -101,7 +101,7 @@ PHP_METHOD(Phalcon_Flash_Direct, output) remove = 1; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 741, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 750, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "phalcon/Flash/Direct.zep", 45); if (Z_TYPE_P(&_0) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1) diff --git a/ext/phalcon/flash/session.zep.c b/ext/phalcon/flash/session.zep.c index 9490478ab7..08a0b7ea30 100644 --- a/ext/phalcon/flash/session.zep.c +++ b/ext/phalcon/flash/session.zep.c @@ -116,7 +116,7 @@ PHP_METHOD(Phalcon_Flash_Session, __construct) ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "_flashMessages"); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 742, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 751, &_0); ZEPHIR_MM_RESTORE(); } @@ -365,7 +365,7 @@ PHP_METHOD(Phalcon_Flash_Session, output) } ZEPHIR_INIT_NVAR(&message); ZEPHIR_INIT_NVAR(&type); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 743, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 752, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_7)) { ZEPHIR_CALL_PARENT(NULL, phalcon_flash_session_ce, getThis(), "clear", NULL, 0); zephir_check_call_status(); @@ -420,7 +420,7 @@ PHP_METHOD(Phalcon_Flash_Session, getSessionMessages) } ZEPHIR_CALL_METHOD(&session, this_ptr, "getsessionservice", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 742, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 751, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&messages, &session, "get", NULL, 0, &_0); zephir_check_call_status(); if (Z_TYPE_P(&messages) != IS_ARRAY) { @@ -432,7 +432,7 @@ PHP_METHOD(Phalcon_Flash_Session, getSessionMessages) if (zephir_array_isset_fetch(&returnMessages, &messages, &type_zv, 0)) { if (remove) { zephir_array_unset(&messages, &type_zv, PH_SEPARATE); - zephir_read_property_cached(&_1$$6, this_ptr, _zephir_prop_0, 742, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$6, this_ptr, _zephir_prop_0, 751, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &session, "set", NULL, 0, &_1$$6, &messages); zephir_check_call_status(); } @@ -442,7 +442,7 @@ PHP_METHOD(Phalcon_Flash_Session, getSessionMessages) RETURN_MM(); } if (remove) { - zephir_read_property_cached(&_2$$7, this_ptr, _zephir_prop_0, 742, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$7, this_ptr, _zephir_prop_0, 751, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &session, "remove", NULL, 0, &_2$$7); zephir_check_call_status(); } @@ -482,7 +482,7 @@ PHP_METHOD(Phalcon_Flash_Session, setSessionMessages) zephir_get_arrval(&messages, messages_param); ZEPHIR_CALL_METHOD(&session, this_ptr, "getsessionservice", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 742, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 751, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &session, "set", NULL, 0, &_0, &messages); zephir_check_call_status(); RETURN_CTOR(&messages); @@ -521,14 +521,14 @@ PHP_METHOD(Phalcon_Flash_Session, getSessionService) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 744, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 753, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { RETURN_MM_MEMBER(getThis(), "sessionService"); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 745, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 754, PH_NOISY_CC | PH_READONLY); _2 = Z_TYPE_P(&_1) != IS_NULL; if (_2) { - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 745, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 754, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_5); ZVAL_STRING(&_5, "session"); ZEPHIR_CALL_METHOD(&_4, &_3, "has", NULL, 0, &_5); @@ -536,12 +536,12 @@ PHP_METHOD(Phalcon_Flash_Session, getSessionService) _2 = ZEPHIR_IS_TRUE_IDENTICAL(&_4); } if (_2) { - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_1, 745, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_1, 754, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_8$$4); ZVAL_STRING(&_8$$4, "session"); ZEPHIR_CALL_METHOD(&_7$$4, &_6$$4, "getshared", NULL, 0, &_8$$4); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 744, &_7$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 753, &_7$$4); RETURN_MM_MEMBER(getThis(), "sessionService"); } ZEPHIR_INIT_NVAR(&_5); diff --git a/ext/phalcon/forms/element/check.zep.c b/ext/phalcon/forms/element/check.zep.c index 88c55ec40e..f5f07239e6 100644 --- a/ext/phalcon/forms/element/check.zep.c +++ b/ext/phalcon/forms/element/check.zep.c @@ -92,11 +92,11 @@ PHP_METHOD(Phalcon_Forms_Element_Check, setUncheckedValue) Z_PARAM_ZVAL(value) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &value); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 746, value); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 755, value); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 747, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 756, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 747, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 756, &__$false); } RETURN_THISW(); } diff --git a/ext/phalcon/forms/element/checkgroup.zep.c b/ext/phalcon/forms/element/checkgroup.zep.c index 42b91f8110..cd92ee9d5b 100644 --- a/ext/phalcon/forms/element/checkgroup.zep.c +++ b/ext/phalcon/forms/element/checkgroup.zep.c @@ -105,7 +105,7 @@ PHP_METHOD(Phalcon_Forms_Element_CheckGroup, __construct) ZEPHIR_CONCAT_VS(&_0$$3, &name, "[]"); ZEPHIR_CPY_WRT(&name, &_0$$3); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 748, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 757, &options); ZEPHIR_CALL_PARENT(NULL, phalcon_forms_element_checkgroup_ce, getThis(), "__construct", NULL, 0, &name, &attributes); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -177,7 +177,7 @@ PHP_METHOD(Phalcon_Forms_Element_CheckGroup, render) } ZEPHIR_CALL_METHOD(&value, this_ptr, "getvalue", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 749, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 758, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&merged); zephir_fast_array_merge(&merged, &_0, &attributes); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getlocaltagfactory", NULL, 0); @@ -186,8 +186,8 @@ PHP_METHOD(Phalcon_Forms_Element_CheckGroup, render) ZVAL_STRING(&_2, "inputCheckboxGroup"); ZEPHIR_CALL_METHOD(&helper, &_1, "newinstance", NULL, 0, &_2); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 750, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 748, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 759, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 757, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_3, &helper, "__invoke", NULL, 0, &_4, &_5, &value, &merged); zephir_check_call_status(); zephir_cast_to_string(&_6, &_3); @@ -221,7 +221,7 @@ PHP_METHOD(Phalcon_Forms_Element_CheckGroup, setOptions) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &options_param); zephir_get_arrval(&options, options_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 748, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 757, &options); RETURN_THIS(); } diff --git a/ext/phalcon/forms/element/radiogroup.zep.c b/ext/phalcon/forms/element/radiogroup.zep.c index a41174bc06..8899dca4ec 100644 --- a/ext/phalcon/forms/element/radiogroup.zep.c +++ b/ext/phalcon/forms/element/radiogroup.zep.c @@ -100,7 +100,7 @@ PHP_METHOD(Phalcon_Forms_Element_RadioGroup, __construct) } else { zephir_get_arrval(&attributes, attributes_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 751, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 760, &options); ZEPHIR_CALL_PARENT(NULL, phalcon_forms_element_radiogroup_ce, getThis(), "__construct", NULL, 0, &name_zv, &attributes); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -172,7 +172,7 @@ PHP_METHOD(Phalcon_Forms_Element_RadioGroup, render) } ZEPHIR_CALL_METHOD(&value, this_ptr, "getvalue", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 752, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 761, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&merged); zephir_fast_array_merge(&merged, &_0, &attributes); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getlocaltagfactory", NULL, 0); @@ -181,8 +181,8 @@ PHP_METHOD(Phalcon_Forms_Element_RadioGroup, render) ZVAL_STRING(&_2, "inputRadioGroup"); ZEPHIR_CALL_METHOD(&helper, &_1, "newinstance", NULL, 0, &_2); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 753, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 751, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 760, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_3, &helper, "__invoke", NULL, 0, &_4, &_5, &value, &merged); zephir_check_call_status(); zephir_cast_to_string(&_6, &_3); @@ -216,7 +216,7 @@ PHP_METHOD(Phalcon_Forms_Element_RadioGroup, setOptions) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &options_param); zephir_get_arrval(&options, options_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 751, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 760, &options); RETURN_THIS(); } diff --git a/ext/phalcon/forms/element/select.zep.c b/ext/phalcon/forms/element/select.zep.c index 0ea49a4042..04a75d2906 100644 --- a/ext/phalcon/forms/element/select.zep.c +++ b/ext/phalcon/forms/element/select.zep.c @@ -93,7 +93,7 @@ PHP_METHOD(Phalcon_Forms_Element_Select, __construct) } else { zephir_get_arrval(&attributes, attributes_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 754, options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 763, options); ZEPHIR_CALL_PARENT(NULL, phalcon_forms_element_select_ce, getThis(), "__construct", NULL, 0, &name_zv, &attributes); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -215,7 +215,7 @@ PHP_METHOD(Phalcon_Forms_Element_Select, render) } ZEPHIR_CALL_METHOD(&_0, this_ptr, "prepareattributes", NULL, 0, &attributes); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 754, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 763, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_CE_STATIC(phalcon_tag_select_ce, "selectfield", NULL, 0, &_0, &_1); zephir_check_call_status(); RETURN_MM(); @@ -241,7 +241,7 @@ PHP_METHOD(Phalcon_Forms_Element_Select, setOptions) Z_PARAM_ZVAL(options) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &options); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 754, options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 763, options); RETURN_THISW(); } @@ -285,11 +285,11 @@ PHP_METHOD(Phalcon_Forms_Element_Select, prepareAttributes) } else { zephir_get_arrval(&attributes, attributes_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 755, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 764, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&name, &_0); zephir_array_update_long(&attributes, 0, &name, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY); zephir_memory_observe(&defaultAttributes); - zephir_read_property_cached(&defaultAttributes, this_ptr, _zephir_prop_1, 756, PH_NOISY_CC); + zephir_read_property_cached(&defaultAttributes, this_ptr, _zephir_prop_1, 765, PH_NOISY_CC); ZEPHIR_INIT_VAR(&mergedAttributes); zephir_fast_array_merge(&mergedAttributes, &defaultAttributes, &attributes); ZEPHIR_CALL_METHOD(&value, this_ptr, "getvalue", NULL, 0); diff --git a/ext/phalcon/forms/form.zep.c b/ext/phalcon/forms/form.zep.c index 9d85cc3fdc..5f0b457fcd 100644 --- a/ext/phalcon/forms/form.zep.c +++ b/ext/phalcon/forms/form.zep.c @@ -161,18 +161,18 @@ PHP_METHOD(Phalcon_Forms_Form, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 757, entity); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 758, &userOptions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 766, entity); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 767, &userOptions); ZEPHIR_INIT_VAR(&_2); object_init_ex(&_2, phalcon_html_attributes_ce); ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 41); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 759, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 768, &_2); ZEPHIR_INIT_VAR(&_3); object_init_ex(&_3, phalcon_messages_messages_ce); ZEPHIR_CALL_METHOD(NULL, &_3, "__construct", NULL, 13); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 760, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 769, &_3); if ((zephir_method_exists_ex(this_ptr, ZEND_STRL("initialize")) == SUCCESS)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0, entity, &userOptions); zephir_check_call_status(); @@ -243,17 +243,17 @@ PHP_METHOD(Phalcon_Forms_Form, add) zephir_check_call_status(); _0 = (zephir_method_exists_ex(element, ZEND_STRL("settagfactory")) == SUCCESS); if (_0) { - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 761, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 770, PH_NOISY_CC | PH_READONLY); _0 = Z_TYPE_P(&_1) != IS_NULL; } if (_0) { - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 761, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 770, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, element, "settagfactory", NULL, 0, &_2$$3); zephir_check_call_status(); } _3 = ZEPHIR_IS_NULL(&position_zv); if (!(_3)) { - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 771, PH_NOISY_CC | PH_READONLY); _3 = ZEPHIR_IS_EMPTY(&_4); } if (_3) { @@ -261,7 +261,7 @@ PHP_METHOD(Phalcon_Forms_Form, add) } else { ZEPHIR_INIT_VAR(&elements); array_init(&elements); - zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 771, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_5$$5, 0, "phalcon/Forms/Form.zep", 183); if (Z_TYPE_P(&_5$$5) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_5$$5), _7$$5, _8$$5, _6$$5) @@ -321,7 +321,7 @@ PHP_METHOD(Phalcon_Forms_Form, add) } ZEPHIR_INIT_NVAR(&value); ZEPHIR_INIT_NVAR(&key); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 762, &elements); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 771, &elements); } RETURN_THIS(); } @@ -443,7 +443,7 @@ PHP_METHOD(Phalcon_Forms_Form, bind) } else { zephir_get_arrval(&whitelist, whitelist_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(ZEPHIR_IS_EMPTY(&_0))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_forms_exceptions_noformelements_ce); @@ -461,10 +461,10 @@ PHP_METHOD(Phalcon_Forms_Form, bind) } } if (ZEPHIR_IS_EMPTY(&whitelist)) { - zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_1, 763, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_1, 772, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&whitelist, &_3$$6); } - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_4, 0, "phalcon/Forms/Form.zep", 237); if (Z_TYPE_P(&_4) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_4), _6, _7, _5) @@ -561,11 +561,11 @@ PHP_METHOD(Phalcon_Forms_Form, bind) ZEPHIR_INIT_NVAR(&value); ZVAL_COPY(&value, _18); ZEPHIR_OBS_NVAR(&element); - zephir_read_property_cached(&_21$$15, this_ptr, _zephir_prop_0, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$15, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&element, &_21$$15, &key, 0))) { ZEPHIR_INIT_NVAR(&element); ZVAL_NULL(&element); - zephir_read_property_cached(&_22$$16, this_ptr, _zephir_prop_0, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$16, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_22$$16, 0, "phalcon/Forms/Form.zep", 255); if (Z_TYPE_P(&_22$$16) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_22$$16), _23$$16) @@ -687,11 +687,11 @@ PHP_METHOD(Phalcon_Forms_Form, bind) ZEPHIR_CALL_METHOD(&value, &data, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&element); - zephir_read_property_cached(&_43$$30, this_ptr, _zephir_prop_0, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_43$$30, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&element, &_43$$30, &key, 0))) { ZEPHIR_INIT_NVAR(&element); ZVAL_NULL(&element); - zephir_read_property_cached(&_44$$31, this_ptr, _zephir_prop_0, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_44$$31, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_44$$31, 0, "phalcon/Forms/Form.zep", 255); if (Z_TYPE_P(&_44$$31) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_44$$31), _45$$31) @@ -795,8 +795,8 @@ PHP_METHOD(Phalcon_Forms_Form, bind) } ZEPHIR_INIT_NVAR(&value); ZEPHIR_INIT_NVAR(&key); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 764, &assignData); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 765, &filteredData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 773, &assignData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 774, &filteredData); if ((zephir_method_exists_ex(this_ptr, ZEND_STRL("afterbind")) == SUCCESS)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "afterbind", NULL, 0, entity); zephir_check_call_status(); @@ -858,9 +858,9 @@ PHP_METHOD(Phalcon_Forms_Form, clear) } else { ZEPHIR_SEPARATE_PARAM(fields); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 764, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 773, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&data, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 771, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&elements, &_0); if (Z_TYPE_P(fields) == IS_NULL) { ZEPHIR_INIT_NVAR(&data); @@ -961,7 +961,7 @@ PHP_METHOD(Phalcon_Forms_Form, clear) } ZEPHIR_INIT_NVAR(&field); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 764, &data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 773, &data); RETURN_THIS(); } @@ -978,7 +978,7 @@ PHP_METHOD(Phalcon_Forms_Form, count) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("elements", 8, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); RETURN_LONG(zephir_fast_count_int(&_0)); } @@ -1006,8 +1006,8 @@ PHP_METHOD(Phalcon_Forms_Form, current) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&element); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 766, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 767, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 775, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 776, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&element, &_0, &_1, 0))) { RETURN_MM_BOOL(0); } @@ -1042,7 +1042,7 @@ PHP_METHOD(Phalcon_Forms_Form, get) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); zephir_memory_observe(&element); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(!(zephir_array_isset_fetch(&element, &_0, &name_zv, 0)))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_forms_exceptions_elementnotinform_ce); @@ -1102,13 +1102,13 @@ PHP_METHOD(Phalcon_Forms_Form, getAttributes) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 759, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 768, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(Z_TYPE_P(&_0) == IS_NULL)) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_html_attributes_ce); ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 41); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 759, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 768, &_1$$3); } RETURN_MM_MEMBER(getThis(), "attributes"); } @@ -1160,7 +1160,7 @@ PHP_METHOD(Phalcon_Forms_Form, getFilteredValue) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 765, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 774, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&filteredData, &_0); if (Z_TYPE_P(&filteredData) == IS_ARRAY) { zephir_memory_observe(&value); @@ -1202,7 +1202,7 @@ PHP_METHOD(Phalcon_Forms_Form, getLabel) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); zephir_memory_observe(&element); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(!(zephir_array_isset_fetch(&element, &_0, &name_zv, 0)))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_forms_exceptions_elementnotinform_ce); @@ -1322,7 +1322,7 @@ PHP_METHOD(Phalcon_Forms_Form, getUserOption) defaultValue = &__$null; } zephir_memory_observe(&value); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 758, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 767, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&value, &_0, &option_zv, 0))) { RETVAL_ZVAL(defaultValue, 1, 0); RETURN_MM(); @@ -1388,9 +1388,9 @@ PHP_METHOD(Phalcon_Forms_Form, getValue) zephir_get_global(&_POST, SL("_POST")); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 757, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 766, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&entity, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 764, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 773, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&data, &_0); if ((zephir_method_exists_ex(this_ptr, ZEND_STRL("getcustomvalue")) == SUCCESS)) { ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getcustomvalue", NULL, 0, &name_zv, &entity, &data); @@ -1455,7 +1455,7 @@ PHP_METHOD(Phalcon_Forms_Form, getValue) RETURN_MM(); } zephir_memory_observe(&element); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 771, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&element, &_0, &name_zv, 0)) { ZEPHIR_RETURN_CALL_METHOD(&element, "getdefault", NULL, 0); zephir_check_call_status(); @@ -1502,7 +1502,7 @@ PHP_METHOD(Phalcon_Forms_Form, has) Z_PARAM_STR(name) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &name_zv)); } @@ -1626,26 +1626,26 @@ PHP_METHOD(Phalcon_Forms_Form, isValid) } else { zephir_get_arrval(&whitelist, whitelist_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_0)) { RETURN_MM_BOOL(1); } if (ZEPHIR_IS_EMPTY(&whitelist)) { - zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_1, 763, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_1, 772, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&whitelist, &_1$$4); } if (Z_TYPE_P(data) != IS_ARRAY) { - zephir_read_property_cached(&_2$$5, this_ptr, _zephir_prop_2, 764, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$5, this_ptr, _zephir_prop_2, 773, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(data, &_2$$5); } _3 = Z_TYPE_P(entity) != IS_OBJECT; if (_3) { zephir_memory_observe(&_4); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 757, PH_NOISY_CC); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 766, PH_NOISY_CC); _3 = Z_TYPE_P(&_4) == IS_OBJECT; } if (_3) { - zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_3, 757, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_3, 766, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(entity, &_5$$6); } ZEPHIR_CALL_METHOD(NULL, this_ptr, "bind", NULL, 0, data, entity, &whitelist); @@ -1670,7 +1670,7 @@ PHP_METHOD(Phalcon_Forms_Form, isValid) ZEPHIR_CALL_METHOD(NULL, &validation, "__construct", NULL, 0); zephir_check_call_status(); } - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_8, 0, "phalcon/Forms/Form.zep", 776); if (Z_TYPE_P(&_8) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_8), _9) @@ -1825,7 +1825,7 @@ PHP_METHOD(Phalcon_Forms_Form, isValid) validationStatus = 0; } if (!(validationStatus)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 760, &messages); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 769, &messages); } if ((zephir_method_exists_ex(this_ptr, ZEND_STRL("aftervalidation")) == SUCCESS)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "aftervalidation", NULL, 0, &messages); @@ -2137,7 +2137,7 @@ PHP_METHOD(Phalcon_Forms_Form, label) zephir_get_arrval(&attributes, attributes_param); } zephir_memory_observe(&element); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(!(zephir_array_isset_fetch(&element, &_0, &name_zv, 0)))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_forms_exceptions_elementnotinform_ce); @@ -2202,7 +2202,7 @@ PHP_METHOD(Phalcon_Forms_Form, render) zephir_get_arrval(&attributes, attributes_param); } zephir_memory_observe(&element); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(!(zephir_array_isset_fetch(&element, &_0, &name_zv, 0)))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_forms_exceptions_elementnotinform_ce); @@ -2247,16 +2247,16 @@ PHP_METHOD(Phalcon_Forms_Form, remove) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, &name_zv)) { zephir_unset_property_array(this_ptr, ZEND_STRL("elements"), &name_zv); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_1$$3, &name_zv, PH_SEPARATE); RETURN_MM_BOOL(1); } ZEPHIR_INIT_VAR(&_2); array_init(&_2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 766, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 775, &_2); RETURN_MM_BOOL(0); } @@ -2289,11 +2289,11 @@ PHP_METHOD(Phalcon_Forms_Form, rewind) ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 767, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 762, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 776, &_0); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 771, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_1, "array_values", NULL, 27, &_0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 766, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 775, &_1); ZEPHIR_MM_RESTORE(); } @@ -2347,7 +2347,7 @@ PHP_METHOD(Phalcon_Forms_Form, setAttributes) Z_PARAM_OBJECT_OF_CLASS(attributes, phalcon_html_attributes_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &attributes); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 759, attributes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 768, attributes); RETURN_THISW(); } @@ -2371,7 +2371,7 @@ PHP_METHOD(Phalcon_Forms_Form, setEntity) Z_PARAM_ZVAL(entity) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &entity); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 757, entity); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 766, entity); RETURN_THISW(); } @@ -2393,7 +2393,7 @@ PHP_METHOD(Phalcon_Forms_Form, setTagFactory) Z_PARAM_OBJECT_OF_CLASS(tagFactory, phalcon_html_tagfactory_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &tagFactory); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 761, tagFactory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 770, tagFactory); RETURN_THISW(); } @@ -2417,7 +2417,7 @@ PHP_METHOD(Phalcon_Forms_Form, setValidation) Z_PARAM_OBJECT_OF_CLASS(validation, phalcon_filter_validation_validationinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &validation); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 768, validation); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 777, validation); RETURN_THISW(); } @@ -2446,7 +2446,7 @@ PHP_METHOD(Phalcon_Forms_Form, setWhitelist) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &whitelist_param); zephir_get_arrval(&whitelist, whitelist_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 763, &whitelist); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 772, &whitelist); RETURN_THIS(); } @@ -2494,7 +2494,7 @@ PHP_METHOD(Phalcon_Forms_Form, setUserOptions) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &options_param); zephir_get_arrval(&options, options_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 758, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 767, &options); RETURN_THIS(); } @@ -2516,8 +2516,8 @@ PHP_METHOD(Phalcon_Forms_Form, valid) if (UNEXPECTED(!_zephir_prop_1)) { _zephir_prop_1 = zend_string_init("position", 8, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 766, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 767, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 775, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 776, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &_1)); } diff --git a/ext/phalcon/forms/formslocator.zep.c b/ext/phalcon/forms/formslocator.zep.c index 280f739306..cd836d625a 100644 --- a/ext/phalcon/forms/formslocator.zep.c +++ b/ext/phalcon/forms/formslocator.zep.c @@ -108,7 +108,7 @@ PHP_METHOD(Phalcon_Forms_FormsLocator, __construct) } ZEPHIR_CALL_METHOD(&_0, this_ptr, "getdefaultservices", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 769, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 778, &_0); zephir_is_iterable(&definitions, 0, "phalcon/Forms/FormsLocator.zep", 78); if (Z_TYPE_P(&definitions) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&definitions), _2, _3, _1) @@ -220,7 +220,7 @@ PHP_METHOD(Phalcon_Forms_FormsLocator, get) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 770, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 779, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&factory); zephir_array_fetch(&factory, &_2, &name_zv, PH_NOISY, "phalcon/Forms/FormsLocator.zep", 100); if (Z_TYPE_P(entity) != IS_NULL) { @@ -229,7 +229,7 @@ PHP_METHOD(Phalcon_Forms_FormsLocator, get) RETURN_MM(); } zephir_memory_observe(&instance); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 771, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&instance, &_3, &name_zv, 0))) { ZVAL_NULL(&_4$$5); ZEPHIR_CALL_ZVAL_FUNCTION(&instance, &factory, NULL, 0, &_4$$5); @@ -272,7 +272,7 @@ PHP_METHOD(Phalcon_Forms_FormsLocator, getElement) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&type_zv); ZVAL_STR_COPY(&type_zv, type); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 769, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 778, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_0, &type_zv))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_forms_exceptions_unknownformelementtype_ce); @@ -282,7 +282,7 @@ PHP_METHOD(Phalcon_Forms_FormsLocator, getElement) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 769, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 778, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_3, &_2, &type_zv, PH_NOISY | PH_READONLY, "phalcon/Forms/FormsLocator.zep", 128); RETURN_CTOR(&_3); } @@ -311,7 +311,7 @@ PHP_METHOD(Phalcon_Forms_FormsLocator, has) Z_PARAM_STR(name) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 770, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 779, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &name_zv)); } @@ -339,7 +339,7 @@ PHP_METHOD(Phalcon_Forms_FormsLocator, hasElement) Z_PARAM_STR(type) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&type_zv, type); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 769, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 778, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &type_zv)); } @@ -374,7 +374,7 @@ PHP_METHOD(Phalcon_Forms_FormsLocator, set) factory = ZEND_CALL_ARG(execute_data, 2); ZVAL_STR(&name_zv, name); zephir_unset_property_array(this_ptr, ZEND_STRL("instances"), &name_zv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 780, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_0, &name_zv, PH_SEPARATE); zephir_update_property_array(this_ptr, SL("factories"), &name_zv, factory); } @@ -424,59 +424,59 @@ PHP_METHOD(Phalcon_Forms_FormsLocator, getDefaultServices) zephir_create_array(return_value, 14, 0); ZEPHIR_INIT_VAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_18__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_20__closure_ce, SL("__invoke")); zephir_array_update_string(return_value, SL("check"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_19__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_21__closure_ce, SL("__invoke")); zephir_array_update_string(return_value, SL("checkgroup"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_20__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_22__closure_ce, SL("__invoke")); zephir_array_update_string(return_value, SL("date"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_21__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_23__closure_ce, SL("__invoke")); zephir_array_update_string(return_value, SL("email"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_22__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_24__closure_ce, SL("__invoke")); zephir_array_update_string(return_value, SL("file"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_23__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_25__closure_ce, SL("__invoke")); zephir_array_update_string(return_value, SL("hidden"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_24__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_26__closure_ce, SL("__invoke")); zephir_array_update_string(return_value, SL("numeric"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_25__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_27__closure_ce, SL("__invoke")); zephir_array_update_string(return_value, SL("password"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_26__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_28__closure_ce, SL("__invoke")); zephir_array_update_string(return_value, SL("radio"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_27__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_29__closure_ce, SL("__invoke")); zephir_array_update_string(return_value, SL("radiogroup"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_28__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_30__closure_ce, SL("__invoke")); zephir_array_update_string(return_value, SL("select"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_29__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_31__closure_ce, SL("__invoke")); zephir_array_update_string(return_value, SL("submit"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_30__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_32__closure_ce, SL("__invoke")); zephir_array_update_string(return_value, SL("text"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_31__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_33__closure_ce, SL("__invoke")); zephir_array_update_string(return_value, SL("textarea"), &_0, PH_COPY | PH_SEPARATE); RETURN_MM(); } diff --git a/ext/phalcon/forms/loader/arrayloader.zep.c b/ext/phalcon/forms/loader/arrayloader.zep.c index 3bde373051..7f6e1a248d 100644 --- a/ext/phalcon/forms/loader/arrayloader.zep.c +++ b/ext/phalcon/forms/loader/arrayloader.zep.c @@ -66,7 +66,7 @@ PHP_METHOD(Phalcon_Forms_Loader_ArrayLoader, __construct) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &definitions_param); zephir_get_arrval(&definitions, definitions_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 772, &definitions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 781, &definitions); ZEPHIR_MM_RESTORE(); } @@ -98,7 +98,7 @@ PHP_METHOD(Phalcon_Forms_Loader_ArrayLoader, load) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 772, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 781, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "phalcon/Forms/Loader/ArrayLoader.zep", 48); if (Z_TYPE_P(&_0) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_0), _2, _3, _1) diff --git a/ext/phalcon/forms/loader/jsonloader.zep.c b/ext/phalcon/forms/loader/jsonloader.zep.c index ec0ef00ba7..a363f7708c 100644 --- a/ext/phalcon/forms/loader/jsonloader.zep.c +++ b/ext/phalcon/forms/loader/jsonloader.zep.c @@ -66,7 +66,7 @@ PHP_METHOD(Phalcon_Forms_Loader_JsonLoader, __construct) Z_PARAM_STR(source) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&source_zv, source); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 773, &source_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 782, &source_zv); } /** @@ -107,8 +107,8 @@ PHP_METHOD(Phalcon_Forms_Loader_JsonLoader, load) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&json); - zephir_read_property_cached(&json, this_ptr, _zephir_prop_0, 773, PH_NOISY_CC); - ZEPHIR_CALL_FUNCTION(&_0, "is_file", NULL, 417, &json); + zephir_read_property_cached(&json, this_ptr, _zephir_prop_0, 782, PH_NOISY_CC); + ZEPHIR_CALL_FUNCTION(&_0, "is_file", NULL, 429, &json); zephir_check_call_status(); _1 = zephir_is_true(&_0); if (_1) { @@ -135,7 +135,7 @@ PHP_METHOD(Phalcon_Forms_Loader_JsonLoader, load) ZVAL_BOOL(&_6$$4, 1); ZVAL_LONG(&_7$$4, 512); ZVAL_LONG(&_8$$4, 4194304); - ZEPHIR_CALL_METHOD(&definitions, &_5$$4, "__invoke", NULL, 359, &json, &_6$$4, &_7$$4, &_8$$4); + ZEPHIR_CALL_METHOD(&definitions, &_5$$4, "__invoke", NULL, 371, &json, &_6$$4, &_7$$4, &_8$$4); zephir_check_call_status_or_jump(try_end_1); try_end_1: diff --git a/ext/phalcon/forms/loader/yamlloader.zep.c b/ext/phalcon/forms/loader/yamlloader.zep.c index a77a8d8060..6c85597a3f 100644 --- a/ext/phalcon/forms/loader/yamlloader.zep.c +++ b/ext/phalcon/forms/loader/yamlloader.zep.c @@ -66,7 +66,7 @@ PHP_METHOD(Phalcon_Forms_Loader_YamlLoader, __construct) Z_PARAM_STR(source) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&source_zv, source); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 774, &source_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 783, &source_zv); } /** @@ -111,9 +111,9 @@ PHP_METHOD(Phalcon_Forms_Loader_YamlLoader, load) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 774, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 783, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&source, &_3); - ZEPHIR_CALL_FUNCTION(&_4, "is_file", NULL, 417, &source); + ZEPHIR_CALL_FUNCTION(&_4, "is_file", NULL, 429, &source); zephir_check_call_status(); _5 = zephir_is_true(&_4); if (_5) { @@ -122,7 +122,7 @@ PHP_METHOD(Phalcon_Forms_Loader_YamlLoader, load) _5 = zephir_is_true(&_6); } if (_5) { - ZEPHIR_CALL_FUNCTION(&definitions, "yaml_parse_file", NULL, 420, &source); + ZEPHIR_CALL_FUNCTION(&definitions, "yaml_parse_file", NULL, 432, &source); zephir_check_call_status(); } else { ZEPHIR_CALL_FUNCTION(&definitions, "yaml_parse", NULL, 0, &source); @@ -170,7 +170,7 @@ PHP_METHOD(Phalcon_Forms_Loader_YamlLoader, phpExtensionLoaded) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 431, &name_zv); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/forms/manager.zep.c b/ext/phalcon/forms/manager.zep.c index 3b2b6685af..3db5f1cc21 100644 --- a/ext/phalcon/forms/manager.zep.c +++ b/ext/phalcon/forms/manager.zep.c @@ -87,7 +87,7 @@ PHP_METHOD(Phalcon_Forms_Manager, __construct) ZEPHIR_CALL_METHOD(NULL, locator, "__construct", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 775, locator); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 784, locator); ZEPHIR_MM_RESTORE(); } @@ -161,7 +161,7 @@ PHP_METHOD(Phalcon_Forms_Manager, get) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); zephir_memory_observe(&form); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 776, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 785, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(!(zephir_array_isset_fetch(&form, &_0, &name_zv, 0)))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_forms_exceptions_formnotregistered_ce); @@ -203,7 +203,7 @@ PHP_METHOD(Phalcon_Forms_Manager, has) Z_PARAM_STR(name) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 776, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 785, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &name_zv)); } @@ -259,7 +259,7 @@ PHP_METHOD(Phalcon_Forms_Manager, loadForm) entity = &entity_sub; entity = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 775, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 784, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&locator, &_0); ZEPHIR_INIT_VAR(&_1); object_init_ex(&_1, phalcon_forms_form_ce); @@ -268,12 +268,12 @@ PHP_METHOD(Phalcon_Forms_Manager, loadForm) ZEPHIR_CALL_METHOD(&form, &_1, "load", NULL, 0, schema, &locator); zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("forms"), &name_zv, &form); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 775, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 784, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); ZEPHIR_INIT_NVAR(&_2); - zephir_create_closure_ex(&_2, NULL, phalcon_32__closure_ce, SL("__invoke")); - zephir_update_static_property_ce(phalcon_32__closure_ce, ZEND_STRL("schema"), schema); - zephir_update_static_property_ce(phalcon_32__closure_ce, ZEND_STRL("locator"), &locator); + zephir_create_closure_ex(&_2, NULL, phalcon_34__closure_ce, SL("__invoke")); + zephir_update_static_property_ce(phalcon_34__closure_ce, ZEND_STRL("schema"), schema); + zephir_update_static_property_ce(phalcon_34__closure_ce, ZEND_STRL("locator"), &locator); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &name_zv, &_2); zephir_check_call_status(); RETURN_CCTOR(&form); diff --git a/ext/phalcon/html/breadcrumbs.zep.c b/ext/phalcon/html/breadcrumbs.zep.c index 7386c74b51..e535cf3715 100644 --- a/ext/phalcon/html/breadcrumbs.zep.c +++ b/ext/phalcon/html/breadcrumbs.zep.c @@ -138,7 +138,7 @@ PHP_METHOD(Phalcon_Html_Breadcrumbs, clear) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 777, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 786, &_0); ZEPHIR_MM_RESTORE(); } @@ -185,10 +185,10 @@ PHP_METHOD(Phalcon_Html_Breadcrumbs, remove) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&link_zv); ZVAL_STR_COPY(&link_zv, link); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 777, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 786, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&elements, &_0); zephir_array_unset(&elements, &link_zv, PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 777, &elements); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 786, &elements); ZEPHIR_MM_RESTORE(); } @@ -250,14 +250,14 @@ PHP_METHOD(Phalcon_Html_Breadcrumbs, render) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 777, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 786, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&elements, &_0); if (ZEPHIR_IS_EMPTY(&elements)) { RETURN_MM_STRING(""); } ZEPHIR_INIT_VAR(&output); array_init(&output); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 778, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 787, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&template, &_0); ZEPHIR_INIT_VAR(&urls); zephir_array_keys(&urls, &elements); @@ -357,7 +357,7 @@ PHP_METHOD(Phalcon_Html_Breadcrumbs, render) zephir_array_append(&output, &_15$$7, PH_SEPARATE, "phalcon/Html/Breadcrumbs.zep", 174); } ZEPHIR_INIT_VAR(&_19); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 779, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 788, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_20); ZEPHIR_CONCAT_SVS(&_20, "
", &_0, "
"); zephir_fast_join(&_19, &_20, &output); @@ -386,7 +386,7 @@ PHP_METHOD(Phalcon_Html_Breadcrumbs, setSeparator) Z_PARAM_STR(separator) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&separator_zv, separator); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 779, &separator_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 788, &separator_zv); RETURN_THISW(); } diff --git a/ext/phalcon/html/escaper.zep.c b/ext/phalcon/html/escaper.zep.c index e12c32cdaa..aedcfebece 100644 --- a/ext/phalcon/html/escaper.zep.c +++ b/ext/phalcon/html/escaper.zep.c @@ -164,7 +164,7 @@ PHP_METHOD(Phalcon_Html_Escaper, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 780, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 789, &_0); ZEPHIR_INIT_VAR(&_1); object_init_ex(&_1, phalcon_html_escaper_cssescaper_ce); if (zephir_has_constructor(&_1)) { @@ -172,7 +172,7 @@ PHP_METHOD(Phalcon_Html_Escaper, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 781, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 790, &_1); ZEPHIR_INIT_VAR(&_2); object_init_ex(&_2, phalcon_html_escaper_htmlescaper_ce); if (zephir_has_constructor(&_2)) { @@ -180,7 +180,7 @@ PHP_METHOD(Phalcon_Html_Escaper, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 782, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 791, &_2); ZEPHIR_INIT_VAR(&_3); object_init_ex(&_3, phalcon_html_escaper_jsescaper_ce); if (zephir_has_constructor(&_3)) { @@ -188,7 +188,7 @@ PHP_METHOD(Phalcon_Html_Escaper, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 783, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 792, &_3); ZEPHIR_INIT_VAR(&_4); object_init_ex(&_4, phalcon_html_escaper_urlescaper_ce); if (zephir_has_constructor(&_4)) { @@ -196,7 +196,7 @@ PHP_METHOD(Phalcon_Html_Escaper, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 784, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 793, &_4); ZEPHIR_INIT_VAR(&_5); ZVAL_STRING(&_5, "utf-8"); if (!ZEPHIR_IS_IDENTICAL(&_5, &encoding_zv)) { @@ -255,7 +255,7 @@ PHP_METHOD(Phalcon_Html_Escaper, attributes) input = &input_sub; input = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 780, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 789, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "escape", NULL, 0, input); zephir_check_call_status(); RETURN_MM(); @@ -290,7 +290,7 @@ PHP_METHOD(Phalcon_Html_Escaper, css) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&input_zv); ZVAL_STR_COPY(&input_zv, input); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 781, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 790, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "escape", NULL, 0, &input_zv); zephir_check_call_status(); RETURN_MM(); @@ -323,7 +323,7 @@ PHP_METHOD(Phalcon_Html_Escaper, detectEncoding) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&input_zv); ZVAL_STR_COPY(&input_zv, input); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 782, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 791, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "detectencoding", NULL, 0, &input_zv); zephir_check_call_status(); RETURN_MM(); @@ -518,7 +518,7 @@ PHP_METHOD(Phalcon_Html_Escaper, getEncoding) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 782, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 791, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getencoding", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -542,7 +542,7 @@ PHP_METHOD(Phalcon_Html_Escaper, getFlags) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 782, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 791, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getflags", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -610,7 +610,7 @@ PHP_METHOD(Phalcon_Html_Escaper, html) zephir_memory_observe(&input_zv); ZVAL_STR_COPY(&input_zv, input); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 782, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 791, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "escape", NULL, 0, &input_zv); zephir_check_call_status(); RETURN_MM(); @@ -645,7 +645,7 @@ PHP_METHOD(Phalcon_Html_Escaper, js) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&input_zv); ZVAL_STR_COPY(&input_zv, input); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 783, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 792, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "escape", NULL, 0, &input_zv); zephir_check_call_status(); RETURN_MM(); @@ -678,7 +678,7 @@ PHP_METHOD(Phalcon_Html_Escaper, normalizeEncoding) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&input_zv); ZVAL_STR_COPY(&input_zv, input); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 782, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 791, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "normalizeencoding", NULL, 0, &input_zv); zephir_check_call_status(); RETURN_MM(); @@ -704,7 +704,7 @@ PHP_METHOD(Phalcon_Html_Escaper, setAttributeEscaper) Z_PARAM_OBJECT_OF_CLASS(escaper, phalcon_html_escaper_attributeescaper_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &escaper); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 780, escaper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 789, escaper); RETURN_THISW(); } @@ -728,7 +728,7 @@ PHP_METHOD(Phalcon_Html_Escaper, setCssEscaper) Z_PARAM_OBJECT_OF_CLASS(escaper, phalcon_html_escaper_cssescaper_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &escaper); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 781, escaper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 790, escaper); RETURN_THISW(); } @@ -782,7 +782,7 @@ PHP_METHOD(Phalcon_Html_Escaper, setDoubleEncode) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &doubleEncode_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 780, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 789, PH_NOISY_CC | PH_READONLY); if (doubleEncode) { ZVAL_BOOL(&_1, 1); } else { @@ -790,7 +790,7 @@ PHP_METHOD(Phalcon_Html_Escaper, setDoubleEncode) } ZEPHIR_CALL_METHOD(NULL, &_0, "setdoubleencode", NULL, 0, &_1); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 781, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 790, PH_NOISY_CC | PH_READONLY); if (doubleEncode) { ZVAL_BOOL(&_3, 1); } else { @@ -798,7 +798,7 @@ PHP_METHOD(Phalcon_Html_Escaper, setDoubleEncode) } ZEPHIR_CALL_METHOD(NULL, &_2, "setdoubleencode", NULL, 0, &_3); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 782, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 791, PH_NOISY_CC | PH_READONLY); if (doubleEncode) { ZVAL_BOOL(&_5, 1); } else { @@ -806,7 +806,7 @@ PHP_METHOD(Phalcon_Html_Escaper, setDoubleEncode) } ZEPHIR_CALL_METHOD(NULL, &_4, "setdoubleencode", NULL, 0, &_5); zephir_check_call_status(); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_3, 783, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_3, 792, PH_NOISY_CC | PH_READONLY); if (doubleEncode) { ZVAL_BOOL(&_7, 1); } else { @@ -814,7 +814,7 @@ PHP_METHOD(Phalcon_Html_Escaper, setDoubleEncode) } ZEPHIR_CALL_METHOD(NULL, &_6, "setdoubleencode", NULL, 0, &_7); zephir_check_call_status(); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_4, 784, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_4, 793, PH_NOISY_CC | PH_READONLY); if (doubleEncode) { ZVAL_BOOL(&_9, 1); } else { @@ -872,19 +872,19 @@ PHP_METHOD(Phalcon_Html_Escaper, setEncoding) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&encoding_zv); ZVAL_STR_COPY(&encoding_zv, encoding); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 780, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 789, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "setencoding", NULL, 0, &encoding_zv); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 781, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 790, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_1, "setencoding", NULL, 0, &encoding_zv); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 782, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 791, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_2, "setencoding", NULL, 0, &encoding_zv); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 783, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 792, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_3, "setencoding", NULL, 0, &encoding_zv); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_4, 784, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_4, 793, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_4, "setencoding", NULL, 0, &encoding_zv); zephir_check_call_status(); RETURN_THIS(); @@ -935,23 +935,23 @@ PHP_METHOD(Phalcon_Html_Escaper, setFlags) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &flags_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 780, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 789, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1, flags); ZEPHIR_CALL_METHOD(NULL, &_0, "setflags", NULL, 0, &_1); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 781, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 790, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2, flags); ZEPHIR_CALL_METHOD(NULL, &_1, "setflags", NULL, 0, &_2); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 782, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 791, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_3, flags); ZEPHIR_CALL_METHOD(NULL, &_2, "setflags", NULL, 0, &_3); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 783, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 792, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_4, flags); ZEPHIR_CALL_METHOD(NULL, &_3, "setflags", NULL, 0, &_4); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_4, 784, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_4, 793, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_5, flags); ZEPHIR_CALL_METHOD(NULL, &_4, "setflags", NULL, 0, &_5); zephir_check_call_status(); @@ -978,7 +978,7 @@ PHP_METHOD(Phalcon_Html_Escaper, setHtmlEscaper) Z_PARAM_OBJECT_OF_CLASS(escaper, phalcon_html_escaper_htmlescaper_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &escaper); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 782, escaper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 791, escaper); RETURN_THISW(); } @@ -1027,7 +1027,7 @@ PHP_METHOD(Phalcon_Html_Escaper, setJsEscaper) Z_PARAM_OBJECT_OF_CLASS(escaper, phalcon_html_escaper_jsescaper_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &escaper); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 783, escaper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 792, escaper); RETURN_THISW(); } @@ -1051,7 +1051,7 @@ PHP_METHOD(Phalcon_Html_Escaper, setUrlEscaper) Z_PARAM_OBJECT_OF_CLASS(escaper, phalcon_html_escaper_urlescaper_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &escaper); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 784, escaper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 793, escaper); RETURN_THISW(); } @@ -1084,7 +1084,7 @@ PHP_METHOD(Phalcon_Html_Escaper, url) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&input_zv); ZVAL_STR_COPY(&input_zv, input); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 784, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 793, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "escape", NULL, 0, &input_zv); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/html/escaper/attributeescaper.zep.c b/ext/phalcon/html/escaper/attributeescaper.zep.c index 75f322af23..e5069d2731 100644 --- a/ext/phalcon/html/escaper/attributeescaper.zep.c +++ b/ext/phalcon/html/escaper/attributeescaper.zep.c @@ -271,9 +271,9 @@ PHP_METHOD(Phalcon_Html_Escaper_AttributeEscaper, escapeValue) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&input_zv); ZVAL_STR_COPY(&input_zv, input); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 785, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 786, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 787, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 794, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 795, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 796, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_FUNCTION("htmlspecialchars", NULL, 0, &input_zv, &_0, &_1, &_2); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/html/escaper/htmlescaper.zep.c b/ext/phalcon/html/escaper/htmlescaper.zep.c index 2ca5165bc6..f4aeb5193a 100644 --- a/ext/phalcon/html/escaper/htmlescaper.zep.c +++ b/ext/phalcon/html/escaper/htmlescaper.zep.c @@ -118,9 +118,9 @@ PHP_METHOD(Phalcon_Html_Escaper_HtmlEscaper, escape) if (Z_TYPE_P(&input_zv) == IS_NULL) { RETURN_MM_STRING(""); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 788, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 789, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 790, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 797, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 798, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 799, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_FUNCTION("htmlspecialchars", NULL, 0, &input_zv, &_0, &_1, &_2); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/html/escaper/traits/escapertrait.zep.c b/ext/phalcon/html/escaper/traits/escapertrait.zep.c index 0516d53542..066ebc1a15 100644 --- a/ext/phalcon/html/escaper/traits/escapertrait.zep.c +++ b/ext/phalcon/html/escaper/traits/escapertrait.zep.c @@ -215,9 +215,9 @@ PHP_METHOD(Phalcon_Html_Escaper_Traits_EscaperTrait, setDoubleEncode) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &doubleEncode_param); if (doubleEncode) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 791, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 800, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 791, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 800, &__$false); } RETURN_THISW(); } @@ -241,7 +241,7 @@ PHP_METHOD(Phalcon_Html_Escaper_Traits_EscaperTrait, setEncoding) Z_PARAM_STR(encoding) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&encoding_zv, encoding); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 792, &encoding_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 801, &encoding_zv); RETURN_THISW(); } @@ -266,7 +266,7 @@ PHP_METHOD(Phalcon_Html_Escaper_Traits_EscaperTrait, setFlags) zephir_fetch_params_without_memory_grow(1, 0, &flags_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, flags); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 793, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 802, &_0); RETURN_THISW(); } diff --git a/ext/phalcon/html/helper/anchor.zep.c b/ext/phalcon/html/helper/anchor.zep.c index b50bf3b65a..ea2010bb9c 100644 --- a/ext/phalcon/html/helper/anchor.zep.c +++ b/ext/phalcon/html/helper/anchor.zep.c @@ -90,9 +90,9 @@ PHP_METHOD(Phalcon_Html_Helper_Anchor, __construct) ZEPHIR_CALL_PARENT(NULL, phalcon_html_helper_anchor_ce, getThis(), "__construct", NULL, 0, escaper, doctype); zephir_check_call_status(); if (forceRaw) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 794, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 803, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 794, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 803, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -166,7 +166,7 @@ PHP_METHOD(Phalcon_Html_Helper_Anchor, __invoke) _2 = raw; if (!(_2)) { zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 794, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 803, PH_NOISY_CC); _2 = zephir_is_true(&_3); } ZEPHIR_INIT_NVAR(&_1); diff --git a/ext/phalcon/html/helper/breadcrumbs.zep.c b/ext/phalcon/html/helper/breadcrumbs.zep.c index 77363d3bb1..4d4d1d6fc5 100644 --- a/ext/phalcon/html/helper/breadcrumbs.zep.c +++ b/ext/phalcon/html/helper/breadcrumbs.zep.c @@ -149,8 +149,8 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 795, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 796, url); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 804, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 805, url); ZEPHIR_MM_RESTORE(); } @@ -205,8 +205,8 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, __invoke) } else { ZEPHIR_CPY_WRT(&_0, &delimiter_zv); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 797, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 798, &indent_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 806, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 807, &indent_zv); RETURN_THIS(); } @@ -280,7 +280,7 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, add) } else { zephir_get_arrval(&attributes, attributes_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 799, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 808, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&count); ZVAL_LONG(&count, (zephir_fast_count_int(&_0) + 1)); ZEPHIR_INIT_VAR(&_1); @@ -316,7 +316,7 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, clear) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 799, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 808, &_0); ZEPHIR_MM_RESTORE(); } @@ -339,7 +339,7 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, clearAttributes) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 800, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 809, &_0); RETURN_THIS(); } @@ -411,9 +411,9 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, remove) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &index_param); zephir_memory_observe(&elements); - zephir_read_property_cached(&elements, this_ptr, _zephir_prop_0, 799, PH_NOISY_CC); + zephir_read_property_cached(&elements, this_ptr, _zephir_prop_0, 808, PH_NOISY_CC); zephir_array_unset_long(&elements, index, PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 799, &elements); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 808, &elements); ZEPHIR_MM_RESTORE(); } @@ -493,11 +493,11 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, render) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 799, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 808, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_0)) { RETURN_MM_STRING(""); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 799, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 808, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&data, &_1); ZEPHIR_INIT_VAR(&output); array_init(&output); @@ -512,7 +512,7 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, render) { ZEPHIR_INIT_NVAR(&element); ZVAL_COPY(&element, _2); - zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_1, 801, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_1, 810, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_5$$4, &_4$$4, SL("line"), PH_NOISY | PH_READONLY, "phalcon/Html/Helper/Breadcrumbs.zep", 249); ZEPHIR_CALL_METHOD(&_3$$4, this_ptr, "getlink", &_6, 0, &_5$$4, &element); zephir_check_call_status(); @@ -536,7 +536,7 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, render) } ZEPHIR_CALL_METHOD(&element, &data, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_10$$5, this_ptr, _zephir_prop_1, 801, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$5, this_ptr, _zephir_prop_1, 810, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_11$$5, &_10$$5, SL("line"), PH_NOISY | PH_READONLY, "phalcon/Html/Helper/Breadcrumbs.zep", 249); ZEPHIR_CALL_METHOD(&_9$$5, this_ptr, "getlink", &_6, 0, &_11$$5, &element); zephir_check_call_status(); @@ -544,30 +544,30 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, render) } } ZEPHIR_INIT_NVAR(&element); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 801, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 810, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_13, &_1, SL("last"), PH_NOISY | PH_READONLY, "phalcon/Html/Helper/Breadcrumbs.zep", 255); ZEPHIR_CALL_METHOD(&_12, this_ptr, "getlink", &_6, 0, &_13, &lastElement); zephir_check_call_status(); zephir_array_append(&output, &_12, PH_SEPARATE, "phalcon/Html/Helper/Breadcrumbs.zep", 255); - zephir_read_property_cached(&_14, this_ptr, _zephir_prop_2, 795, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_15, this_ptr, _zephir_prop_1, 801, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14, this_ptr, _zephir_prop_2, 804, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15, this_ptr, _zephir_prop_1, 810, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_16, &_15, SL("main"), PH_NOISY | PH_READONLY, "phalcon/Html/Helper/Breadcrumbs.zep", 258); ZEPHIR_INIT_VAR(&_17); zephir_create_array(&_17, 4, 0); - zephir_read_property_cached(&_19, this_ptr, _zephir_prop_3, 800, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19, this_ptr, _zephir_prop_3, 809, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_18, this_ptr, "processattributes", NULL, 0, &_19); zephir_check_call_status(); zephir_array_update_string(&_17, SL("attributes"), &_18, PH_COPY | PH_SEPARATE); zephir_memory_observe(&_20); - zephir_read_property_cached(&_20, this_ptr, _zephir_prop_4, 797, PH_NOISY_CC); + zephir_read_property_cached(&_20, this_ptr, _zephir_prop_4, 806, PH_NOISY_CC); zephir_array_update_string(&_17, SL("delimiter"), &_20, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_20); - zephir_read_property_cached(&_20, this_ptr, _zephir_prop_5, 798, PH_NOISY_CC); + zephir_read_property_cached(&_20, this_ptr, _zephir_prop_5, 807, PH_NOISY_CC); zephir_array_update_string(&_17, SL("indent"), &_20, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_VAR(&_21); - zephir_read_property_cached(&_22, this_ptr, _zephir_prop_5, 798, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_23, this_ptr, _zephir_prop_6, 802, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_24, this_ptr, _zephir_prop_4, 797, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22, this_ptr, _zephir_prop_5, 807, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23, this_ptr, _zephir_prop_6, 811, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24, this_ptr, _zephir_prop_4, 806, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_25); ZEPHIR_CONCAT_VVV(&_25, &_22, &_23, &_24); zephir_fast_join(&_21, &_25, &output); @@ -600,7 +600,7 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, setAttributes) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &attributes_param); zephir_get_arrval(&attributes, attributes_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 800, &attributes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 809, &attributes); RETURN_THIS(); } @@ -629,8 +629,8 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, setPrefix) Z_PARAM_STR(prefix) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&prefix_zv, prefix); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 803, &prefix_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 796, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 812, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 805, &__$null); RETURN_THISW(); } @@ -653,7 +653,7 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, setSeparator) Z_PARAM_STR(separator) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&separator_zv, separator); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 802, &separator_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 811, &separator_zv); RETURN_THISW(); } @@ -695,7 +695,7 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, setTemplate) zephir_array_update_string(&_0, SL("main"), &main_zv, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_0, SL("line"), &line_zv, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_0, SL("last"), &last_zv, PH_COPY | PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 801, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 810, &_0); RETURN_THIS(); } @@ -782,11 +782,11 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, getLink) zephir_array_fetch_string(&_0, &element, SL("link"), PH_NOISY | PH_READONLY, "phalcon/Html/Helper/Breadcrumbs.zep", 339); _1 = !(ZEPHIR_IS_EMPTY(&_0)); if (_1) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 796, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 805, PH_NOISY_CC | PH_READONLY); _1 = Z_TYPE_P(&_2) != IS_NULL; } if (_1) { - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 796, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 805, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_7$$3, &element, SL("link"), PH_NOISY | PH_READONLY, "phalcon/Html/Helper/Breadcrumbs.zep", 340); ZEPHIR_CALL_METHOD(&link, &_6$$3, "get", NULL, 0, &_7$$3); zephir_check_call_status(); @@ -794,11 +794,11 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, getLink) zephir_array_fetch_string(&_3, &element, SL("link"), PH_NOISY | PH_READONLY, "phalcon/Html/Helper/Breadcrumbs.zep", 341); _4 = !(ZEPHIR_IS_EMPTY(&_3)); if (_4) { - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 803, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 812, PH_NOISY_CC | PH_READONLY); _4 = !(ZEPHIR_IS_EMPTY(&_5)); } if (_4) { - zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_1, 803, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_1, 812, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_9$$4, &element, SL("link"), PH_NOISY | PH_READONLY, "phalcon/Html/Helper/Breadcrumbs.zep", 342); ZEPHIR_INIT_NVAR(&link); ZEPHIR_CONCAT_VV(&link, &_8$$4, &_9$$4); @@ -807,8 +807,8 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, getLink) zephir_array_fetch_string(&link, &element, SL("link"), PH_NOISY, "phalcon/Html/Helper/Breadcrumbs.zep", 344); } } - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 798, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11, this_ptr, _zephir_prop_3, 795, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 807, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11, this_ptr, _zephir_prop_3, 804, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_13); zephir_create_array(&_13, 4, 0); zephir_array_fetch_string(&_15, &element, SL("attributes"), PH_NOISY | PH_READONLY, "phalcon/Html/Helper/Breadcrumbs.zep", 351); @@ -818,7 +818,7 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, getLink) zephir_memory_observe(&_16); zephir_array_fetch_string(&_16, &element, SL("icon"), PH_NOISY, "phalcon/Html/Helper/Breadcrumbs.zep", 352); zephir_array_update_string(&_13, SL("icon"), &_16, PH_COPY | PH_SEPARATE); - zephir_read_property_cached(&_17, this_ptr, _zephir_prop_4, 804, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17, this_ptr, _zephir_prop_4, 813, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_18, &element, SL("text"), PH_NOISY | PH_READONLY, "phalcon/Html/Helper/Breadcrumbs.zep", 353); ZEPHIR_CALL_METHOD(&_14, &_17, "html", NULL, 0, &_18); zephir_check_call_status(); @@ -826,7 +826,7 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, getLink) zephir_array_update_string(&_13, SL("link"), &link, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(&_12, &_11, "__invoke", NULL, 0, &template_zv, &_13); zephir_check_call_status(); - zephir_read_property_cached(&_19, this_ptr, _zephir_prop_5, 797, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19, this_ptr, _zephir_prop_5, 806, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_VVV(return_value, &_10, &_12, &_19); RETURN_MM(); } diff --git a/ext/phalcon/html/helper/button.zep.c b/ext/phalcon/html/helper/button.zep.c index 6931fa842e..0422ad4d99 100644 --- a/ext/phalcon/html/helper/button.zep.c +++ b/ext/phalcon/html/helper/button.zep.c @@ -90,9 +90,9 @@ PHP_METHOD(Phalcon_Html_Helper_Button, __construct) ZEPHIR_CALL_PARENT(NULL, phalcon_html_helper_button_ce, getThis(), "__construct", NULL, 0, escaper, doctype); zephir_check_call_status(); if (forceRaw) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 805, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 814, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 805, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 814, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -156,7 +156,7 @@ PHP_METHOD(Phalcon_Html_Helper_Button, __invoke) _0 = raw; if (!(_0)) { zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 805, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 814, PH_NOISY_CC); _0 = zephir_is_true(&_1); } ZEPHIR_INIT_VAR(&_2); diff --git a/ext/phalcon/html/helper/doctype.zep.c b/ext/phalcon/html/helper/doctype.zep.c index 4b2a9b260f..0dea15f42a 100644 --- a/ext/phalcon/html/helper/doctype.zep.c +++ b/ext/phalcon/html/helper/doctype.zep.c @@ -122,10 +122,10 @@ PHP_METHOD(Phalcon_Html_Helper_Doctype, __construct) ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 5); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 806, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 815, &_0); ZEPHIR_INIT_VAR(&_1); ZEPHIR_GET_CONSTANT(&_1, "PHP_EOL"); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 807, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 816, &_1); ZEPHIR_MM_RESTORE(); } @@ -178,8 +178,8 @@ PHP_METHOD(Phalcon_Html_Helper_Doctype, __invoke) } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, type); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 806, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 807, &delimiter_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 815, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 816, &delimiter_zv); RETURN_THIS(); } @@ -218,64 +218,64 @@ PHP_METHOD(Phalcon_Html_Helper_Doctype, __toString) if (UNEXPECTED(!_zephir_prop_1)) { _zephir_prop_1 = zend_string_init("delimiter", 9, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 806, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 815, PH_NOISY_CC | PH_READONLY); do { if (ZEPHIR_IS_LONG(&_0, 1)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SV(return_value, "", &_1$$3); return; } if (ZEPHIR_IS_LONG(&_0, 2)) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SVSV(return_value, "", &_3$$4); return; } if (ZEPHIR_IS_LONG(&_0, 3)) { - zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SVSV(return_value, "", &_5$$5); return; } if (ZEPHIR_IS_LONG(&_0, 4)) { - zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SVSV(return_value, "", &_7$$6); return; } if (ZEPHIR_IS_LONG(&_0, 6)) { - zephir_read_property_cached(&_8$$7, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_9$$7, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$7, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$7, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SVSV(return_value, "", &_9$$7); return; } if (ZEPHIR_IS_LONG(&_0, 7)) { - zephir_read_property_cached(&_10$$8, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11$$8, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$8, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$8, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SVSV(return_value, "", &_11$$8); return; } if (ZEPHIR_IS_LONG(&_0, 8)) { - zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_13$$9, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$9, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SVSV(return_value, "", &_13$$9); return; } if (ZEPHIR_IS_LONG(&_0, 9)) { - zephir_read_property_cached(&_14$$10, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_15$$10, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$10, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$10, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SVSV(return_value, "", &_15$$10); return; } if (ZEPHIR_IS_LONG(&_0, 10)) { - zephir_read_property_cached(&_16$$11, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_17$$11, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$11, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$11, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SVSV(return_value, "", &_17$$11); return; } } while(0); - zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 816, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SV(return_value, "", &_18); return; } diff --git a/ext/phalcon/html/helper/element.zep.c b/ext/phalcon/html/helper/element.zep.c index 690ba2d929..6543a3ef17 100644 --- a/ext/phalcon/html/helper/element.zep.c +++ b/ext/phalcon/html/helper/element.zep.c @@ -90,9 +90,9 @@ PHP_METHOD(Phalcon_Html_Helper_Element, __construct) ZEPHIR_CALL_PARENT(NULL, phalcon_html_helper_element_ce, getThis(), "__construct", NULL, 0, escaper, doctype); zephir_check_call_status(); if (forceRaw) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 808, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 817, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 808, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 817, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -160,7 +160,7 @@ PHP_METHOD(Phalcon_Html_Helper_Element, __invoke) _0 = raw; if (!(_0)) { zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 808, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 817, PH_NOISY_CC); _0 = zephir_is_true(&_1); } ZVAL_BOOL(&_2, _0); diff --git a/ext/phalcon/html/helper/friendlytitle.zep.c b/ext/phalcon/html/helper/friendlytitle.zep.c index a6748995be..8cd4457b96 100644 --- a/ext/phalcon/html/helper/friendlytitle.zep.c +++ b/ext/phalcon/html/helper/friendlytitle.zep.c @@ -77,7 +77,7 @@ PHP_METHOD(Phalcon_Html_Helper_FriendlyTitle, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 809, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 818, &_0); ZEPHIR_MM_RESTORE(); } @@ -150,7 +150,7 @@ PHP_METHOD(Phalcon_Html_Helper_FriendlyTitle, __invoke) } /* try_start_1: */ - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 809, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 818, PH_NOISY_CC | PH_READONLY); if (lowercase) { ZVAL_BOOL(&_1$$3, 1); } else { diff --git a/ext/phalcon/html/helper/input/checkboxgroup.zep.c b/ext/phalcon/html/helper/input/checkboxgroup.zep.c index 9879874567..6e5e11d1e1 100644 --- a/ext/phalcon/html/helper/input/checkboxgroup.zep.c +++ b/ext/phalcon/html/helper/input/checkboxgroup.zep.c @@ -82,20 +82,20 @@ PHP_METHOD(Phalcon_Html_Helper_Input_CheckboxGroup, isChecked) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&value_zv); ZVAL_STR_COPY(&value_zv, value); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 810, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 819, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { RETURN_MM_BOOL(0); } zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 810, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 819, PH_NOISY_CC); if (Z_TYPE_P(&_1) == IS_ARRAY) { zephir_memory_observe(&selected); - zephir_read_property_cached(&selected, this_ptr, _zephir_prop_0, 810, PH_NOISY_CC); + zephir_read_property_cached(&selected, this_ptr, _zephir_prop_0, 819, PH_NOISY_CC); } else { ZEPHIR_INIT_VAR(&_2$$5); zephir_create_array(&_2$$5, 1, 0); zephir_memory_observe(&_3$$5); - zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_0, 810, PH_NOISY_CC); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_0, 819, PH_NOISY_CC); zephir_array_fast_append(&_2$$5, &_3$$5); ZEPHIR_CPY_WRT(&selected, &_2$$5); } diff --git a/ext/phalcon/html/helper/input/generic.zep.c b/ext/phalcon/html/helper/input/generic.zep.c index 01ef9a7c4e..54c6aa8c56 100644 --- a/ext/phalcon/html/helper/input/generic.zep.c +++ b/ext/phalcon/html/helper/input/generic.zep.c @@ -92,7 +92,7 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Generic, __construct) } ZEPHIR_CALL_PARENT(NULL, phalcon_html_helper_input_generic_ce, getThis(), "__construct", NULL, 0, escaper, doctype); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 811, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 820, &type_zv); ZEPHIR_MM_RESTORE(); } @@ -119,7 +119,7 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Generic, setType) Z_PARAM_STR(type) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&type_zv, type); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 811, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 820, &type_zv); RETURN_THISW(); } diff --git a/ext/phalcon/html/helper/input/radiogroup.zep.c b/ext/phalcon/html/helper/input/radiogroup.zep.c index 2f4777ab64..38ecaca590 100644 --- a/ext/phalcon/html/helper/input/radiogroup.zep.c +++ b/ext/phalcon/html/helper/input/radiogroup.zep.c @@ -77,12 +77,12 @@ PHP_METHOD(Phalcon_Html_Helper_Input_RadioGroup, isChecked) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&value_zv); ZVAL_STR_COPY(&value_zv, value); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 812, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 821, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { RETURN_MM_BOOL(0); } zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 812, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 821, PH_NOISY_CC); zephir_cast_to_string(&_2, &_1); RETURN_MM_BOOL(ZEPHIR_IS_IDENTICAL(&_2, &value_zv)); } diff --git a/ext/phalcon/html/helper/input/select.zep.c b/ext/phalcon/html/helper/input/select.zep.c index d7a254a864..f4c214e472 100644 --- a/ext/phalcon/html/helper/input/select.zep.c +++ b/ext/phalcon/html/helper/input/select.zep.c @@ -136,7 +136,7 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select, add) ZEPHIR_INIT_VAR(&_3); zephir_create_array(&_3, 4, 0); zephir_memory_observe(&_4); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 813, PH_NOISY_CC); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 822, PH_NOISY_CC); zephir_array_fast_append(&_3, &_4); zephir_array_fast_append(&_3, &text_zv); zephir_array_fast_append(&_3, &attributes); @@ -229,7 +229,7 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select, addPlaceholder) ZEPHIR_INIT_VAR(&_2); zephir_create_array(&_2, 4, 0); zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 813, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 822, PH_NOISY_CC); zephir_array_fast_append(&_2, &_3); zephir_array_fast_append(&_2, &text_zv); zephir_array_fast_append(&_2, &attributes); @@ -567,7 +567,7 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select, optGroup) } else { zephir_get_arrval(&attributes, attributes_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 814, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 823, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_INIT_VAR(&_1$$3); zephir_create_array(&_1$$3, 3, 0); @@ -585,15 +585,15 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select, optGroup) zephir_update_property_array_append(this_ptr, SL("store"), &_1$$3); ZEPHIR_INIT_NVAR(&_2$$3); ZVAL_LONG(&_2$$3, 1); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 815, PH_NOISY_CC); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 824, PH_NOISY_CC); ZEPHIR_ADD_ASSIGN(&_5$$3, &_2$$3) - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 815, &_5$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 824, &_5$$3); } else { ZEPHIR_INIT_VAR(&_7$$4); ZVAL_LONG(&_7$$4, 1); - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_1, 815, PH_NOISY_CC); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_1, 824, PH_NOISY_CC); ZEPHIR_SUB_ASSIGN(&_6$$4, &_7$$4) - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 815, &_6$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 824, &_6$$4); ZEPHIR_INIT_VAR(&_8$$4); zephir_create_array(&_8$$4, 3, 0); ZEPHIR_INIT_VAR(&_9$$4); @@ -608,11 +608,11 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select, optGroup) zephir_update_property_array_append(this_ptr, SL("store"), &_8$$4); } zephir_memory_observe(&_11); - zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 814, PH_NOISY_CC); + zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 823, PH_NOISY_CC); if (!zephir_is_true(&_11)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 814, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 823, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 814, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 823, &__$false); } RETURN_THIS(); } @@ -663,7 +663,7 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select, placeholder) ZEPHIR_INIT_VAR(&_2); zephir_create_array(&_2, 4, 0); zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 813, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 822, PH_NOISY_CC); zephir_array_fast_append(&_2, &_3); zephir_array_fast_append(&_2, &text_zv); ZEPHIR_INIT_VAR(&_4); @@ -702,7 +702,7 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select, selected) Z_PARAM_STR(selected) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&selected_zv, selected); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 816, &selected_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 825, &selected_zv); RETURN_THISW(); } @@ -739,9 +739,9 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select, strict) } else { } if (flag) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 817, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 826, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 817, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 826, &__$false); } RETURN_THISW(); } @@ -856,14 +856,14 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select, processValue) } if (_0) { zephir_array_update_string(&attributes, SL("value"), &value_zv, PH_COPY | PH_SEPARATE); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 816, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 825, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_STRING_IDENTICAL(&_1$$3, "")) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 817, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 826, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_2$$4)) { - zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_0, 816, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_0, 825, PH_NOISY_CC | PH_READONLY); matched = ZEPHIR_IS_IDENTICAL(&value_zv, &_3$$5); } else { - zephir_read_property_cached(&_4$$6, this_ptr, _zephir_prop_0, 816, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$6, this_ptr, _zephir_prop_0, 825, PH_NOISY_CC | PH_READONLY); matched = ZEPHIR_IS_EQUAL(&value_zv, &_4$$6); } if (matched) { diff --git a/ext/phalcon/html/helper/input/select/arraydata.zep.c b/ext/phalcon/html/helper/input/select/arraydata.zep.c index 5d632d9319..3f2488fa09 100644 --- a/ext/phalcon/html/helper/input/select/arraydata.zep.c +++ b/ext/phalcon/html/helper/input/select/arraydata.zep.c @@ -95,8 +95,8 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select_ArrayData, __construct) } else { zephir_get_arrval(&attributes, attributes_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 818, &data); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 819, &attributes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 827, &data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 828, &attributes); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/html/helper/input/select/resultsetdata.zep.c b/ext/phalcon/html/helper/input/select/resultsetdata.zep.c index deac620d28..89b3682978 100644 --- a/ext/phalcon/html/helper/input/select/resultsetdata.zep.c +++ b/ext/phalcon/html/helper/input/select/resultsetdata.zep.c @@ -117,9 +117,9 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select_ResultsetData, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 820, resultset); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 821, &using); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 822, &attributesMap); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 829, resultset); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 830, &using); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 831, &attributesMap); ZEPHIR_MM_RESTORE(); } @@ -143,7 +143,7 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select_ResultsetData, getAttributes) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 823, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 832, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "resolve", NULL, 0); zephir_check_call_status(); @@ -169,7 +169,7 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select_ResultsetData, getOptions) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 824, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 833, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "resolve", NULL, 0); zephir_check_call_status(); @@ -283,17 +283,17 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select_ResultsetData, resolve) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 821, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 830, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&usingZero); zephir_array_fetch_long(&usingZero, &_0, 0, PH_NOISY, "phalcon/Html/Helper/Input/Select/ResultsetData.zep", 123); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 821, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 830, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&usingOne); zephir_array_fetch_long(&usingOne, &_1, 1, PH_NOISY, "phalcon/Html/Helper/Input/Select/ResultsetData.zep", 124); ZEPHIR_INIT_VAR(&options); array_init(&options); ZEPHIR_INIT_VAR(&attrs); array_init(&attrs); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 820, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 829, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_2, 0, "phalcon/Html/Helper/Input/Select/ResultsetData.zep", 159); if (Z_TYPE_P(&_2) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_2), _3) @@ -319,11 +319,11 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select_ResultsetData, resolve) zephir_check_call_status(); zephir_array_update_zval(&options, &optionValue, &optionText, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_8$$3); - zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_2, 822, PH_NOISY_CC); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_2, 831, PH_NOISY_CC); if (!(ZEPHIR_IS_EMPTY(&_8$$3))) { ZEPHIR_INIT_NVAR(&optionAttrs); array_init(&optionAttrs); - zephir_read_property_cached(&_9$$5, this_ptr, _zephir_prop_2, 822, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$5, this_ptr, _zephir_prop_2, 831, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_9$$5, 0, "phalcon/Html/Helper/Input/Select/ResultsetData.zep", 153); if (Z_TYPE_P(&_9$$5) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_9$$5), _11$$5, _12$$5, _10$$5) @@ -431,11 +431,11 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select_ResultsetData, resolve) zephir_check_call_status(); zephir_array_update_zval(&options, &optionValue, &optionText, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_24$$15); - zephir_read_property_cached(&_24$$15, this_ptr, _zephir_prop_2, 822, PH_NOISY_CC); + zephir_read_property_cached(&_24$$15, this_ptr, _zephir_prop_2, 831, PH_NOISY_CC); if (!(ZEPHIR_IS_EMPTY(&_24$$15))) { ZEPHIR_INIT_NVAR(&optionAttrs); array_init(&optionAttrs); - zephir_read_property_cached(&_25$$17, this_ptr, _zephir_prop_2, 822, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$17, this_ptr, _zephir_prop_2, 831, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_25$$17, 0, "phalcon/Html/Helper/Input/Select/ResultsetData.zep", 153); if (Z_TYPE_P(&_25$$17) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_25$$17), _27$$17, _28$$17, _26$$17) @@ -508,8 +508,8 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select_ResultsetData, resolve) } } ZEPHIR_INIT_NVAR(&option); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 824, &options); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 823, &attrs); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 833, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 832, &attrs); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/html/helper/input/textarea.zep.c b/ext/phalcon/html/helper/input/textarea.zep.c index 6f223c5caa..f1c46a4473 100644 --- a/ext/phalcon/html/helper/input/textarea.zep.c +++ b/ext/phalcon/html/helper/input/textarea.zep.c @@ -74,11 +74,11 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Textarea, __toString) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 825, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 834, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&attributes, &_0); ZEPHIR_INIT_VAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 825, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 834, &_1); zephir_memory_observe(&value); if (!(zephir_array_isset_string_fetch(&value, &attributes, SL("value"), 0))) { ZEPHIR_INIT_NVAR(&value); @@ -86,7 +86,7 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Textarea, __toString) } zephir_array_unset_string(&attributes, SL("type"), PH_SEPARATE); zephir_array_unset_string(&attributes, SL("value"), PH_SEPARATE); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 826, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 835, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "renderfullelement", NULL, 0, &_2, &value, &attributes); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/html/helper/label.zep.c b/ext/phalcon/html/helper/label.zep.c index 9f4415fece..9f619e9597 100644 --- a/ext/phalcon/html/helper/label.zep.c +++ b/ext/phalcon/html/helper/label.zep.c @@ -90,9 +90,9 @@ PHP_METHOD(Phalcon_Html_Helper_Label, __construct) ZEPHIR_CALL_PARENT(NULL, phalcon_html_helper_label_ce, getThis(), "__construct", NULL, 0, escaper, doctype); zephir_check_call_status(); if (forceRaw) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 827, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 836, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 827, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 836, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -156,7 +156,7 @@ PHP_METHOD(Phalcon_Html_Helper_Label, __invoke) _0 = raw; if (!(_0)) { zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 827, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 836, PH_NOISY_CC); _0 = zephir_is_true(&_1); } ZEPHIR_INIT_VAR(&_2); diff --git a/ext/phalcon/html/helper/ol.zep.c b/ext/phalcon/html/helper/ol.zep.c index 47b181b282..d0ef93fa11 100644 --- a/ext/phalcon/html/helper/ol.zep.c +++ b/ext/phalcon/html/helper/ol.zep.c @@ -91,9 +91,9 @@ PHP_METHOD(Phalcon_Html_Helper_Ol, __construct) ZEPHIR_CALL_PARENT(NULL, phalcon_html_helper_ol_ce, getThis(), "__construct", NULL, 0, escaper, doctype); zephir_check_call_status(); if (forceRaw) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 263, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 264, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 263, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 264, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -167,14 +167,14 @@ PHP_METHOD(Phalcon_Html_Helper_Ol, add) ZEPHIR_INIT_VAR(&_2); zephir_create_array(&_2, 4, 0); zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 264, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 265, PH_NOISY_CC); zephir_array_fast_append(&_2, &_3); zephir_array_fast_append(&_2, &text_zv); zephir_array_fast_append(&_2, &attributes); _4 = raw; if (!(_4)) { ZEPHIR_OBS_NVAR(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 263, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 264, PH_NOISY_CC); _4 = zephir_is_true(&_3); } ZEPHIR_INIT_NVAR(&_1); diff --git a/ext/phalcon/html/helper/preload.zep.c b/ext/phalcon/html/helper/preload.zep.c index c372b9b577..bff6c41998 100644 --- a/ext/phalcon/html/helper/preload.zep.c +++ b/ext/phalcon/html/helper/preload.zep.c @@ -81,7 +81,7 @@ PHP_METHOD(Phalcon_Html_Helper_Preload, __construct) } ZEPHIR_CALL_PARENT(NULL, phalcon_html_helper_preload_ce, getThis(), "__construct", NULL, 0, escaper); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 828, response); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 837, response); ZEPHIR_MM_RESTORE(); } @@ -157,7 +157,7 @@ PHP_METHOD(Phalcon_Html_Helper_Preload, __invoke) ZEPHIR_INIT_VAR(&_0); zephir_fast_array_merge(&_0, &overrides, &attributes); ZEPHIR_CPY_WRT(&overrides, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 828, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 837, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_1) != IS_NULL) { ZEPHIR_INIT_VAR(&link); object_init_ex(&link, phalcon_html_link_link_ce); @@ -182,7 +182,7 @@ PHP_METHOD(Phalcon_Html_Helper_Preload, __invoke) zephir_check_call_status(); ZEPHIR_INIT_VAR(&header); ZEPHIR_CONCAT_SV(&header, "Link: ", &_4$$3); - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 828, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 837, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_6$$3, "setrawheader", NULL, 0, &header); zephir_check_call_status(); } diff --git a/ext/phalcon/html/helper/style.zep.c b/ext/phalcon/html/helper/style.zep.c index c709996852..81f2f8fd24 100644 --- a/ext/phalcon/html/helper/style.zep.c +++ b/ext/phalcon/html/helper/style.zep.c @@ -145,9 +145,9 @@ PHP_METHOD(Phalcon_Html_Helper_Style, setStyle) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &flag_param); if (flag) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 265, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 266, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 265, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 266, &__$false); } RETURN_THISW(); } @@ -193,7 +193,7 @@ PHP_METHOD(Phalcon_Html_Helper_Style, getAttributes) zephir_array_update_string(&required, SL("href"), &url_zv, PH_COPY | PH_SEPARATE); add_assoc_stringl_ex(&required, SL("type"), SL("text/css")); add_assoc_stringl_ex(&required, SL("media"), SL("screen")); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 265, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 266, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { zephir_array_unset_string(&required, SL("rel"), PH_SEPARATE); } @@ -221,7 +221,7 @@ PHP_METHOD(Phalcon_Html_Helper_Style, getTag) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 265, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 266, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_1)) { ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "style"); diff --git a/ext/phalcon/html/helper/title.zep.c b/ext/phalcon/html/helper/title.zep.c index 837f08ed68..8463af45c6 100644 --- a/ext/phalcon/html/helper/title.zep.c +++ b/ext/phalcon/html/helper/title.zep.c @@ -124,8 +124,8 @@ PHP_METHOD(Phalcon_Html_Helper_Title, __invoke) } else { ZEPHIR_CPY_WRT(&_0, &delimiter_zv); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 829, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 830, &indent_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 838, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 839, &indent_zv); RETURN_THIS(); } @@ -184,28 +184,28 @@ PHP_METHOD(Phalcon_Html_Helper_Title, __toString) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 831, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 840, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_create_array(&_1, 1, 0); zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 832, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 841, PH_NOISY_CC); zephir_array_fast_append(&_1, &_2); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 833, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 842, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&items, "array_merge", NULL, 195, &_0, &_1, &_3); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_4); array_init(&_4); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 833, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 842, &_4); ZEPHIR_INIT_VAR(&_5); array_init(&_5); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 831, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 840, &_5); ZEPHIR_INIT_VAR(&_6); ZEPHIR_INIT_NVAR(&_6); ZVAL_STRING(&_6, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 832, &_6); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_3, 830, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 841, &_6); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_3, 839, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_6); - zephir_read_property_cached(&_9, this_ptr, _zephir_prop_4, 834, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_4, 843, PH_NOISY_CC | PH_READONLY); zephir_fast_join(&_6, &_9, &items); ZEPHIR_INIT_VAR(&_10); array_init(&_10); @@ -214,7 +214,7 @@ PHP_METHOD(Phalcon_Html_Helper_Title, __toString) ZVAL_BOOL(&_12, 1); ZEPHIR_CALL_METHOD(&_8, this_ptr, "renderfullelement", NULL, 0, &_11, &_6, &_10, &_12); zephir_check_call_status(); - zephir_read_property_cached(&_12, this_ptr, _zephir_prop_5, 829, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12, this_ptr, _zephir_prop_5, 838, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_VVV(return_value, &_7, &_8, &_12); RETURN_MM(); } @@ -261,7 +261,7 @@ PHP_METHOD(Phalcon_Html_Helper_Title, append) if (raw) { ZEPHIR_CPY_WRT(&_0, &text); } else { - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 835, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 844, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_0, &_1, "html", NULL, 0, &text); zephir_check_call_status(); } @@ -327,12 +327,12 @@ PHP_METHOD(Phalcon_Html_Helper_Title, set) if (raw) { ZEPHIR_CPY_WRT(&_0, &text); } else { - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 835, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 844, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_0, &_1, "html", NULL, 0, &text); zephir_check_call_status(); } zephir_get_strval(&text, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 832, &text); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 841, &text); RETURN_THIS(); } @@ -385,11 +385,11 @@ PHP_METHOD(Phalcon_Html_Helper_Title, setSeparator) if (raw) { ZEPHIR_CPY_WRT(&_0, &separator_zv); } else { - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 835, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 844, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_0, &_1, "html", NULL, 0, &separator_zv); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 834, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 843, &_0); RETURN_THIS(); } @@ -441,18 +441,18 @@ PHP_METHOD(Phalcon_Html_Helper_Title, prepend) if (raw) { ZEPHIR_CPY_WRT(&_0, &text); } else { - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 835, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 844, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_0, &_1, "html", NULL, 0, &text); zephir_check_call_status(); } zephir_get_strval(&text, &_0); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 831, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 840, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&prepend, &_2); ZEPHIR_MAKE_REF(&prepend); ZEPHIR_CALL_FUNCTION(NULL, "array_unshift", NULL, 0, &prepend, &text); ZEPHIR_UNREF(&prepend); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 831, &prepend); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 840, &prepend); RETURN_THIS(); } diff --git a/ext/phalcon/html/helper/voidtag.zep.c b/ext/phalcon/html/helper/voidtag.zep.c index fc624f12cc..82dee20348 100644 --- a/ext/phalcon/html/helper/voidtag.zep.c +++ b/ext/phalcon/html/helper/voidtag.zep.c @@ -90,10 +90,10 @@ PHP_METHOD(Phalcon_Html_Helper_VoidTag, __invoke) } ZEPHIR_INIT_VAR(&closeTag); ZVAL_STRING(&closeTag, ""); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 836, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 845, PH_NOISY_CC | PH_READONLY); _1 = Z_TYPE_P(&_0) != IS_NULL; if (_1) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 836, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 845, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_3, &_2, "gettype", NULL, 0); zephir_check_call_status(); _1 = ZEPHIR_GT_LONG(&_3, 5); diff --git a/ext/phalcon/html/tagfactory.zep.c b/ext/phalcon/html/tagfactory.zep.c index 25a0f9b624..4f5b4c55e5 100644 --- a/ext/phalcon/html/tagfactory.zep.c +++ b/ext/phalcon/html/tagfactory.zep.c @@ -202,17 +202,17 @@ PHP_METHOD(Phalcon_Html_TagFactory, __construct) url = &url_sub; url = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 837, escaper); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 838, response); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 839, url); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 846, escaper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 847, response); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 848, url); ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, phalcon_html_helper_doctype_ce); ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 840, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 849, &_0); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getdefaultservices", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 841, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 850, &_1); zephir_is_iterable(&services, 0, "phalcon/Html/TagFactory.zep", 169); if (Z_TYPE_P(&services) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&services), _3, _4, _2) @@ -325,7 +325,7 @@ PHP_METHOD(Phalcon_Html_TagFactory, has) Z_PARAM_STR(name) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 841, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 850, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &name_zv)); } @@ -370,7 +370,7 @@ PHP_METHOD(Phalcon_Html_TagFactory, newInstance) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 841, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 850, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_0, &name_zv))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_html_exceptions_servicenotregistered_ce); @@ -380,9 +380,9 @@ PHP_METHOD(Phalcon_Html_TagFactory, newInstance) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 842, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 851, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_2, &name_zv))) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 841, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 850, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&factory); zephir_array_fetch(&factory, &_3$$4, &name_zv, PH_NOISY, "phalcon/Html/TagFactory.zep", 216); ZEPHIR_INIT_VAR(&_4$$4); @@ -390,7 +390,7 @@ PHP_METHOD(Phalcon_Html_TagFactory, newInstance) zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("instances"), &name_zv, &_4$$4); } - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 842, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 851, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_6, &_5, &name_zv, PH_NOISY | PH_READONLY, "phalcon/Html/TagFactory.zep", 220); RETURN_CTOR(&_6); } @@ -426,7 +426,7 @@ PHP_METHOD(Phalcon_Html_TagFactory, set) ZVAL_STR(&name_zv, name); zephir_update_property_array(this_ptr, SL("factories"), &name_zv, definition); zephir_unset_property_array(this_ptr, ZEND_STRL("instances"), &name_zv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 842, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_0, &name_zv, PH_SEPARATE); } @@ -462,283 +462,283 @@ PHP_METHOD(Phalcon_Html_TagFactory, getDefaultServices) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 837, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 846, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&escaper, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 838, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 847, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&response, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 839, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 848, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&url, &_0); zephir_create_array(return_value, 59, 0); ZEPHIR_INIT_VAR(&_1); ZEPHIR_INIT_NVAR(&_1); - zephir_create_closure_ex(&_1, this_ptr, phalcon_33__closure_ce, SL("__invoke")); - zephir_update_static_property_ce(phalcon_33__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("a"), &_1, PH_COPY | PH_SEPARATE); - ZEPHIR_INIT_NVAR(&_1); - ZEPHIR_INIT_NVAR(&_1); - zephir_create_closure_ex(&_1, this_ptr, phalcon_34__closure_ce, SL("__invoke")); - zephir_update_static_property_ce(phalcon_34__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("aRaw"), &_1, PH_COPY | PH_SEPARATE); - ZEPHIR_INIT_NVAR(&_1); - ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_35__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_35__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("base"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("a"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_36__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_36__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("body"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("aRaw"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); - zephir_create_closure_ex(&_1, NULL, phalcon_37__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_1, this_ptr, phalcon_37__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_37__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_update_static_property_ce(phalcon_37__closure_ce, ZEND_STRL("url"), &url); - zephir_array_update_string(return_value, SL("breadcrumbs"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("base"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_38__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_38__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("button"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("body"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); - zephir_create_closure_ex(&_1, this_ptr, phalcon_39__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_1, NULL, phalcon_39__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_39__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("buttonRaw"), &_1, PH_COPY | PH_SEPARATE); + zephir_update_static_property_ce(phalcon_39__closure_ce, ZEND_STRL("url"), &url); + zephir_array_update_string(return_value, SL("breadcrumbs"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_40__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_40__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("close"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("button"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_41__closure_ce, SL("__invoke")); - zephir_array_update_string(return_value, SL("doctype"), &_1, PH_COPY | PH_SEPARATE); + zephir_update_static_property_ce(phalcon_41__closure_ce, ZEND_STRL("escaper"), &escaper); + zephir_array_update_string(return_value, SL("buttonRaw"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_42__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_42__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("element"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("close"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_43__closure_ce, SL("__invoke")); - zephir_update_static_property_ce(phalcon_43__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("elementRaw"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("doctype"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_44__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_44__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("form"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("element"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); - zephir_create_closure_ex(&_1, NULL, phalcon_45__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_1, this_ptr, phalcon_45__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_45__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("friendlyTitle"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("elementRaw"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_46__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_46__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("img"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("form"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); - zephir_create_closure_ex(&_1, this_ptr, phalcon_47__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_1, NULL, phalcon_47__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_47__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputCheckbox"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("friendlyTitle"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_48__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_48__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputCheckboxGroup"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("img"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_49__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_49__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputColor"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputCheckbox"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_50__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_50__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputDate"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputCheckboxGroup"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_51__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_51__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputDateTime"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputColor"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_52__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_52__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputDateTimeLocal"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputDate"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_53__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_53__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputEmail"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputDateTime"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_54__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_54__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputFile"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputDateTimeLocal"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_55__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_55__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputHidden"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputEmail"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_56__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_56__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputImage"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputFile"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_57__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_57__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputInput"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputHidden"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_58__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_58__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputMonth"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputImage"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_59__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_59__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputNumeric"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputInput"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_60__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_60__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputPassword"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputMonth"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_61__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_61__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputRadio"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputNumeric"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_62__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_62__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputRadioGroup"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputPassword"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_63__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_63__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputRange"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputRadio"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_64__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_64__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputSearch"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputRadioGroup"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_65__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_65__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputSelect"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputRange"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_66__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_66__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputSubmit"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputSearch"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_67__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_67__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputTel"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputSelect"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_68__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_68__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputText"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputSubmit"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_69__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_69__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputTextarea"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputTel"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_70__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_70__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputTime"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputText"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_71__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_71__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputUrl"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputTextarea"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_72__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_72__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("inputWeek"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputTime"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_73__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_73__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("label"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputUrl"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_74__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_74__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("labelRaw"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("inputWeek"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_75__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_75__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("link"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("label"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_76__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_76__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("meta"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("labelRaw"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_77__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_77__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("ol"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("link"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_78__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_78__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("olRaw"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("meta"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); - zephir_create_closure_ex(&_1, NULL, phalcon_79__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_1, this_ptr, phalcon_79__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_79__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_update_static_property_ce(phalcon_79__closure_ce, ZEND_STRL("response"), &response); - zephir_array_update_string(return_value, SL("preload"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("ol"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_80__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_80__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("script"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("olRaw"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); - zephir_create_closure_ex(&_1, this_ptr, phalcon_81__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_1, NULL, phalcon_81__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_81__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("style"), &_1, PH_COPY | PH_SEPARATE); + zephir_update_static_property_ce(phalcon_81__closure_ce, ZEND_STRL("response"), &response); + zephir_array_update_string(return_value, SL("preload"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_82__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_82__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("tag"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("script"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_83__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_83__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("title"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("style"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_84__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_84__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("ul"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("tag"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_85__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_85__closure_ce, ZEND_STRL("escaper"), &escaper); - zephir_array_update_string(return_value, SL("ulRaw"), &_1, PH_COPY | PH_SEPARATE); + zephir_array_update_string(return_value, SL("title"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, this_ptr, phalcon_86__closure_ce, SL("__invoke")); zephir_update_static_property_ce(phalcon_86__closure_ce, ZEND_STRL("escaper"), &escaper); + zephir_array_update_string(return_value, SL("ul"), &_1, PH_COPY | PH_SEPARATE); + ZEPHIR_INIT_NVAR(&_1); + ZEPHIR_INIT_NVAR(&_1); + zephir_create_closure_ex(&_1, this_ptr, phalcon_87__closure_ce, SL("__invoke")); + zephir_update_static_property_ce(phalcon_87__closure_ce, ZEND_STRL("escaper"), &escaper); + zephir_array_update_string(return_value, SL("ulRaw"), &_1, PH_COPY | PH_SEPARATE); + ZEPHIR_INIT_NVAR(&_1); + ZEPHIR_INIT_NVAR(&_1); + zephir_create_closure_ex(&_1, this_ptr, phalcon_88__closure_ce, SL("__invoke")); + zephir_update_static_property_ce(phalcon_88__closure_ce, ZEND_STRL("escaper"), &escaper); zephir_array_update_string(return_value, SL("voidTag"), &_1, PH_COPY | PH_SEPARATE); RETURN_MM(); } diff --git a/ext/phalcon/http/cookie.zep.c b/ext/phalcon/http/cookie.zep.c index 330f428c1d..2a57a8d099 100644 --- a/ext/phalcon/http/cookie.zep.c +++ b/ext/phalcon/http/cookie.zep.c @@ -217,23 +217,23 @@ PHP_METHOD(Phalcon_Http_Cookie, __construct) } else { zephir_get_arrval(&options, options_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 843, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 852, &name_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, expire); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 844, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 845, &path_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 853, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 854, &path_zv); if (secure) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 846, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 855, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 846, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 855, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 847, &domain_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 856, &domain_zv); if (httpOnly) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 848, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 857, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 848, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 857, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 849, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 858, &options); if (Z_TYPE_P(value) != IS_NULL) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "setvalue", NULL, 0, value); zephir_check_call_status(); @@ -321,15 +321,15 @@ PHP_METHOD(Phalcon_Http_Cookie, delete) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 843, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 852, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&name, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 847, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 856, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&domain, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 845, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 854, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&path, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 846, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 855, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&secure, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 848, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 857, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&httpOnly, &_0); ZEPHIR_CALL_METHOD(&session, this_ptr, "getstartedsession", NULL, 0); zephir_check_call_status(); @@ -339,8 +339,8 @@ PHP_METHOD(Phalcon_Http_Cookie, delete) ZEPHIR_CALL_METHOD(NULL, &session, "remove", NULL, 0, &_1$$3); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 850, &__$null); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 849, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 859, &__$null); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 858, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); ZEPHIR_INIT_VAR(&_3); zephir_time(&_3); @@ -395,7 +395,7 @@ PHP_METHOD(Phalcon_Http_Cookie, getDomain) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 860, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "restore", NULL, 0); zephir_check_call_status(); @@ -421,7 +421,7 @@ PHP_METHOD(Phalcon_Http_Cookie, getExpiration) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 860, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "restore", NULL, 0); zephir_check_call_status(); @@ -447,7 +447,7 @@ PHP_METHOD(Phalcon_Http_Cookie, getHttpOnly) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 860, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "restore", NULL, 0); zephir_check_call_status(); @@ -491,7 +491,7 @@ PHP_METHOD(Phalcon_Http_Cookie, getPath) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 860, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "restore", NULL, 0); zephir_check_call_status(); @@ -518,7 +518,7 @@ PHP_METHOD(Phalcon_Http_Cookie, getSecure) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 860, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "restore", NULL, 0); zephir_check_call_status(); @@ -611,25 +611,25 @@ PHP_METHOD(Phalcon_Http_Cookie, getValue) defaultValue = &defaultValue_sub; defaultValue = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 860, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "restore", NULL, 0); zephir_check_call_status(); } ZEPHIR_INIT_VAR(&container); ZVAL_NULL(&container); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 843, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 852, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&name, &_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 852, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 861, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_FALSE_IDENTICAL(&_1)) { zephir_memory_observe(&value); if (!(zephir_array_isset_fetch(&value, &_COOKIE, &name, 0))) { RETVAL_ZVAL(defaultValue, 1, 0); RETURN_MM(); } - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 853, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 862, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_2$$4)) { - zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_4, 854, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_4, 863, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_3$$6); if (Z_TYPE_P(&container) == IS_NULL) { ZEPHIR_INIT_VAR(&_4$$7); @@ -654,7 +654,7 @@ PHP_METHOD(Phalcon_Http_Cookie, getValue) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_5, 855, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_5, 864, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&signKey, &_3$$6); if (Z_TYPE_P(&signKey) == IS_STRING) { ZEPHIR_CALL_METHOD(&decryptedValue, &crypt, "decryptbase64", NULL, 0, &value, &signKey); @@ -666,13 +666,13 @@ PHP_METHOD(Phalcon_Http_Cookie, getValue) } else { ZEPHIR_CPY_WRT(&decryptedValue, &value); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 850, &decryptedValue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 859, &decryptedValue); if (Z_TYPE_P(filters) != IS_NULL) { - zephir_read_property_cached(&_8$$12, this_ptr, _zephir_prop_7, 856, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$12, this_ptr, _zephir_prop_7, 865, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&filter, &_8$$12); if (Z_TYPE_P(&filter) != IS_OBJECT) { if (Z_TYPE_P(&container) == IS_NULL) { - zephir_read_property_cached(&_9$$14, this_ptr, _zephir_prop_4, 854, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$14, this_ptr, _zephir_prop_4, 863, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_9$$14); if (Z_TYPE_P(&container) == IS_NULL) { ZEPHIR_INIT_VAR(&_10$$15); @@ -689,7 +689,7 @@ PHP_METHOD(Phalcon_Http_Cookie, getValue) ZEPHIR_CALL_METHOD(&_11$$13, &container, "getshared", NULL, 0, &_12$$13); zephir_check_call_status(); ZEPHIR_CPY_WRT(&filter, &_11$$13); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 856, &filter); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 865, &filter); } ZEPHIR_RETURN_CALL_METHOD(&filter, "sanitize", NULL, 0, &decryptedValue, filters); zephir_check_call_status(); @@ -757,7 +757,7 @@ PHP_METHOD(Phalcon_Http_Cookie, restore) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 860, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_CALL_METHOD(&session, this_ptr, "getstartedsession", NULL, 0); zephir_check_call_status(); @@ -767,28 +767,28 @@ PHP_METHOD(Phalcon_Http_Cookie, restore) ZEPHIR_CALL_METHOD(&definition, &session, "get", NULL, 0, &_1$$4); zephir_check_call_status(); if (zephir_array_isset_string_fetch(&expire, &definition, SL("expire"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 844, &expire); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 853, &expire); } if (zephir_array_isset_string_fetch(&domain, &definition, SL("domain"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 847, &domain); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 856, &domain); } if (zephir_array_isset_string_fetch(&path, &definition, SL("path"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 845, &path); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 854, &path); } if (zephir_array_isset_string_fetch(&secure, &definition, SL("secure"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 846, &secure); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 855, &secure); } if (zephir_array_isset_string_fetch(&httpOnly, &definition, SL("httpOnly"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 848, &httpOnly); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 857, &httpOnly); } if (zephir_array_isset_string_fetch(&options, &definition, SL("options"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 849, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 858, &options); } } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 851, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 860, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 851, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 860, &__$false); } } RETURN_THIS(); @@ -884,23 +884,23 @@ PHP_METHOD(Phalcon_Http_Cookie, send) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 843, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 852, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&name, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 859, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&value, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 844, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 853, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&expire, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 847, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 856, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&domain, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 845, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 854, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&path, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 846, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 855, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&secure, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 848, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 857, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&httpOnly, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_7, 849, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_7, 858, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_8, 854, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_8, 863, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); ZEPHIR_INIT_VAR(&definition); array_init(&definition); @@ -923,7 +923,7 @@ PHP_METHOD(Phalcon_Http_Cookie, send) zephir_check_call_status(); } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_9, 853, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_9, 862, PH_NOISY_CC | PH_READONLY); _3 = zephir_is_true(&_0); if (_3) { _3 = !(ZEPHIR_IS_EMPTY(&value)); @@ -952,7 +952,7 @@ PHP_METHOD(Phalcon_Http_Cookie, send) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_8$$5, this_ptr, _zephir_prop_10, 855, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$5, this_ptr, _zephir_prop_10, 864, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&signKey, &_8$$5); if (Z_TYPE_P(&signKey) == IS_STRING) { zephir_cast_to_string(&_9$$8, &value); @@ -1025,12 +1025,12 @@ PHP_METHOD(Phalcon_Http_Cookie, setDomain) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&domain_zv); ZVAL_STR_COPY(&domain_zv, domain); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 860, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "restore", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 847, &domain_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 856, &domain_zv); RETURN_THIS(); } @@ -1061,14 +1061,14 @@ PHP_METHOD(Phalcon_Http_Cookie, setExpiration) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &expire_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 860, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "restore", NULL, 0); zephir_check_call_status(); } ZVAL_UNDEF(&_1); ZVAL_LONG(&_1, expire); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 844, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 853, &_1); RETURN_THIS(); } @@ -1101,15 +1101,15 @@ PHP_METHOD(Phalcon_Http_Cookie, setHttpOnly) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &httpOnly_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 860, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "restore", NULL, 0); zephir_check_call_status(); } if (httpOnly) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 848, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 857, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 848, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 857, &__$false); } RETURN_THIS(); } @@ -1137,7 +1137,7 @@ PHP_METHOD(Phalcon_Http_Cookie, setOptions) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &options_param); zephir_get_arrval(&options, options_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 849, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 858, &options); RETURN_THIS(); } @@ -1170,12 +1170,12 @@ PHP_METHOD(Phalcon_Http_Cookie, setPath) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&path_zv); ZVAL_STR_COPY(&path_zv, path); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 860, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "restore", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 845, &path_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 854, &path_zv); RETURN_THIS(); } @@ -1208,15 +1208,15 @@ PHP_METHOD(Phalcon_Http_Cookie, setSecure) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &secure_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 860, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "restore", NULL, 0); zephir_check_call_status(); } if (secure) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 846, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 855, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 846, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 855, &__$false); } RETURN_THIS(); } @@ -1263,7 +1263,7 @@ PHP_METHOD(Phalcon_Http_Cookie, setSignKey) ZEPHIR_CALL_METHOD(NULL, this_ptr, "assertsignkeyislongenough", NULL, 0, &signKey_zv); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 855, &signKey_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 864, &signKey_zv); RETURN_THIS(); } @@ -1293,11 +1293,11 @@ PHP_METHOD(Phalcon_Http_Cookie, setValue) Z_PARAM_ZVAL(value) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &value); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 850, value); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 859, value); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 852, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 861, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 852, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 861, &__$false); } RETURN_THISW(); } @@ -1323,9 +1323,9 @@ PHP_METHOD(Phalcon_Http_Cookie, useEncryption) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &useEncryption_param); if (useEncryption) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 853, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 862, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 853, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 862, &__$false); } RETURN_THISW(); } @@ -1379,7 +1379,7 @@ PHP_METHOD(Phalcon_Http_Cookie, getSessionKey) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("name", 4, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 843, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 852, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SV(return_value, "_PHCOOKIE_", &_0); return; } @@ -1409,7 +1409,7 @@ PHP_METHOD(Phalcon_Http_Cookie, getStartedSession) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 854, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 863, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); _1 = Z_TYPE_P(&container) != IS_OBJECT; if (!(_1)) { diff --git a/ext/phalcon/http/request.zep.c b/ext/phalcon/http/request.zep.c index 09968fa1e0..6f60f4750b 100644 --- a/ext/phalcon/http/request.zep.c +++ b/ext/phalcon/http/request.zep.c @@ -249,13 +249,13 @@ PHP_METHOD(Phalcon_Http_Request, getAttributes) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 857, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 866, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_http_request_bag_attributebag_ce); ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 857, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 866, &_1$$3); } RETURN_MM_MEMBER(getThis(), "attributes"); } @@ -450,16 +450,16 @@ PHP_METHOD(Phalcon_Http_Request, getClientAddress) RETURN_MM_BOOL(0); } if (trustForwardedHeader) { - zephir_read_property_cached(&_0$$4, this_ptr, _zephir_prop_0, 858, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$4, this_ptr, _zephir_prop_0, 867, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_STRING_IDENTICAL(&_0$$4, "")) { zephir_memory_observe(&trustedProxyHeaderIp); - zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_0, 858, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_0, 867, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&trustedProxyHeaderIp, &server, &_1$$5, 0)) { RETURN_CCTOR(&trustedProxyHeaderIp); } } zephir_memory_observe(&_2$$4); - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 859, PH_NOISY_CC); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 868, PH_NOISY_CC); _3$$4 = !(ZEPHIR_IS_EMPTY(&_2$$4)); if (_3$$4) { ZEPHIR_CALL_METHOD(&_4$$4, this_ptr, "isproxytrusted", NULL, 0, &address); @@ -478,7 +478,7 @@ PHP_METHOD(Phalcon_Http_Request, getClientAddress) ZVAL_STRING(&_6$$8, "trim"); ZEPHIR_CALL_FUNCTION(&forwardedIps, "array_map", NULL, 19, &_6$$8, &_5$$8); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&reverseForwardedIps, "array_reverse", NULL, 255, &forwardedIps); + ZEPHIR_CALL_FUNCTION(&reverseForwardedIps, "array_reverse", NULL, 261, &forwardedIps); zephir_check_call_status(); zephir_is_iterable(&reverseForwardedIps, 0, "phalcon/Http/Request.zep", 289); if (Z_TYPE_P(&reverseForwardedIps) == IS_ARRAY) { @@ -487,7 +487,7 @@ PHP_METHOD(Phalcon_Http_Request, getClientAddress) ZEPHIR_INIT_NVAR(&forwardedIp); ZVAL_COPY(&forwardedIp, _7$$8); ZEPHIR_OBS_NVAR(&_8$$9); - zephir_read_property_cached(&_8$$9, this_ptr, _zephir_prop_1, 859, PH_NOISY_CC); + zephir_read_property_cached(&_8$$9, this_ptr, _zephir_prop_1, 868, PH_NOISY_CC); _9$$9 = !(ZEPHIR_IS_EMPTY(&_8$$9)); if (_9$$9) { ZEPHIR_CALL_METHOD(&_10$$9, this_ptr, "isproxytrusted", NULL, 0, &forwardedIp); @@ -522,7 +522,7 @@ PHP_METHOD(Phalcon_Http_Request, getClientAddress) ZEPHIR_CALL_METHOD(&forwardedIp, &reverseForwardedIps, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&_14$$12); - zephir_read_property_cached(&_14$$12, this_ptr, _zephir_prop_1, 859, PH_NOISY_CC); + zephir_read_property_cached(&_14$$12, this_ptr, _zephir_prop_1, 868, PH_NOISY_CC); _15$$12 = !(ZEPHIR_IS_EMPTY(&_14$$12)); if (_15$$12) { ZEPHIR_CALL_METHOD(&_16$$12, this_ptr, "isproxytrusted", NULL, 0, &forwardedIp); @@ -721,7 +721,7 @@ PHP_METHOD(Phalcon_Http_Request, getFilteredData) } else { } zephir_memory_observe(&filters); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 860, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 869, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_1, &_0, &methodKey_zv, PH_READONLY, "phalcon/Http/Request.zep", 366); if (!(zephir_array_isset_fetch(&filters, &_1, &name_zv, 0))) { ZEPHIR_INIT_NVAR(&filters); @@ -1378,7 +1378,7 @@ PHP_METHOD(Phalcon_Http_Request, getHttpHost) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&strict); - zephir_read_property_cached(&strict, this_ptr, _zephir_prop_0, 861, PH_NOISY_CC); + zephir_read_property_cached(&strict, this_ptr, _zephir_prop_0, 870, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "HTTP_HOST"); ZEPHIR_CALL_METHOD(&host, this_ptr, "getserver", NULL, 0, &_0); @@ -1517,7 +1517,7 @@ PHP_METHOD(Phalcon_Http_Request, getJsonRawBody) } else { ZVAL_BOOL(&_1, 0); } - ZEPHIR_RETURN_CALL_METHOD(&_0, "__invoke", NULL, 359, &rawBody, &_1); + ZEPHIR_RETURN_CALL_METHOD(&_0, "__invoke", NULL, 371, &rawBody, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -1606,7 +1606,7 @@ PHP_METHOD(Phalcon_Http_Request, getMethod) ZEPHIR_INIT_NVAR(&returnMethod); zephir_fast_strtoupper(&returnMethod, &overridedMethod); } else { - zephir_read_property_cached(&_2$$5, this_ptr, _zephir_prop_0, 862, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$5, this_ptr, _zephir_prop_0, 871, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_2$$5)) { zephir_memory_observe(&spoofedMethod); if (zephir_array_isset_string_fetch(&spoofedMethod, &_REQUEST, SL("_method"), 0)) { @@ -1703,11 +1703,11 @@ PHP_METHOD(Phalcon_Http_Request, getPatch) noRecursive = 0; } else { } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 863, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 872, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_0, this_ptr, "getpostdata", NULL, 0, &_1); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 863, &_0); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 863, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 872, &_0); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 872, PH_NOISY_CC | PH_READONLY); if (notAllowEmpty) { ZVAL_BOOL(&_3, 1); } else { @@ -1867,8 +1867,8 @@ PHP_METHOD(Phalcon_Http_Request, getPost) } ZEPHIR_CALL_METHOD(&_0, this_ptr, "getpostdata", NULL, 0, &_POST); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 863, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 863, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 872, &_0); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 872, PH_NOISY_CC | PH_READONLY); if (notAllowEmpty) { ZVAL_BOOL(&_2, 1); } else { @@ -2009,11 +2009,11 @@ PHP_METHOD(Phalcon_Http_Request, getPut) noRecursive = 0; } else { } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 863, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 872, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_0, this_ptr, "getpostdata", NULL, 0, &_1); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 863, &_0); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 863, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 872, &_0); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 872, PH_NOISY_CC | PH_READONLY); if (notAllowEmpty) { ZVAL_BOOL(&_3, 1); } else { @@ -2142,14 +2142,14 @@ PHP_METHOD(Phalcon_Http_Request, getRawBody) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 864, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 873, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&rawBody, &_0); if (ZEPHIR_IS_EMPTY(&rawBody)) { ZEPHIR_INIT_VAR(&_1$$3); ZVAL_STRING(&_1$$3, "php://input"); ZEPHIR_CALL_METHOD(&contents, this_ptr, "phpfilegetcontents", NULL, 0, &_1$$3); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 864, &contents); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 873, &contents); RETURN_CCTOR(&contents); } RETURN_CCTOR(&rawBody); @@ -3331,9 +3331,9 @@ PHP_METHOD(Phalcon_Http_Request, setHttpMethodParameterOverride) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &override_param); if (override) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 862, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 871, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 862, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 871, &__$false); } RETURN_THISW(); } @@ -3515,9 +3515,9 @@ PHP_METHOD(Phalcon_Http_Request, setStrictHostCheck) } else { } if (flag) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 861, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 870, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 861, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 870, &__$false); } RETURN_THISW(); } @@ -3652,7 +3652,7 @@ PHP_METHOD(Phalcon_Http_Request, setTrustedProxyHeader) ZEPHIR_CONCAT_SV(&_5$$3, "HTTP_", &trustedHeader); ZEPHIR_CPY_WRT(&trustedHeader, &_5$$3); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 858, &trustedHeader); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 867, &trustedHeader); RETURN_THIS(); } @@ -4349,11 +4349,11 @@ PHP_METHOD(Phalcon_Http_Request, isIpAddressInCIDR) } ZEPHIR_INIT_VAR(&_3); ZVAL_STRING(&_3, "H*"); - ZEPHIR_CALL_FUNCTION(&ipBits, "unpack", NULL, 503, &_3, &ipBin); + ZEPHIR_CALL_FUNCTION(&ipBits, "unpack", NULL, 0, &_3, &ipBin); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_3); ZVAL_STRING(&_3, "H*"); - ZEPHIR_CALL_FUNCTION(&subnetBits, "unpack", NULL, 503, &_3, &subnetBin); + ZEPHIR_CALL_FUNCTION(&subnetBits, "unpack", NULL, 0, &_3, &subnetBin); zephir_check_call_status(); zephir_array_fetch_long(&_4, &ipBits, 1, PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 1699); ZEPHIR_CPY_WRT(&ipBits, &_4); @@ -4377,7 +4377,7 @@ PHP_METHOD(Phalcon_Http_Request, isIpAddressInCIDR) maskBytes = (int) zephir_floor(&_5); remainingBits = (long) (zephir_safe_mod_zval_long(&maskLength, 8)); ZVAL_LONG(&_8, maskBytes); - ZEPHIR_CALL_FUNCTION(&_9, "strncmp", NULL, 404, &ipBits, &subnetBits, &_8); + ZEPHIR_CALL_FUNCTION(&_9, "strncmp", NULL, 416, &ipBits, &subnetBits, &_8); zephir_check_call_status(); if (!ZEPHIR_IS_LONG_IDENTICAL(&_9, 0)) { RETURN_MM_BOOL(0); @@ -4887,10 +4887,10 @@ PHP_METHOD(Phalcon_Http_Request, getFilterService) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 865, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 874, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&filterService, &_0); if (Z_TYPE_P(&filterService) != IS_OBJECT) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 866, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 875, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_1$$3); if (Z_TYPE_P(&container) == IS_NULL) { ZEPHIR_INIT_VAR(&_2$$4); @@ -4906,7 +4906,7 @@ PHP_METHOD(Phalcon_Http_Request, getFilterService) ZEPHIR_CALL_METHOD(&_3$$3, &container, "getshared", NULL, 0, &_4$$3); zephir_check_call_status(); ZEPHIR_CPY_WRT(&filterService, &_3$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 865, &filterService); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 874, &filterService); } RETURN_MM_MEMBER(getThis(), "filterService"); } @@ -5634,7 +5634,7 @@ PHP_METHOD(Phalcon_Http_Request, isProxyTrusted) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&ip_zv); ZVAL_STR_COPY(&ip_zv, ip); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 859, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 868, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "phalcon/Http/Request.zep", 2019); if (Z_TYPE_P(&_0) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1) diff --git a/ext/phalcon/http/request/bag/abstractbag.zep.c b/ext/phalcon/http/request/bag/abstractbag.zep.c index 221838535f..fe9246b719 100644 --- a/ext/phalcon/http/request/bag/abstractbag.zep.c +++ b/ext/phalcon/http/request/bag/abstractbag.zep.c @@ -92,7 +92,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, __construct) } ZEPHIR_CALL_METHOD(&_0, this_ptr, "normalizeitems", NULL, 0, &items); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 266, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 267, &_0); ZEPHIR_MM_RESTORE(); } @@ -122,7 +122,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, count) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("items", 5, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 266, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 267, PH_NOISY_CC | PH_READONLY); RETURN_LONG(zephir_fast_count_int(&_0)); } @@ -170,7 +170,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, get) ZEPHIR_CALL_METHOD(&_0, this_ptr, "normalizekey", NULL, 0, &key); zephir_check_call_status(); zephir_get_strval(&key, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 266, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 267, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&value, &_1, &key, 1)) { if (Z_TYPE_P(&value) != IS_NULL) { RETURN_CTOR(&value); @@ -226,7 +226,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, getArray) ZEPHIR_CALL_METHOD(&_0, this_ptr, "normalizekey", NULL, 0, &key); zephir_check_call_status(); zephir_get_strval(&key, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 266, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 267, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&value, &_1, &key, 1)) { if (Z_TYPE_P(&value) == IS_ARRAY) { RETURN_CTOR(&value); @@ -278,7 +278,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, getBool) ZEPHIR_CALL_METHOD(&_0, this_ptr, "normalizekey", NULL, 0, &key); zephir_check_call_status(); zephir_get_strval(&key, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 266, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 267, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&value, &_1, &key, 1)) { if (Z_TYPE_P(&value) != IS_NULL) { RETURN_MM_BOOL(zephir_get_boolval(&value)); @@ -331,7 +331,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, getFloat) ZEPHIR_CALL_METHOD(&_0, this_ptr, "normalizekey", NULL, 0, &key); zephir_check_call_status(); zephir_get_strval(&key, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 266, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 267, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&value, &_1, &key, 1)) { if (Z_TYPE_P(&value) != IS_NULL) { RETURN_MM_DOUBLE(zephir_get_doubleval(&value)); @@ -382,7 +382,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, getInt) ZEPHIR_CALL_METHOD(&_0, this_ptr, "normalizekey", NULL, 0, &key); zephir_check_call_status(); zephir_get_strval(&key, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 266, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 267, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&value, &_1, &key, 1)) { if (Z_TYPE_P(&value) != IS_NULL) { RETURN_MM_LONG(zephir_get_intval(&value)); @@ -412,7 +412,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, getIterator) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); object_init_ex(return_value, spl_ce_ArrayIterator); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 266, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 267, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 18, &_0); zephir_check_call_status(); RETURN_MM(); @@ -467,7 +467,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, getString) ZEPHIR_CALL_METHOD(&_0, this_ptr, "normalizekey", NULL, 0, &key); zephir_check_call_status(); zephir_get_strval(&key, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 266, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 267, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&value, &_1, &key, 1)) { if (Z_TYPE_P(&value) != IS_NULL) { zephir_cast_to_string(&_2$$4, &value); @@ -509,7 +509,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, has) ZVAL_STR_COPY(&key_zv, key); ZEPHIR_CALL_METHOD(&_0, this_ptr, "normalizekey", NULL, 0, &key_zv); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 266, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 267, PH_NOISY_CC | PH_READONLY); RETURN_MM_BOOL(zephir_array_key_exists(&_1, &_0)); } @@ -610,7 +610,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, offsetSet) if (Z_TYPE_P(offset) == IS_NULL) { ZEPHIR_INIT_VAR(&_0$$3); object_init_ex(&_0$$3, phalcon_http_request_exceptions_nullkeyexception_ce); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 240); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 246); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$3, "phalcon/Http/Request/Bag/AbstractBag.zep", 275); ZEPHIR_MM_RESTORE(); @@ -684,7 +684,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, remove) zephir_check_call_status(); zephir_get_strval(&key, &_0); zephir_unset_property_array(this_ptr, ZEND_STRL("items"), &key); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 266, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 267, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_1, &key, PH_SEPARATE); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/http/request/file.zep.c b/ext/phalcon/http/request/file.zep.c index 9602f79ac6..dc4c5f2cf4 100644 --- a/ext/phalcon/http/request/file.zep.c +++ b/ext/phalcon/http/request/file.zep.c @@ -162,7 +162,7 @@ PHP_METHOD(Phalcon_Http_Request_File, __construct) } zephir_memory_observe(&name); if (zephir_array_isset_string_fetch(&name, &file, SL("name"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 867, &name); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 876, &name); ZEPHIR_INIT_VAR(&_0$$3); ZVAL_STRING(&_0$$3, "PATHINFO_EXTENSION"); ZEPHIR_CALL_FUNCTION(&_1$$3, "defined", NULL, 147, &_0$$3); @@ -171,31 +171,31 @@ PHP_METHOD(Phalcon_Http_Request_File, __construct) ZVAL_LONG(&_2$$4, 4); ZEPHIR_CALL_FUNCTION(&_3$$4, "pathinfo", NULL, 199, &name, &_2$$4); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 868, &_3$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 877, &_3$$4); } } ZEPHIR_INIT_VAR(&_5); ZVAL_STRING(&_5, "tmp_name"); ZEPHIR_CALL_METHOD(&_4, this_ptr, "getarrval", NULL, 0, &file, &_5); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 869, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 878, &_4); ZEPHIR_INIT_NVAR(&_5); ZVAL_STRING(&_5, "size"); ZEPHIR_CALL_METHOD(&_6, this_ptr, "getarrval", NULL, 0, &file, &_5); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 870, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 879, &_6); ZEPHIR_INIT_NVAR(&_5); ZVAL_STRING(&_5, "type"); ZEPHIR_CALL_METHOD(&_7, this_ptr, "getarrval", NULL, 0, &file, &_5); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 871, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 880, &_7); ZEPHIR_INIT_NVAR(&_5); ZVAL_STRING(&_5, "error"); ZEPHIR_CALL_METHOD(&_8, this_ptr, "getarrval", NULL, 0, &file, &_5); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 872, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 881, &_8); if (!(ZEPHIR_IS_EMPTY(&key_zv))) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 873, &key_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 882, &key_zv); } ZEPHIR_MM_RESTORE(); } @@ -265,16 +265,16 @@ PHP_METHOD(Phalcon_Http_Request_File, getRealType) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 874, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 883, PH_NOISY_CC); if (ZEPHIR_IS_EMPTY(&_0)) { ZVAL_LONG(&_1$$3, 16); ZEPHIR_CALL_FUNCTION(&finfo, "finfo_open", NULL, 0, &_1$$3); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&finfo)) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 869, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 878, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&mime, "finfo_file", NULL, 0, &finfo, &_2$$4); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 874, &mime); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 883, &mime); } } RETURN_MM_MEMBER_TYPED(getThis(), "realType", IS_STRING); @@ -329,7 +329,7 @@ PHP_METHOD(Phalcon_Http_Request_File, isUploadedFile) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name); - zephir_read_property_cached(&name, this_ptr, _zephir_prop_0, 869, PH_NOISY_CC); + zephir_read_property_cached(&name, this_ptr, _zephir_prop_0, 878, PH_NOISY_CC); _0 = !(ZEPHIR_IS_EMPTY(&name)); if (_0) { ZEPHIR_CALL_FUNCTION(&_1, "is_uploaded_file", NULL, 34, &name); @@ -364,7 +364,7 @@ PHP_METHOD(Phalcon_Http_Request_File, moveTo) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&destination_zv); ZVAL_STR_COPY(&destination_zv, destination); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 869, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 878, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_FUNCTION("move_uploaded_file", NULL, 0, &_0, &destination_zv); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/http/response.zep.c b/ext/phalcon/http/response.zep.c index ddaea71a90..2ef9a87d14 100644 --- a/ext/phalcon/http/response.zep.c +++ b/ext/phalcon/http/response.zep.c @@ -150,7 +150,7 @@ PHP_METHOD(Phalcon_Http_Response, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 875, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 884, &_0); ZEPHIR_INIT_VAR(&_1); object_init_ex(&_1, phalcon_support_helper_json_encode_ce); if (zephir_has_constructor(&_1)) { @@ -158,7 +158,7 @@ PHP_METHOD(Phalcon_Http_Response, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 876, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 885, &_1); if (!ZEPHIR_IS_NULL(&content_zv)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "setcontent", NULL, 0, &content_zv); zephir_check_call_status(); @@ -198,7 +198,7 @@ PHP_METHOD(Phalcon_Http_Response, appendContent) zephir_check_call_status(); ZEPHIR_INIT_VAR(&_1); ZEPHIR_CONCAT_VV(&_1, &_0, content); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 877, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 886, &_1); RETURN_THIS(); } @@ -222,7 +222,7 @@ PHP_METHOD(Phalcon_Http_Response, getContent) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 877, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 886, PH_NOISY_CC); zephir_cast_to_string(&_1, &_0); RETURN_CTOR(&_1); } @@ -256,7 +256,7 @@ PHP_METHOD(Phalcon_Http_Response, getDI) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 878, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 887, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (Z_TYPE_P(&container) == IS_NULL) { ZEPHIR_CALL_CE_STATIC(&container, phalcon_di_di_ce, "getdefault", NULL, 0); @@ -270,7 +270,7 @@ PHP_METHOD(Phalcon_Http_Response, getDI) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 878, &container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 887, &container); } RETURN_CCTOR(&container); } @@ -321,7 +321,7 @@ PHP_METHOD(Phalcon_Http_Response, getReasonPhrase) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 875, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "Status"); ZEPHIR_CALL_METHOD(&_1, &_0, "get", NULL, 0, &_2); @@ -369,7 +369,7 @@ PHP_METHOD(Phalcon_Http_Response, getStatusCode) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 875, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "Status"); ZEPHIR_CALL_METHOD(&_1, &_0, "get", NULL, 0, &_2); @@ -604,7 +604,7 @@ PHP_METHOD(Phalcon_Http_Response, removeHeader) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 875, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "remove", NULL, 0, &name_zv); zephir_check_call_status(); RETURN_THIS(); @@ -628,7 +628,7 @@ PHP_METHOD(Phalcon_Http_Response, resetHeaders) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 875, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "reset", NULL, 0); zephir_check_call_status(); RETURN_THIS(); @@ -668,7 +668,7 @@ PHP_METHOD(Phalcon_Http_Response, send) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 879, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 888, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(zephir_is_true(&_0))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_http_response_exceptions_responsealreadysent_ce); @@ -682,12 +682,12 @@ PHP_METHOD(Phalcon_Http_Response, send) zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, this_ptr, "sendcookies", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 877, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 886, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&content, &_2); if (Z_TYPE_P(&content) != IS_NULL) { zend_print_zval(&content, 0); } else { - zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_2, 880, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_2, 889, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&file, &_3$$5); _4$$5 = Z_TYPE_P(&file) == IS_STRING; if (_4$$5) { @@ -699,9 +699,9 @@ PHP_METHOD(Phalcon_Http_Response, send) } } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 879, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 888, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 879, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 888, &__$false); } RETURN_THIS(); } @@ -725,7 +725,7 @@ PHP_METHOD(Phalcon_Http_Response, sendCookies) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 881, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 890, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cookies, &_0); if (Z_TYPE_P(&cookies) == IS_OBJECT) { ZEPHIR_CALL_METHOD(NULL, &cookies, "send", NULL, 0); @@ -763,9 +763,9 @@ PHP_METHOD(Phalcon_Http_Response, sendHeaders) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 875, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&headers, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 882, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 891, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_0); if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_2$$3); @@ -864,7 +864,7 @@ PHP_METHOD(Phalcon_Http_Response, setContent) Z_PARAM_STR(content) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&content_zv, content); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 877, &content_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 886, &content_zv); RETURN_THISW(); } @@ -963,7 +963,7 @@ PHP_METHOD(Phalcon_Http_Response, setCookies) Z_PARAM_OBJECT_OF_CLASS(cookies, phalcon_http_response_cookiesinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &cookies); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 881, cookies); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 890, cookies); RETURN_THISW(); } @@ -985,7 +985,7 @@ PHP_METHOD(Phalcon_Http_Response, setDI) Z_PARAM_OBJECT_OF_CLASS(container, phalcon_di_diinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &container); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 878, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 887, container); } /** @@ -1041,7 +1041,7 @@ PHP_METHOD(Phalcon_Http_Response, setEventsManager) Z_PARAM_OBJECT_OF_CLASS(eventsManager, phalcon_events_managerinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &eventsManager); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 882, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 891, eventsManager); } /** @@ -1206,7 +1206,7 @@ PHP_METHOD(Phalcon_Http_Response, setFileToSend) } else { ZEPHIR_INIT_VAR(&_7$$8); ZVAL_STRING(&_7$$8, "\15\17\\\""); - ZEPHIR_CALL_FUNCTION(&_8$$8, "addcslashes", NULL, 489, &basePath, &_7$$8); + ZEPHIR_CALL_FUNCTION(&_8$$8, "addcslashes", NULL, 500, &basePath, &_7$$8); zephir_check_call_status(); ZEPHIR_CPY_WRT(&basePath, &_8$$8); ZEPHIR_INIT_VAR(&_9$$8); @@ -1215,7 +1215,7 @@ PHP_METHOD(Phalcon_Http_Response, setFileToSend) zephir_check_call_status(); } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 880, &filePath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 889, &filePath_zv); RETURN_THIS(); } @@ -1251,7 +1251,7 @@ PHP_METHOD(Phalcon_Http_Response, setHeader) value = ZEND_CALL_ARG(execute_data, 2); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 875, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &name_zv, value); zephir_check_call_status(); RETURN_THIS(); @@ -1302,7 +1302,7 @@ PHP_METHOD(Phalcon_Http_Response, setHeaders) } ZEPHIR_INIT_NVAR(&value); ZVAL_COPY(&value, _0); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 875, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_3$$3, "set", NULL, 0, &name, &value); zephir_check_call_status(); } ZEND_HASH_FOREACH_END(); @@ -1326,7 +1326,7 @@ PHP_METHOD(Phalcon_Http_Response, setHeaders) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&value, &data, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_0, 875, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_6$$4, "set", NULL, 0, &name, &value); zephir_check_call_status(); } @@ -1387,7 +1387,7 @@ PHP_METHOD(Phalcon_Http_Response, setJsonContent) ZVAL_STRING(&_0, "application/json"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "setcontenttype", NULL, 0, &_0); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 876, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 885, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_3, jsonOptions); ZVAL_LONG(&_4, depth); ZEPHIR_CALL_METHOD(&_2, &_1, "__invoke", NULL, 0, content, &_3, &_4); @@ -1502,7 +1502,7 @@ PHP_METHOD(Phalcon_Http_Response, setRawHeader) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&header_zv); ZVAL_STR_COPY(&header_zv, header); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 875, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "setraw", NULL, 0, &header_zv); zephir_check_call_status(); RETURN_THIS(); @@ -1568,7 +1568,7 @@ PHP_METHOD(Phalcon_Http_Response, setStatusCode) } else { zephir_get_strval(&message, message_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 875, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(¤tHeadersRaw, &_0, "toarray", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_1); @@ -1593,7 +1593,7 @@ PHP_METHOD(Phalcon_Http_Response, setStatusCode) _5$$3 = zephir_is_true(&_7$$3); } if (_5$$3) { - zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 875, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_9$$4, "remove", NULL, 0, &key); zephir_check_call_status(); } @@ -1627,7 +1627,7 @@ PHP_METHOD(Phalcon_Http_Response, setStatusCode) _12$$5 = zephir_is_true(&_14$$5); } if (_12$$5) { - zephir_read_property_cached(&_15$$6, this_ptr, _zephir_prop_0, 875, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$6, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_15$$6, "remove", NULL, 0, &key); zephir_check_call_status(); } @@ -1739,14 +1739,14 @@ PHP_METHOD(Phalcon_Http_Response, setStatusCode) zephir_array_fetch_long(&defaultMessage, &statusCodes, code, PH_NOISY, "phalcon/Http/Response.zep", 840); zephir_get_strval(&message, &defaultMessage); } - zephir_read_property_cached(&_17, this_ptr, _zephir_prop_0, 875, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_18); ZVAL_LONG(&_18, code); ZEPHIR_INIT_VAR(&_19); ZEPHIR_CONCAT_SVSV(&_19, "HTTP/1.1 ", &_18, " ", &message); ZEPHIR_CALL_METHOD(NULL, &_17, "setraw", NULL, 0, &_19); zephir_check_call_status(); - zephir_read_property_cached(&_20, this_ptr, _zephir_prop_0, 875, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_21); ZVAL_LONG(&_21, code); ZEPHIR_INIT_VAR(&_22); @@ -1782,7 +1782,7 @@ PHP_METHOD(Phalcon_Http_Response, phpExtensionLoaded) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 431, &name_zv); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/http/response/cookies.zep.c b/ext/phalcon/http/response/cookies.zep.c index e60d9098b5..7feb416bfa 100644 --- a/ext/phalcon/http/response/cookies.zep.c +++ b/ext/phalcon/http/response/cookies.zep.c @@ -147,9 +147,9 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, __construct) ZVAL_STR_COPY(&signKey_zv, signKey); } if (useEncryption) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 883, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 892, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 883, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 892, &__$false); } ZEPHIR_CALL_METHOD(NULL, this_ptr, "setsignkey", NULL, 0, &signKey_zv); zephir_check_call_status(); @@ -184,7 +184,7 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, delete) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); zephir_memory_observe(&cookie); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 893, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&cookie, &_0, &name_zv, 0))) { RETURN_MM_BOOL(0); } @@ -235,7 +235,7 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, get) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); zephir_memory_observe(&cookie); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 893, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&cookie, &_0, &name_zv, 0)) { RETURN_CCTOR(&cookie); } @@ -252,11 +252,11 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, get) ZEPHIR_CALL_METHOD(NULL, &cookie, "setdi", NULL, 0, &container); zephir_check_call_status(); zephir_memory_observe(&encryption); - zephir_read_property_cached(&encryption, this_ptr, _zephir_prop_1, 883, PH_NOISY_CC); + zephir_read_property_cached(&encryption, this_ptr, _zephir_prop_1, 892, PH_NOISY_CC); if (zephir_is_true(&encryption)) { ZEPHIR_CALL_METHOD(NULL, &cookie, "useencryption", NULL, 0, &encryption); zephir_check_call_status(); - zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_2, 885, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_2, 894, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &cookie, "setsignkey", NULL, 0, &_4$$4); zephir_check_call_status(); } @@ -296,7 +296,7 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, has) ZEND_PARSE_PARAMETERS_END(); zephir_get_global(&_COOKIE, SL("_COOKIE")); ZVAL_STR(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 893, PH_NOISY_CC | PH_READONLY); _1 = zephir_array_isset_value(&_0, &name_zv); if (!(_1)) { _1 = zephir_array_isset_value(&_COOKIE, &name_zv); @@ -332,7 +332,7 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, reset) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 884, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 893, &_0); RETURN_THIS(); } @@ -366,7 +366,7 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, send) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - ZEPHIR_CALL_FUNCTION(&_0, "headers_sent", NULL, 0); + ZEPHIR_CALL_FUNCTION(&_0, "headers_sent", NULL, 215); zephir_check_call_status(); _1 = ZEPHIR_IS_TRUE_IDENTICAL(&_0); if (!(_1)) { @@ -377,7 +377,7 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, send) if (_1) { RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 893, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_3, 0, "phalcon/Http/Response/Cookies.zep", 212); if (Z_TYPE_P(&_3) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_3), _4) @@ -411,9 +411,9 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, send) } ZEPHIR_INIT_NVAR(&cookie); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 886, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 895, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 886, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 895, &__$false); } RETURN_MM_BOOL(1); } @@ -562,11 +562,11 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, set) zephir_get_arrval(&options, options_param); } zephir_memory_observe(&encryption); - zephir_read_property_cached(&encryption, this_ptr, _zephir_prop_0, 883, PH_NOISY_CC); + zephir_read_property_cached(&encryption, this_ptr, _zephir_prop_0, 892, PH_NOISY_CC); zephir_memory_observe(&cookie); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 884, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 893, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&cookie, &_0, &name_zv, 0))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 887, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 896, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_3$$3); zephir_create_array(&_3$$3, 8, 0); zephir_array_fast_append(&_3$$3, &name_zv); @@ -588,13 +588,13 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, set) ZEPHIR_CALL_METHOD(&_2$$3, &_1$$3, "get", NULL, 0, &_4$$3, &_3$$3); zephir_check_call_status(); ZEPHIR_CPY_WRT(&cookie, &_2$$3); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 887, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 896, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &cookie, "setdi", NULL, 0, &_5$$3); zephir_check_call_status(); if (zephir_is_true(&encryption)) { ZEPHIR_CALL_METHOD(NULL, &cookie, "useencryption", NULL, 0, &encryption); zephir_check_call_status(); - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_3, 885, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_3, 894, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &cookie, "setsignkey", NULL, 0, &_6$$4); zephir_check_call_status(); } @@ -625,11 +625,11 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, set) zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &cookie, "setoptions", NULL, 0, &options); zephir_check_call_status(); - zephir_read_property_cached(&_9$$5, this_ptr, _zephir_prop_3, 885, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$5, this_ptr, _zephir_prop_3, 894, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &cookie, "setsignkey", NULL, 0, &_9$$5); zephir_check_call_status(); } - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_4, 888, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_4, 897, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_FALSE_IDENTICAL(&_10)) { ZEPHIR_CALL_METHOD(&container, this_ptr, "checkcontainer", NULL, 0); zephir_check_call_status(); @@ -640,9 +640,9 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, set) ZEPHIR_CALL_METHOD(NULL, &response, "setcookies", NULL, 0, this_ptr); zephir_check_call_status(); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 888, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 897, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 888, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 897, &__$false); } } RETURN_THIS(); @@ -684,7 +684,7 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, setSignKey) zephir_memory_observe(&signKey_zv); ZVAL_STR_COPY(&signKey_zv, signKey); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 885, &signKey_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 894, &signKey_zv); RETURN_THIS(); } @@ -709,9 +709,9 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, useEncryption) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &useEncryption_param); if (useEncryption) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 883, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 892, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 883, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 892, &__$false); } RETURN_THISW(); } @@ -733,7 +733,7 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, checkContainer) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 887, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 896, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (Z_TYPE_P(&container) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); diff --git a/ext/phalcon/http/response/headers.zep.c b/ext/phalcon/http/response/headers.zep.c index a0dcedf943..264820b015 100644 --- a/ext/phalcon/http/response/headers.zep.c +++ b/ext/phalcon/http/response/headers.zep.c @@ -82,7 +82,7 @@ PHP_METHOD(Phalcon_Http_Response_Headers, get) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 889, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 898, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&headers, &_0); zephir_memory_observe(&headerValue); if (!(zephir_array_isset_fetch(&headerValue, &headers, &name_zv, 0))) { @@ -110,7 +110,7 @@ PHP_METHOD(Phalcon_Http_Response_Headers, getIterator) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); object_init_ex(return_value, spl_ce_ArrayIterator); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 889, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 898, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 18, &_0); zephir_check_call_status(); RETURN_MM(); @@ -140,7 +140,7 @@ PHP_METHOD(Phalcon_Http_Response_Headers, has) Z_PARAM_STR(name) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 889, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 898, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_key_exists(&_0, &name_zv)); } @@ -178,10 +178,10 @@ PHP_METHOD(Phalcon_Http_Response_Headers, remove) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&header_zv); ZVAL_STR_COPY(&header_zv, header); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 889, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 898, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&headers, &_0); zephir_array_unset(&headers, &header_zv, PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 889, &headers); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 898, &headers); RETURN_THIS(); } @@ -206,7 +206,7 @@ PHP_METHOD(Phalcon_Http_Response_Headers, reset) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 889, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 898, &_0); ZEPHIR_MM_RESTORE(); } @@ -253,17 +253,17 @@ PHP_METHOD(Phalcon_Http_Response_Headers, send) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - ZEPHIR_CALL_FUNCTION(&_0, "headers_sent", NULL, 0); + ZEPHIR_CALL_FUNCTION(&_0, "headers_sent", NULL, 215); zephir_check_call_status(); _1 = ZEPHIR_IS_TRUE_IDENTICAL(&_0); if (!(_1)) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 890, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); _1 = ZEPHIR_IS_TRUE_IDENTICAL(&_2); } if (_1) { RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 889, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 898, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_3, 0, "phalcon/Http/Response/Headers.zep", 126); if (Z_TYPE_P(&_3) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_3), _5, _6, _4) @@ -279,7 +279,7 @@ PHP_METHOD(Phalcon_Http_Response_Headers, send) if (Z_TYPE_P(&value) != IS_NULL) { ZEPHIR_INIT_NVAR(&_7$$5); ZEPHIR_CONCAT_VSV(&_7$$5, &header, ": ", &value); - ZEPHIR_CALL_FUNCTION(NULL, "header", &_8, 0, &_7$$5, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "header", &_8, 217, &_7$$5, &__$true); zephir_check_call_status(); } else { _9$$6 = zephir_memnstr_str(&header, SL(":"), "phalcon/Http/Response/Headers.zep", 118); @@ -291,12 +291,12 @@ PHP_METHOD(Phalcon_Http_Response_Headers, send) _9$$6 = ZEPHIR_IS_STRING(&_12$$6, "HTTP/"); } if (_9$$6) { - ZEPHIR_CALL_FUNCTION(NULL, "header", &_8, 0, &header, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "header", &_8, 217, &header, &__$true); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(&_13$$8); ZEPHIR_CONCAT_VS(&_13$$8, &header, ": "); - ZEPHIR_CALL_FUNCTION(NULL, "header", &_8, 0, &_13$$8, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "header", &_8, 217, &_13$$8, &__$true); zephir_check_call_status(); } } @@ -324,7 +324,7 @@ PHP_METHOD(Phalcon_Http_Response_Headers, send) if (Z_TYPE_P(&value) != IS_NULL) { ZEPHIR_INIT_NVAR(&_16$$10); ZEPHIR_CONCAT_VSV(&_16$$10, &header, ": ", &value); - ZEPHIR_CALL_FUNCTION(NULL, "header", &_8, 0, &_16$$10, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "header", &_8, 217, &_16$$10, &__$true); zephir_check_call_status(); } else { _17$$11 = zephir_memnstr_str(&header, SL(":"), "phalcon/Http/Response/Headers.zep", 118); @@ -336,12 +336,12 @@ PHP_METHOD(Phalcon_Http_Response_Headers, send) _17$$11 = ZEPHIR_IS_STRING(&_20$$11, "HTTP/"); } if (_17$$11) { - ZEPHIR_CALL_FUNCTION(NULL, "header", &_8, 0, &header, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "header", &_8, 217, &header, &__$true); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(&_21$$13); ZEPHIR_CONCAT_VS(&_21$$13, &header, ": "); - ZEPHIR_CALL_FUNCTION(NULL, "header", &_8, 0, &_21$$13, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "header", &_8, 217, &_21$$13, &__$true); zephir_check_call_status(); } } @@ -350,9 +350,9 @@ PHP_METHOD(Phalcon_Http_Response_Headers, send) ZEPHIR_INIT_NVAR(&value); ZEPHIR_INIT_NVAR(&header); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 890, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 899, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 890, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 899, &__$false); } RETURN_MM_BOOL(1); } diff --git a/ext/phalcon/image/adapter/gd.zep.c b/ext/phalcon/image/adapter/gd.zep.c index d0fde63451..9aeeda3d52 100644 --- a/ext/phalcon/image/adapter/gd.zep.c +++ b/ext/phalcon/image/adapter/gd.zep.c @@ -173,34 +173,34 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __construct) } ZEPHIR_CALL_METHOD(NULL, this_ptr, "check", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 891, &file_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 900, &file_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 892, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 891, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 901, &_0); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 900, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "phpfileexists", NULL, 0, &_0); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_1)) { - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 891, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 900, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_3$$3, "realpath", NULL, 157, &_2$$3); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 893, &_3$$3); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 891, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 902, &_3$$3); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 900, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&imageInfo, "getimagesize", NULL, 0, &_4$$3); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&imageInfo)) { zephir_array_fetch_long(&_5$$4, &imageInfo, 0, PH_NOISY | PH_READONLY, "phalcon/Image/Adapter/Gd.zep", 77); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 894, &_5$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 903, &_5$$4); zephir_array_fetch_long(&_6$$4, &imageInfo, 1, PH_NOISY | PH_READONLY, "phalcon/Image/Adapter/Gd.zep", 78); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 895, &_6$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 904, &_6$$4); zephir_array_fetch_long(&_7$$4, &imageInfo, 2, PH_NOISY | PH_READONLY, "phalcon/Image/Adapter/Gd.zep", 79); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 892, &_7$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 901, &_7$$4); zephir_array_fetch_string(&_8$$4, &imageInfo, SL("mime"), PH_NOISY | PH_READONLY, "phalcon/Image/Adapter/Gd.zep", 80); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 896, &_8$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 905, &_8$$4); } else { ZEPHIR_INIT_VAR(&_9$$5); object_init_ex(&_9$$5, phalcon_image_exceptions_imageloadfailed_ce); - zephir_read_property_cached(&_10$$5, this_ptr, _zephir_prop_0, 891, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$5, this_ptr, _zephir_prop_0, 900, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_9$$5, "__construct", NULL, 0, &_10$$5); zephir_check_call_status(); zephir_throw_exception_debug(&_9$$5, "phalcon/Image/Adapter/Gd.zep", 82); @@ -208,53 +208,53 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __construct) return; } zephir_memory_observe(&_11$$3); - zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_1, 892, PH_NOISY_CC); + zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_1, 901, PH_NOISY_CC); do { if (ZEPHIR_IS_LONG(&_11$$3, 1)) { - zephir_read_property_cached(&_12$$6, this_ptr, _zephir_prop_0, 891, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$6, this_ptr, _zephir_prop_0, 900, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_13$$6, "imagecreatefromgif", NULL, 0, &_12$$6); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 897, &_13$$6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 906, &_13$$6); break; } if (ZEPHIR_IS_LONG(&_11$$3, 2) || ZEPHIR_IS_LONG(&_11$$3, 9)) { - zephir_read_property_cached(&_14$$7, this_ptr, _zephir_prop_0, 891, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$7, this_ptr, _zephir_prop_0, 900, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_15$$7, "imagecreatefromjpeg", NULL, 0, &_14$$7); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 897, &_15$$7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 906, &_15$$7); break; } if (ZEPHIR_IS_LONG(&_11$$3, 3)) { - zephir_read_property_cached(&_16$$8, this_ptr, _zephir_prop_0, 891, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$8, this_ptr, _zephir_prop_0, 900, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_17$$8, "imagecreatefrompng", NULL, 0, &_16$$8); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 897, &_17$$8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 906, &_17$$8); break; } if (ZEPHIR_IS_LONG(&_11$$3, 18)) { - zephir_read_property_cached(&_18$$9, this_ptr, _zephir_prop_0, 891, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$9, this_ptr, _zephir_prop_0, 900, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_19$$9, "imagecreatefromwebp", NULL, 0, &_18$$9); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 897, &_19$$9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 906, &_19$$9); break; } if (ZEPHIR_IS_LONG(&_11$$3, 15)) { - zephir_read_property_cached(&_20$$10, this_ptr, _zephir_prop_0, 891, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$10, this_ptr, _zephir_prop_0, 900, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_21$$10, "imagecreatefromwbmp", NULL, 0, &_20$$10); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 897, &_21$$10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 906, &_21$$10); break; } if (ZEPHIR_IS_LONG(&_11$$3, 16)) { - zephir_read_property_cached(&_22$$11, this_ptr, _zephir_prop_0, 891, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$11, this_ptr, _zephir_prop_0, 900, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_23$$11, "imagecreatefromxbm", NULL, 0, &_22$$11); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 897, &_23$$11); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 906, &_23$$11); break; } ZEPHIR_INIT_VAR(&_24$$12); object_init_ex(&_24$$12, phalcon_image_exceptions_unsupportedimagetype_ce); - zephir_read_property_cached(&_25$$12, this_ptr, _zephir_prop_5, 896, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$12, this_ptr, _zephir_prop_5, 905, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_24$$12, "__construct", NULL, 0, &_25$$12); zephir_check_call_status(); zephir_throw_exception_debug(&_24$$12, "phalcon/Image/Adapter/Gd.zep", 112); @@ -262,7 +262,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __construct) return; } while(0); - zephir_read_property_cached(&_26$$3, this_ptr, _zephir_prop_6, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_26$$3, this_ptr, _zephir_prop_6, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 0, &_26$$3, &__$true); zephir_check_call_status(); } else { @@ -273,7 +273,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __construct) if (_27$$13) { ZEPHIR_INIT_VAR(&_28$$14); object_init_ex(&_28$$14, phalcon_image_exceptions_imageloadfailed_ce); - zephir_read_property_cached(&_29$$14, this_ptr, _zephir_prop_0, 891, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$14, this_ptr, _zephir_prop_0, 900, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_28$$14, "__construct", NULL, 0, &_29$$14); zephir_check_call_status(); zephir_throw_exception_debug(&_28$$14, "phalcon/Image/Adapter/Gd.zep", 118); @@ -284,28 +284,28 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __construct) ZVAL_LONG(&_31$$13, height); ZEPHIR_CALL_FUNCTION(&_32$$13, "imagecreatetruecolor", NULL, 0, &_30$$13, &_31$$13); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 897, &_32$$13); - zephir_read_property_cached(&_30$$13, this_ptr, _zephir_prop_6, 897, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 906, &_32$$13); + zephir_read_property_cached(&_30$$13, this_ptr, _zephir_prop_6, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "imagealphablending", NULL, 0, &_30$$13, &__$true); zephir_check_call_status(); - zephir_read_property_cached(&_31$$13, this_ptr, _zephir_prop_6, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_31$$13, this_ptr, _zephir_prop_6, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 0, &_31$$13, &__$true); zephir_check_call_status(); - zephir_read_property_cached(&_33$$13, this_ptr, _zephir_prop_0, 891, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 893, &_33$$13); + zephir_read_property_cached(&_33$$13, this_ptr, _zephir_prop_0, 900, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 902, &_33$$13); ZVAL_UNDEF(&_34$$13); ZVAL_LONG(&_34$$13, width); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 894, &_34$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 903, &_34$$13); ZVAL_UNDEF(&_34$$13); ZVAL_LONG(&_34$$13, height); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 895, &_34$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 904, &_34$$13); ZVAL_UNDEF(&_34$$13); ZVAL_LONG(&_34$$13, 3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 892, &_34$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 901, &_34$$13); ZEPHIR_INIT_VAR(&_35$$13); ZEPHIR_INIT_NVAR(&_35$$13); ZVAL_STRING(&_35$$13, "image/png"); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 896, &_35$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 905, &_35$$13); } ZEPHIR_MM_RESTORE(); } @@ -323,7 +323,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __destruct) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("image", 5, 1); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 897, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 906, &__$null); } /** @@ -481,10 +481,10 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processBackground) zephir_check_call_status(); zephir_round(&_0, &_2, NULL, NULL); opacity = zephir_get_intval(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 894, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 903, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 904, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&background, this_ptr, "processcreate", NULL, 0, &_1, &_3); zephir_check_call_status(); ZVAL_LONG(&_4, red); @@ -495,8 +495,8 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processBackground) zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(NULL, "imagealphablending", NULL, 0, &background, &__$true); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 894, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 903, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 904, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_6, 0); ZVAL_LONG(&_7, 0); ZVAL_LONG(&_8, 0); @@ -504,7 +504,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processBackground) ZEPHIR_CALL_FUNCTION(©, "imagecopy", NULL, 0, &background, &image, &_6, &_7, &_8, &_9, &_4, &_5); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(©)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 897, &background); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 906, &background); } ZEPHIR_MM_RESTORE(); } @@ -540,7 +540,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processBlur) if (!(counter < radius)) { break; } - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1$$3, 7); ZEPHIR_CALL_FUNCTION(NULL, "imagefilter", &_2, 0, &_0$$3, &_1$$3); zephir_check_call_status(); @@ -642,16 +642,16 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processCrop) ZEPHIR_INIT_NVAR(&_0); ZVAL_LONG(&_0, height); zephir_array_update_string(&rect, SL("height"), &_0, PH_COPY | PH_SEPARATE); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&image, "imagecrop", NULL, 0, &_1, &rect); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 897, &image); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 906, &image); ZEPHIR_CALL_FUNCTION(&_2, "imagesx", NULL, 0, &image); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 894, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 903, &_2); ZEPHIR_CALL_FUNCTION(&_3, "imagesy", NULL, 0, &image); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 895, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 904, &_3); ZEPHIR_MM_RESTORE(); } @@ -683,12 +683,12 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processFlip) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &direction_param); if (direction == 11) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1$$3, 1); ZEPHIR_CALL_FUNCTION(NULL, "imageflip", NULL, 0, &_0$$3, &_1$$3); zephir_check_call_status(); } else { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_3$$4, 2); ZEPHIR_CALL_FUNCTION(NULL, "imageflip", NULL, 0, &_2$$4, &_3$$4); zephir_check_call_status(); @@ -778,8 +778,8 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processMask) alpha = 127; ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 0, &maskImage, &__$true); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 894, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 903, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 904, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&newImage, this_ptr, "processcreate", NULL, 0, &_3, &_4); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 0, &newImage, &__$true); @@ -794,19 +794,19 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processMask) ZVAL_LONG(&_6, 0); ZEPHIR_CALL_FUNCTION(NULL, "imagefill", NULL, 0, &newImage, &_5, &_6, &color); zephir_check_call_status(); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 894, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 903, PH_NOISY_CC | PH_READONLY); _9 = !ZEPHIR_IS_LONG_IDENTICAL(&_5, maskWidth); if (!(_9)) { - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 904, PH_NOISY_CC | PH_READONLY); _9 = !ZEPHIR_IS_LONG_IDENTICAL(&_6, maskHeight); } if (_9) { - zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 894, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_1, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 903, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_1, 904, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&tempImage, "imagecreatetruecolor", NULL, 0, &_10$$3, &_11$$3); zephir_check_call_status(); - zephir_read_property_cached(&_12$$3, this_ptr, _zephir_prop_0, 894, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_13$$3, this_ptr, _zephir_prop_1, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$3, this_ptr, _zephir_prop_0, 903, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$3, this_ptr, _zephir_prop_1, 904, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_14$$3, 0); ZVAL_LONG(&_15$$3, 0); ZVAL_LONG(&_16$$3, 0); @@ -819,13 +819,13 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processMask) } x = 0; while (1) { - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 894, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 903, PH_NOISY_CC | PH_READONLY); if (!(ZEPHIR_GT_LONG(&_7, x))) { break; } y = 0; while (1) { - zephir_read_property_cached(&_20$$4, this_ptr, _zephir_prop_1, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$4, this_ptr, _zephir_prop_1, 904, PH_NOISY_CC | PH_READONLY); if (!(ZEPHIR_GT_LONG(&_20$$4, y))) { break; } @@ -840,12 +840,12 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processMask) ZVAL_DOUBLE(&_26$$6, zephir_safe_div_zval_long(&_25$$6, 2)); alpha = (127 - zephir_get_intval(&_26$$6)); } - zephir_read_property_cached(&_21$$5, this_ptr, _zephir_prop_2, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$5, this_ptr, _zephir_prop_2, 906, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_22$$5, x); ZVAL_LONG(&_27$$5, y); ZEPHIR_CALL_FUNCTION(&index, "imagecolorat", &_23, 0, &_21$$5, &_22$$5, &_27$$5); zephir_check_call_status(); - zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_2, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_2, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&color, "imagecolorsforindex", &_24, 0, &_22$$5, &index); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&red); @@ -865,7 +865,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processMask) } x++; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 897, &newImage); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 906, &newImage); ZEPHIR_MM_RESTORE(); } @@ -915,28 +915,28 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processPixelate) zephir_fetch_params(1, 1, 0, &amount_param); x = 0; while (1) { - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 894, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 903, PH_NOISY_CC | PH_READONLY); if (!(ZEPHIR_GT_LONG(&_0, x))) { break; } y = 0; while (1) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 904, PH_NOISY_CC | PH_READONLY); if (!(ZEPHIR_GT_LONG(&_1$$3, y))) { break; } x1 = ((x + (zephir_safe_div_long_long(amount, 2)))); y1 = ((y + (zephir_safe_div_long_long(amount, 2)))); - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 894, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 903, PH_NOISY_CC | PH_READONLY); _3$$4 = ZEPHIR_LE_LONG(&_2$$4, x1); if (!(_3$$4)) { - zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_1, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_1, 904, PH_NOISY_CC | PH_READONLY); _3$$4 = ZEPHIR_LE_LONG(&_4$$4, y1); } if (_3$$4) { break; } - zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_2, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_2, 906, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_6$$4, x1); ZVAL_LONG(&_7$$4, y1); ZEPHIR_CALL_FUNCTION(&color, "imagecolorat", &_8, 0, &_5$$4, &_6$$4, &_7$$4); @@ -945,7 +945,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processPixelate) ZVAL_LONG(&x2, (x + amount)); ZEPHIR_INIT_NVAR(&y2); ZVAL_LONG(&y2, (y + amount)); - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_2, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_2, 906, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_7$$4, x); ZVAL_LONG(&_9$$4, y); ZEPHIR_CALL_FUNCTION(NULL, "imagefilledrectangle", &_10, 0, &_6$$4, &_7$$4, &_9$$4, &x2, &y2, &color); @@ -1035,14 +1035,14 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processReflection) } else { stepping = (long) (zephir_safe_div_long_long(127, height)); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 894, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 903, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 904, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_4, (zephir_get_numberval(&_3) + height)); ZEPHIR_CALL_METHOD(&reflection, this_ptr, "processcreate", NULL, 0, &_1, &_4); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 897, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 894, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 906, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 903, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 904, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_7, 0); ZVAL_LONG(&_8, 0); ZVAL_LONG(&_9, 0); @@ -1054,9 +1054,9 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processReflection) if (!(height >= offset)) { break; } - zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_1, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_1, 904, PH_NOISY_CC | PH_READONLY); sourceY = ((zephir_get_numberval(&_11$$5) - offset) - 1); - zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_1, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_1, 904, PH_NOISY_CC | PH_READONLY); destinationY = (zephir_get_numberval(&_12$$5) + offset); if (fadeIn) { ZEPHIR_INIT_NVAR(&_13$$6); @@ -1069,12 +1069,12 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processReflection) zephir_round(&_15$$7, &_16$$7, NULL, NULL); destinationOpacity = zephir_get_intval(&_15$$7); } - zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_0, 894, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_0, 903, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_18$$5, 1); ZEPHIR_CALL_METHOD(&line, this_ptr, "processcreate", NULL, 0, &_17$$5, &_18$$5); zephir_check_call_status(); - zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_2, 897, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_19$$5, this_ptr, _zephir_prop_0, 894, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_2, 906, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19$$5, this_ptr, _zephir_prop_0, 903, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_20$$5, 0); ZVAL_LONG(&_21$$5, 0); ZVAL_LONG(&_22$$5, 0); @@ -1089,7 +1089,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processReflection) ZVAL_LONG(&_24$$5, destinationOpacity); ZEPHIR_CALL_FUNCTION(NULL, "imagefilter", &_25, 0, &line, &_20$$5, &_21$$5, &_22$$5, &_23$$5, &_24$$5); zephir_check_call_status(); - zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_0, 894, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_0, 903, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_21$$5, 0); ZVAL_LONG(&_22$$5, destinationY); ZVAL_LONG(&_23$$5, 0); @@ -1099,13 +1099,13 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processReflection) zephir_check_call_status(); offset++; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 897, &reflection); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 906, &reflection); ZEPHIR_CALL_FUNCTION(&_27, "imagesx", NULL, 0, &reflection); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 894, &_27); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 903, &_27); ZEPHIR_CALL_FUNCTION(&_28, "imagesy", NULL, 0, &reflection); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 895, &_28); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 904, &_28); ZEPHIR_MM_RESTORE(); } @@ -1155,38 +1155,38 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processRender) zephir_check_call_status(); do { if (ZEPHIR_IS_STRING(&extension, "gif")) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "imagegif", NULL, 0, &_1$$3); zephir_check_call_status(); break; } if (ZEPHIR_IS_STRING(&extension, "jpg") || ZEPHIR_IS_STRING(&extension, "jpeg")) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_3$$4, quality); ZEPHIR_CALL_FUNCTION(NULL, "imagejpeg", NULL, 0, &_2$$4, &__$null, &_3$$4); zephir_check_call_status(); break; } if (ZEPHIR_IS_STRING(&extension, "png")) { - zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "imagepng", NULL, 0, &_4$$5); zephir_check_call_status(); break; } if (ZEPHIR_IS_STRING(&extension, "wbmp")) { - zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "imagewbmp", NULL, 0, &_5$$6); zephir_check_call_status(); break; } if (ZEPHIR_IS_STRING(&extension, "webp")) { - zephir_read_property_cached(&_6$$7, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$7, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "imagewebp", NULL, 0, &_6$$7); zephir_check_call_status(); break; } if (ZEPHIR_IS_STRING(&extension, "xbm")) { - zephir_read_property_cached(&_7$$8, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$8, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "imagexbm", NULL, 0, &_7$$8, &__$null); zephir_check_call_status(); break; @@ -1260,9 +1260,9 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processResize) zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 0, &image, &__$true); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 894, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 903, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 904, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_3, 0); ZVAL_LONG(&_4, 0); ZVAL_LONG(&_5, 0); @@ -1271,13 +1271,13 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processResize) ZVAL_LONG(&_8, height); ZEPHIR_CALL_FUNCTION(NULL, "imagecopyresampled", NULL, 0, &image, &_0, &_3, &_4, &_5, &_6, &_7, &_8, &_1, &_2); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 897, &image); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 906, &image); ZEPHIR_CALL_FUNCTION(&_9, "imagesx", NULL, 0, &image); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 894, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 903, &_9); ZEPHIR_CALL_FUNCTION(&_10, "imagesy", NULL, 0, &image); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 895, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 904, &_10); ZEPHIR_MM_RESTORE(); } @@ -1326,14 +1326,14 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processRotate) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, °rees_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1, 0); ZVAL_LONG(&_2, 0); ZVAL_LONG(&_3, 0); ZVAL_LONG(&_4, 127); ZEPHIR_CALL_FUNCTION(&transparent, "imagecolorallocatealpha", NULL, 0, &_0, &_1, &_2, &_3, &_4); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2, (360 - degrees)); ZEPHIR_CALL_FUNCTION(&image, "imagerotate", NULL, 0, &_1, &_2, &transparent); zephir_check_call_status(); @@ -1343,7 +1343,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processRotate) zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&height, "imagesy", NULL, 0, &image); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_3, 0); ZVAL_LONG(&_4, 0); ZVAL_LONG(&_5, 0); @@ -1352,9 +1352,9 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processRotate) ZEPHIR_CALL_FUNCTION(©, "imagecopymerge", NULL, 0, &_2, &image, &_3, &_4, &_5, &_6, &width, &height, &_7); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(©)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 897, &image); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 894, &width); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 895, &height); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 906, &image); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 903, &width); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 904, &height); } ZEPHIR_MM_RESTORE(); } @@ -1418,7 +1418,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSave) ZEPHIR_CALL_FUNCTION(&extension, "pathinfo", NULL, 199, &file_zv, &_0); zephir_check_call_status(); if (1 == ZEPHIR_IS_EMPTY(&extension)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 892, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 901, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&extension, "image_type_to_extension", NULL, 0, &_1$$3, &__$false); zephir_check_call_status(); } @@ -1429,8 +1429,8 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSave) if (ZEPHIR_IS_STRING(&extension, "gif")) { ZVAL_UNDEF(&_3$$4); ZVAL_LONG(&_3$$4, 1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 892, &_3$$4); - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 897, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 901, &_3$$4); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "imagegif", NULL, 0, &_3$$4, &file_zv); zephir_check_call_status(); break; @@ -1438,19 +1438,19 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSave) if (ZEPHIR_IS_STRING(&extension, "jpg") || ZEPHIR_IS_STRING(&extension, "jpeg")) { ZVAL_UNDEF(&_4$$5); ZVAL_LONG(&_4$$5, 2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 892, &_4$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 901, &_4$$5); if (quality >= 0) { ZVAL_LONG(&_6$$6, quality); ZVAL_LONG(&_7$$6, 1); ZEPHIR_CALL_METHOD(&_5$$6, this_ptr, "checkhighlow", NULL, 0, &_6$$6, &_7$$6); zephir_check_call_status(); quality = zephir_get_numberval(&_5$$6); - zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_1, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_1, 906, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_7$$6, quality); ZEPHIR_CALL_FUNCTION(NULL, "imagejpeg", NULL, 0, &_6$$6, &file_zv, &_7$$6); zephir_check_call_status(); } else { - zephir_read_property_cached(&_8$$7, this_ptr, _zephir_prop_1, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$7, this_ptr, _zephir_prop_1, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "imagejpeg", NULL, 0, &_8$$7, &file_zv); zephir_check_call_status(); } @@ -1459,8 +1459,8 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSave) if (ZEPHIR_IS_STRING(&extension, "png")) { ZVAL_UNDEF(&_9$$8); ZVAL_LONG(&_9$$8, 3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 892, &_9$$8); - zephir_read_property_cached(&_9$$8, this_ptr, _zephir_prop_1, 897, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 901, &_9$$8); + zephir_read_property_cached(&_9$$8, this_ptr, _zephir_prop_1, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "imagepng", NULL, 0, &_9$$8, &file_zv); zephir_check_call_status(); break; @@ -1468,8 +1468,8 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSave) if (ZEPHIR_IS_STRING(&extension, "wbmp")) { ZVAL_UNDEF(&_10$$9); ZVAL_LONG(&_10$$9, 15); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 892, &_10$$9); - zephir_read_property_cached(&_10$$9, this_ptr, _zephir_prop_1, 897, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 901, &_10$$9); + zephir_read_property_cached(&_10$$9, this_ptr, _zephir_prop_1, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "imagewbmp", NULL, 0, &_10$$9, &file_zv); zephir_check_call_status(); break; @@ -1477,8 +1477,8 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSave) if (ZEPHIR_IS_STRING(&extension, "webp")) { ZVAL_UNDEF(&_11$$10); ZVAL_LONG(&_11$$10, 18); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 892, &_11$$10); - zephir_read_property_cached(&_11$$10, this_ptr, _zephir_prop_1, 897, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 901, &_11$$10); + zephir_read_property_cached(&_11$$10, this_ptr, _zephir_prop_1, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "imagewebp", NULL, 0, &_11$$10, &file_zv); zephir_check_call_status(); break; @@ -1486,8 +1486,8 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSave) if (ZEPHIR_IS_STRING(&extension, "xbm")) { ZVAL_UNDEF(&_12$$11); ZVAL_LONG(&_12$$11, 16); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 892, &_12$$11); - zephir_read_property_cached(&_12$$11, this_ptr, _zephir_prop_1, 897, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 901, &_12$$11); + zephir_read_property_cached(&_12$$11, this_ptr, _zephir_prop_1, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "imagexbm", NULL, 0, &_12$$11, &file_zv); zephir_check_call_status(); break; @@ -1501,10 +1501,10 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSave) return; } while(0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 892, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 901, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_14, "image_type_to_mime_type", NULL, 0, &_0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 896, &_14); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 905, &_14); RETURN_MM_BOOL(1); } @@ -1599,20 +1599,20 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSharpen) ZVAL_LONG(&_4, -1); zephir_array_fast_append(&_3, &_4); zephir_array_fast_append(&matrix, &_3); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_6, (amount - 8)); ZVAL_LONG(&_7, 0); ZEPHIR_CALL_FUNCTION(&result, "imageconvolution", NULL, 0, &_5, &matrix, &_6, &_7); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&result)) { - zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_9$$3, "imagesx", NULL, 0, &_8$$3); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 894, &_9$$3); - zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 903, &_9$$3); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_11$$3, "imagesy", NULL, 0, &_10$$3); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 895, &_11$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 904, &_11$$3); } ZEPHIR_MM_RESTORE(); } @@ -1780,7 +1780,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processText) ZEPHIR_INIT_VAR(&height); ZVAL_LONG(&height, (zephir_get_numberval(&_13$$3) + 10)); if (ZEPHIR_LT_LONG(offsetX, 0)) { - zephir_read_property_cached(&_14$$6, this_ptr, _zephir_prop_0, 894, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$6, this_ptr, _zephir_prop_0, 903, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_15$$6); zephir_sub_function(&_15$$6, &_14$$6, &width); ZEPHIR_INIT_VAR(&_16$$6); @@ -1788,14 +1788,14 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processText) ZEPHIR_CPY_WRT(offsetX, &_16$$6); } if (ZEPHIR_LT_LONG(offsetY, 0)) { - zephir_read_property_cached(&_17$$7, this_ptr, _zephir_prop_1, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$7, this_ptr, _zephir_prop_1, 904, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_18$$7); zephir_sub_function(&_18$$7, &_17$$7, &height); ZEPHIR_INIT_VAR(&_19$$7); zephir_add_function(&_19$$7, &_18$$7, offsetY); ZEPHIR_CPY_WRT(offsetY, &_19$$7); } - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 906, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_6$$3, red); ZVAL_LONG(&_20$$3, green); ZVAL_LONG(&_21$$3, blue); @@ -1803,7 +1803,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processText) ZEPHIR_CALL_FUNCTION(&color, "imagecolorallocatealpha", NULL, 0, &_5$$3, &_6$$3, &_20$$3, &_21$$3, &_22$$3); zephir_check_call_status(); angle = 0; - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_2, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_2, 906, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_20$$3, size); ZVAL_LONG(&_21$$3, angle); ZEPHIR_CALL_FUNCTION(NULL, "imagettftext", NULL, 0, &_6$$3, &_20$$3, &_21$$3, offsetX, offsetY, &color, &fontFile_zv, &text_zv); @@ -1817,7 +1817,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processText) ZEPHIR_CALL_FUNCTION(&height, "imagefontheight", NULL, 0, &_23$$8); zephir_check_call_status(); if (ZEPHIR_LT_LONG(offsetX, 0)) { - zephir_read_property_cached(&_25$$9, this_ptr, _zephir_prop_0, 894, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$9, this_ptr, _zephir_prop_0, 903, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_26$$9); zephir_sub_function(&_26$$9, &_25$$9, &width); ZEPHIR_INIT_VAR(&_27$$9); @@ -1825,21 +1825,21 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processText) ZEPHIR_CPY_WRT(offsetX, &_27$$9); } if (ZEPHIR_LT_LONG(offsetY, 0)) { - zephir_read_property_cached(&_28$$10, this_ptr, _zephir_prop_1, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$10, this_ptr, _zephir_prop_1, 904, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_29$$10); zephir_sub_function(&_29$$10, &_28$$10, &height); ZEPHIR_INIT_VAR(&_30$$10); zephir_add_function(&_30$$10, &_29$$10, offsetY); ZEPHIR_CPY_WRT(offsetY, &_30$$10); } - zephir_read_property_cached(&_23$$8, this_ptr, _zephir_prop_2, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$8, this_ptr, _zephir_prop_2, 906, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_31$$8, red); ZVAL_LONG(&_32$$8, green); ZVAL_LONG(&_33$$8, blue); ZVAL_LONG(&_34$$8, opacity); ZEPHIR_CALL_FUNCTION(&color, "imagecolorallocatealpha", NULL, 0, &_23$$8, &_31$$8, &_32$$8, &_33$$8, &_34$$8); zephir_check_call_status(); - zephir_read_property_cached(&_31$$8, this_ptr, _zephir_prop_2, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_31$$8, this_ptr, _zephir_prop_2, 906, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_32$$8, size); ZEPHIR_CALL_FUNCTION(NULL, "imagestring", NULL, 0, &_31$$8, &_32$$8, offsetX, offsetY, &text_zv, &color); zephir_check_call_status(); @@ -1924,10 +1924,10 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processWatermark) ZEPHIR_CALL_FUNCTION(NULL, "imagefilledrectangle", NULL, 0, &overlay, &_4$$3, &_6$$3, &_7$$3, &_8$$3, &color); zephir_check_call_status(); } - zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "imagealphablending", NULL, 0, &_9, &__$true); zephir_check_call_status(); - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_11, offsetX); ZVAL_LONG(&_12, offsetY); ZVAL_LONG(&_13, 0); @@ -2444,7 +2444,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, phpExtensionLoaded) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 431, &name_zv); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/image/adapter/imagick.zep.c b/ext/phalcon/image/adapter/imagick.zep.c index e6f40d8a9b..9e4b3830e4 100644 --- a/ext/phalcon/image/adapter/imagick.zep.c +++ b/ext/phalcon/image/adapter/imagick.zep.c @@ -190,39 +190,39 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, __construct) } ZEPHIR_CALL_METHOD(NULL, this_ptr, "check", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 898, &file_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 907, &file_zv); ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, zephir_get_internal_ce(SL("imagick"))); ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 899, &_0); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 898, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 908, &_0); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 907, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "phpfileexists", NULL, 0, &_2); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_1)) { - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 898, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 907, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_4$$3, "realpath", NULL, 157, &_3$$3); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 900, &_4$$3); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_2, 900, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 909, &_4$$3); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_2, 909, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_6$$3, &_5$$3, "readimage", NULL, 0, &_7$$3); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_6$$3)) { ZEPHIR_INIT_VAR(&_8$$4); object_init_ex(&_8$$4, phalcon_image_exceptions_imageloadfailed_ce); - zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 898, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 907, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_8$$4, "__construct", NULL, 0, &_9$$4); zephir_check_call_status(); zephir_throw_exception_debug(&_8$$4, "phalcon/Image/Adapter/Imagick.zep", 96); ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_11$$3, &_10$$3, "getimagealphachannel", NULL, 0); zephir_check_call_status(); if (!zephir_is_true(&_11$$3)) { - zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_13$$5); ZVAL_STRING(&_13$$5, "Imagick::ALPHACHANNEL_SET"); ZEPHIR_CALL_FUNCTION(&_14$$5, "constant", NULL, 148, &_13$$5); @@ -230,24 +230,24 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, __construct) ZEPHIR_CALL_METHOD(NULL, &_12$$5, "setimagealphachannel", NULL, 0, &_14$$5); zephir_check_call_status(); } - zephir_read_property_cached(&_15$$3, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$3, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_16$$3, &_15$$3, "getimagetype", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 901, &_16$$3); - zephir_read_property_cached(&_17$$3, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 910, &_16$$3); + zephir_read_property_cached(&_17$$3, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_18$$3, &_17$$3, "getimagetype", NULL, 0); zephir_check_call_status(); if (ZEPHIR_IS_LONG(&_18$$3, 1)) { - zephir_read_property_cached(&_19$$6, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19$$6, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&image, &_19$$6, "coalesceimages", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_20$$6, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$6, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_20$$6, "clear", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_21$$6, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$6, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_21$$6, "destroy", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 899, &image); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 908, &image); } } else { _22$$7 = 0 == width; @@ -257,14 +257,14 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, __construct) if (_22$$7) { ZEPHIR_INIT_VAR(&_23$$8); object_init_ex(&_23$$8, phalcon_image_exceptions_imageloadfailed_ce); - zephir_read_property_cached(&_24$$8, this_ptr, _zephir_prop_0, 898, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24$$8, this_ptr, _zephir_prop_0, 907, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_23$$8, "__construct", NULL, 0, &_24$$8); zephir_check_call_status(); zephir_throw_exception_debug(&_23$$8, "phalcon/Image/Adapter/Imagick.zep", 119); ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_25$$7, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$7, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_26$$7); object_init_ex(&_26$$7, zephir_get_internal_ce(SL("imagickpixel"))); ZEPHIR_INIT_VAR(&_27$$7); @@ -275,37 +275,37 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, __construct) ZVAL_LONG(&_29$$7, height); ZEPHIR_CALL_METHOD(NULL, &_25$$7, "newimage", NULL, 0, &_28$$7, &_29$$7, &_26$$7); zephir_check_call_status(); - zephir_read_property_cached(&_28$$7, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$7, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_27$$7); ZVAL_STRING(&_27$$7, "png"); ZEPHIR_CALL_METHOD(NULL, &_28$$7, "setformat", NULL, 0, &_27$$7); zephir_check_call_status(); - zephir_read_property_cached(&_29$$7, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$7, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_27$$7); ZVAL_STRING(&_27$$7, "png"); ZEPHIR_CALL_METHOD(NULL, &_29$$7, "setimageformat", NULL, 0, &_27$$7); zephir_check_call_status(); - zephir_read_property_cached(&_30$$7, this_ptr, _zephir_prop_0, 898, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 900, &_30$$7); + zephir_read_property_cached(&_30$$7, this_ptr, _zephir_prop_0, 907, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 909, &_30$$7); } - zephir_read_property_cached(&_31, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_31, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_32, &_31, "getimagewidth", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 902, &_32); - zephir_read_property_cached(&_33, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 911, &_32); + zephir_read_property_cached(&_33, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_34, &_33, "getimageheight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 903, &_34); - zephir_read_property_cached(&_35, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 912, &_34); + zephir_read_property_cached(&_35, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_36, &_35, "getimagetype", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 901, &_36); - zephir_read_property_cached(&_37, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 910, &_36); + zephir_read_property_cached(&_37, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_38, &_37, "getimageformat", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_39); ZEPHIR_CONCAT_SV(&_39, "image/", &_38); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 904, &_39); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 913, &_39); ZEPHIR_MM_RESTORE(); } @@ -330,12 +330,12 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, __destruct) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC); if (zephir_is_instance_of(&_0, SL("Imagick"))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_1$$3, "clear", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "destroy", NULL, 0); zephir_check_call_status(); } @@ -444,7 +444,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, liquidRescale) rigidity = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); ZVAL_LONG(&_0, 0); ZEPHIR_CALL_METHOD(NULL, &image, "setiteratorindex", NULL, 0, &_0); @@ -476,10 +476,10 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, liquidRescale) } ZEPHIR_CALL_METHOD(&_10, &image, "getimagewidth", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 902, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 911, &_10); ZEPHIR_CALL_METHOD(&_11, &image, "getimageheight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 903, &_11); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 912, &_11); RETURN_THIS(); } @@ -524,7 +524,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, setResourceLimit) _0 = type <= 6; } if (_0) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2$$3, type); ZVAL_LONG(&_3$$3, limit); ZEPHIR_CALL_METHOD(NULL, &_1$$3, "setresourcelimit", NULL, 0, &_2$$3, &_3$$3); @@ -634,7 +634,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processBackground) object_init_ex(&background, zephir_get_internal_ce(SL("imagick"))); ZEPHIR_CALL_METHOD(NULL, &background, "__construct", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2, 0); ZEPHIR_CALL_METHOD(NULL, &_1, "setiteratorindex", NULL, 0, &_2); zephir_check_call_status(); @@ -642,8 +642,8 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processBackground) if (!(1)) { break; } - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 902, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 903, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 911, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 912, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &background, "newimage", &_6, 0, &_4$$3, &_5$$3, &pixel1); zephir_check_call_status(); @@ -687,12 +687,12 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processBackground) ZVAL_LONG(&_19$$3, localOpacity); ZEPHIR_CALL_METHOD(NULL, &background, "evaluateimage", &_20, 0, &_17$$3, &_19$$3, &_18$$3); zephir_check_call_status(); - zephir_read_property_cached(&_19$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_21$$3, &_19$$3, "getcolorspace", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &background, "setcolorspace", &_22, 0, &_21$$3); zephir_check_call_status(); - zephir_read_property_cached(&_23$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_16$$3); ZVAL_STRING(&_16$$3, "Imagick::COMPOSITE_DISSOLVE"); ZEPHIR_CALL_FUNCTION(&_24$$3, "constant", &_11, 148, &_16$$3); @@ -710,20 +710,20 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processBackground) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_25$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_30$$3, &_25$$3, "nextimage", NULL, 0); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_30$$3)) { break; } } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_2, "clear", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_3, "destroy", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 899, &background); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 908, &background); ZEPHIR_MM_RESTORE(); } @@ -759,7 +759,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processBlur) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &radius_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1, 0); ZEPHIR_CALL_METHOD(NULL, &_0, "setiteratorindex", NULL, 0, &_1); zephir_check_call_status(); @@ -767,12 +767,12 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processBlur) if (!(1)) { break; } - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_3$$3, radius); ZVAL_LONG(&_4$$3, 100); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "blurimage", NULL, 0, &_3$$3, &_4$$3); zephir_check_call_status(); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5$$3, &_3$$3, "nextimage", NULL, 0); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_5$$3)) { @@ -832,7 +832,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processCrop) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 4, 0, &width_param, &height_param, &offsetX_param, &offsetY_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); ZVAL_LONG(&_0, 0); ZEPHIR_CALL_METHOD(NULL, &image, "setiteratorindex", NULL, 0, &_0); @@ -861,10 +861,10 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processCrop) } ZEPHIR_CALL_METHOD(&_9, &image, "getimagewidth", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 902, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 911, &_9); ZEPHIR_CALL_METHOD(&_10, &image, "getimageheight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 903, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 912, &_10); ZEPHIR_MM_RESTORE(); } @@ -907,7 +907,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processFlip) ZEPHIR_INIT_NVAR(&method); ZVAL_STRING(&method, "flopImage"); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1, 0); ZEPHIR_CALL_METHOD(NULL, &_0, "setiteratorindex", NULL, 0, &_1); zephir_check_call_status(); @@ -915,10 +915,10 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processFlip) if (!(1)) { break; } - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD_ZVAL(NULL, &_2$$3, &method, NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_4$$3, &_3$$3, "nextimage", NULL, 0); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_4$$3)) { @@ -978,7 +978,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processMask) zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &image, "readimageblob", NULL, 0, &_0); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2, 0); ZEPHIR_CALL_METHOD(NULL, &_1, "setiteratorindex", NULL, 0, &_2); zephir_check_call_status(); @@ -986,11 +986,11 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processMask) if (!(1)) { break; } - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZVAL_BOOL(&_4$$3, 1); ZEPHIR_CALL_METHOD(NULL, &_3$$3, "setimagematte", NULL, 0, &_4$$3); zephir_check_call_status(); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_5$$3); ZVAL_STRING(&_5$$3, "Imagick::COMPOSITE_DSTIN"); ZEPHIR_CALL_FUNCTION(&_6$$3, "constant", &_7, 148, &_5$$3); @@ -1008,7 +1008,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processMask) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_12$$3, &_8$$3, "nextimage", NULL, 0); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_12$$3)) { @@ -1066,11 +1066,11 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processPixelate) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &amount_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 902, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 911, PH_NOISY_CC | PH_READONLY); width = (int) (zephir_safe_div_zval_long(&_0, amount)); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 903, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 912, PH_NOISY_CC | PH_READONLY); height = (int) (zephir_safe_div_zval_long(&_1, amount)); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 908, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_3, 0); ZEPHIR_CALL_METHOD(NULL, &_2, "setiteratorindex", NULL, 0, &_3); zephir_check_call_status(); @@ -1078,17 +1078,17 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processPixelate) if (!(1)) { break; } - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 908, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_5$$3, width); ZVAL_LONG(&_6$$3, height); ZEPHIR_CALL_METHOD(NULL, &_4$$3, "scaleimage", NULL, 0, &_5$$3, &_6$$3); zephir_check_call_status(); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 899, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 902, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_1, 903, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 908, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 911, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_1, 912, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_5$$3, "scaleimage", NULL, 0, &_6$$3, &_7$$3); zephir_check_call_status(); - zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_2, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_2, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_9$$3, &_8$$3, "nextimage", NULL, 0); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_9$$3)) { @@ -1198,15 +1198,15 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processReflection) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 3, 0, &height_param, &opacity_param, &fadeIn_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 905, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 914, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&reflection); if (ZEPHIR_GE_LONG(&_0, 30100)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); if (zephir_clone(&reflection, &_1$$3) == FAILURE) { RETURN_MM(); } } else { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_3$$4, &_2$$4, "clone", NULL, 0); zephir_check_call_status(); if (zephir_clone(&reflection, &_3$$4) == FAILURE) { @@ -1236,7 +1236,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processReflection) ZVAL_LONG(&_10$$5, 0); ZEPHIR_CALL_METHOD(NULL, &reflection, "setimagepage", &_14, 0, &_12$$5, &_8$$5, &_9$$5, &_10$$5); zephir_check_call_status(); - zephir_read_property_cached(&_8$$5, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$5, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_15$$5, &_8$$5, "nextimage", NULL, 0); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_15$$5)) { @@ -1296,7 +1296,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processReflection) ZVAL_LONG(&_21$$7, opacity); ZEPHIR_CALL_METHOD(NULL, &reflection, "evaluateimage", &_28, 0, &_26$$7, &_21$$7, &_27$$7); zephir_check_call_status(); - zephir_read_property_cached(&_21$$7, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$7, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_29$$7, &_21$$7, "nextimage", NULL, 0); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_29$$7)) { @@ -1313,11 +1313,11 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processReflection) object_init_ex(&pixel, zephir_get_internal_ce(SL("imagickpixel"))); ZEPHIR_CALL_METHOD(NULL, &pixel, "__construct", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_30, &_4, "getimageheight", NULL, 0); zephir_check_call_status(); height = (zephir_get_numberval(&_30) + height); - zephir_read_property_cached(&_31, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_31, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_32, 0); ZEPHIR_CALL_METHOD(NULL, &_31, "setiteratorindex", NULL, 0, &_32); zephir_check_call_status(); @@ -1325,7 +1325,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processReflection) if (!(1)) { break; } - zephir_read_property_cached(&_33$$10, this_ptr, _zephir_prop_2, 902, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_33$$10, this_ptr, _zephir_prop_2, 911, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_34$$10, height); ZEPHIR_CALL_METHOD(NULL, &image, "newimage", &_35, 0, &_33$$10, &_34$$10, &pixel); zephir_check_call_status(); @@ -1335,17 +1335,17 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processReflection) zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &image, "setimagealphachannel", &_38, 0, &_37$$10); zephir_check_call_status(); - zephir_read_property_cached(&_34$$10, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_34$$10, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_39$$10, &_34$$10, "getcolorspace", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &image, "setcolorspace", &_40, 0, &_39$$10); zephir_check_call_status(); - zephir_read_property_cached(&_41$$10, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_41$$10, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_42$$10, &_41$$10, "getimagedelay", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &image, "setimagedelay", &_43, 0, &_42$$10); zephir_check_call_status(); - zephir_read_property_cached(&_44$$10, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_44$$10, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_36$$10); ZVAL_STRING(&_36$$10, "Imagick::COMPOSITE_SRC"); ZEPHIR_CALL_FUNCTION(&_45$$10, "constant", &_20, 148, &_36$$10); @@ -1363,7 +1363,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processReflection) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_46$$10, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_46$$10, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_50$$10, &_46$$10, "nextimage", NULL, 0); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_50$$10)) { @@ -1384,7 +1384,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processReflection) ZVAL_STRING(&_51$$13, "Imagick::COMPOSITE_OVER"); ZEPHIR_CALL_FUNCTION(&_52$$13, "constant", &_20, 148, &_51$$13); zephir_check_call_status(); - zephir_read_property_cached(&_53$$13, this_ptr, _zephir_prop_3, 903, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_53$$13, this_ptr, _zephir_prop_3, 912, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_54$$13, 0); ZEPHIR_CALL_METHOD(&result, &image, "compositeimage", &_48, 0, &reflection, &_52$$13, &_54$$13, &_53$$13); zephir_check_call_status(); @@ -1411,21 +1411,21 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processReflection) } ZEPHIR_CALL_METHOD(NULL, &reflection, "destroy", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_32, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_32, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_32, "clear", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_60, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_60, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_60, "destroy", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 899, &image); - zephir_read_property_cached(&_61, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 908, &image); + zephir_read_property_cached(&_61, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_62, &_61, "getimagewidth", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 902, &_62); - zephir_read_property_cached(&_63, this_ptr, _zephir_prop_1, 899, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 911, &_62); + zephir_read_property_cached(&_63, this_ptr, _zephir_prop_1, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_64, &_63, "getimageheight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 903, &_64); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 912, &_64); ZEPHIR_MM_RESTORE(); } @@ -1477,7 +1477,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processRender) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 2, 0, &extension_param, &quality_param); zephir_get_strval(&extension, extension_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); ZEPHIR_CALL_METHOD(NULL, &image, "setformat", NULL, 0, &extension); zephir_check_call_status(); @@ -1487,12 +1487,12 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processRender) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_1, &image, "getimagetype", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 901, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 910, &_1); ZEPHIR_CALL_METHOD(&_2, &image, "getimageformat", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_3); ZEPHIR_CONCAT_SV(&_3, "image/", &_2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 904, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 913, &_3); ZEPHIR_INIT_VAR(&_4); zephir_fast_strtolower(&_4, &extension); zephir_get_strval(&extension, &_4); @@ -1564,7 +1564,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processResize) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 2, 0, &width_param, &height_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); ZVAL_LONG(&_0, 0); ZEPHIR_CALL_METHOD(NULL, &image, "setiteratorindex", NULL, 0, &_0); @@ -1585,10 +1585,10 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processResize) } ZEPHIR_CALL_METHOD(&_6, &image, "getimagewidth", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 902, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 911, &_6); ZEPHIR_CALL_METHOD(&_7, &image, "getimageheight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 903, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 912, &_7); ZEPHIR_MM_RESTORE(); } @@ -1639,7 +1639,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processRotate) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, °rees_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1, 0); ZEPHIR_CALL_METHOD(NULL, &_0, "setiteratorindex", NULL, 0, &_1); zephir_check_call_status(); @@ -1651,32 +1651,32 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processRotate) if (!(1)) { break; } - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_3$$3, degrees); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "rotateimage", NULL, 0, &pixel, &_3$$3); zephir_check_call_status(); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 902, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 903, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 911, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 912, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_6$$3, 0); ZVAL_LONG(&_7$$3, 0); ZEPHIR_CALL_METHOD(NULL, &_3$$3, "setimagepage", NULL, 0, &_4$$3, &_5$$3, &_6$$3, &_7$$3); zephir_check_call_status(); - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_8$$3, &_6$$3, "nextimage", NULL, 0); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_8$$3)) { break; } } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_9, &_1, "getimagewidth", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 902, &_9); - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 911, &_9); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_11, &_10, "getimageheight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 903, &_11); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 912, &_11); ZEPHIR_MM_RESTORE(); } @@ -1743,35 +1743,35 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processSave) ZVAL_LONG(&_0, 4); ZEPHIR_CALL_FUNCTION(&extension, "pathinfo", NULL, 199, &file_zv, &_0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "setformat", NULL, 0, &extension); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_1, "setimageformat", NULL, 0, &extension); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_3, &_2, "getimagetype", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 901, &_3); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 910, &_3); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5, &_4, "getimageformat", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_6); ZEPHIR_CONCAT_SV(&_6, "image/", &_5); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 904, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 913, &_6); ZEPHIR_INIT_VAR(&_7); zephir_fast_strtolower(&_7, &extension); ZEPHIR_CPY_WRT(&extension, &_7); do { if (ZEPHIR_IS_STRING(&extension, "gif")) { - zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_8$$3, "optimizeimagelayers", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_9$$3); ZVAL_STRING(&_9$$3, "w"); ZEPHIR_CALL_METHOD(&fp, this_ptr, "phpfopen", NULL, 0, &file_zv, &_9$$3); zephir_check_call_status(); - zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_10$$3, "writeimagesfile", NULL, 0, &fp); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, this_ptr, "phpfclose", NULL, 0, &fp); @@ -1779,7 +1779,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processSave) RETURN_MM_NULL(); } if (ZEPHIR_IS_STRING(&extension, "jpg") || ZEPHIR_IS_STRING(&extension, "jpeg")) { - zephir_read_property_cached(&_11$$4, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$4, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_12$$4); ZVAL_STRING(&_12$$4, "Imagick::COMPRESSION_JPEG"); ZEPHIR_CALL_FUNCTION(&_13$$4, "constant", NULL, 148, &_12$$4); @@ -1795,12 +1795,12 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processSave) ZEPHIR_CALL_METHOD(&_14$$5, this_ptr, "checkhighlow", NULL, 0, &_15$$5, &_16$$5); zephir_check_call_status(); quality = zephir_get_numberval(&_14$$5); - zephir_read_property_cached(&_15$$5, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$5, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_16$$5, quality); ZEPHIR_CALL_METHOD(NULL, &_15$$5, "setimagecompressionquality", NULL, 0, &_16$$5); zephir_check_call_status(); } - zephir_read_property_cached(&_17, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_17, "writeimage", NULL, 0, &file_zv); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -1849,7 +1849,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processSharpen) } amount = zephir_get_numberval(&_0); amount = (long) (zephir_safe_div_long_long(((amount * 3.0)), 100)); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2, 0); ZEPHIR_CALL_METHOD(NULL, &_1, "setiteratorindex", NULL, 0, &_2); zephir_check_call_status(); @@ -1857,12 +1857,12 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processSharpen) if (!(1)) { break; } - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_4$$3, 0); ZVAL_LONG(&_5$$3, amount); ZEPHIR_CALL_METHOD(NULL, &_3$$3, "sharpenimage", NULL, 0, &_4$$3, &_5$$3); zephir_check_call_status(); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_6$$3, &_4$$3, "nextimage", NULL, 0); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_6$$3)) { @@ -2149,7 +2149,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processText) ZEPHIR_CALL_METHOD(NULL, &draw, "setgravity", NULL, 0, &gravity); zephir_check_call_status(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2, 0); ZEPHIR_CALL_METHOD(NULL, &_1, "setiteratorindex", NULL, 0, &_2); zephir_check_call_status(); @@ -2157,11 +2157,11 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processText) if (!(1)) { break; } - zephir_read_property_cached(&_18$$14, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$14, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_19$$14, 0); ZEPHIR_CALL_METHOD(NULL, &_18$$14, "annotateimage", NULL, 0, &draw, offsetX, offsetY, &_19$$14, &text_zv); zephir_check_call_status(); - zephir_read_property_cached(&_19$$14, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19$$14, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_20$$14, &_19$$14, "nextimage", NULL, 0); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_20$$14)) { @@ -2243,7 +2243,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processWatermark) ZVAL_LONG(&_4, opacity); ZEPHIR_CALL_METHOD(NULL, &image, "evaluateimage", NULL, 0, &_2, &_4, &_3); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_5, 0); ZEPHIR_CALL_METHOD(NULL, &_4, "setiteratorindex", NULL, 0, &_5); zephir_check_call_status(); @@ -2251,7 +2251,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processWatermark) if (!(1)) { break; } - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_7$$3); ZVAL_STRING(&_7$$3, "Imagick::COMPOSITE_OVER"); ZEPHIR_CALL_FUNCTION(&_8$$3, "constant", NULL, 148, &_7$$3); @@ -2269,7 +2269,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processWatermark) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_13$$3, &_9$$3, "nextimage", NULL, 0); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_13$$3)) { @@ -2323,7 +2323,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, check) ZVAL_STRING(&_3$$4, "Imagick::IMAGICK_EXTNUM"); ZEPHIR_CALL_FUNCTION(&_4$$4, "constant", NULL, 148, &_3$$4); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 905, &_4$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 914, &_4$$4); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/logger/abstractlogger.zep.c b/ext/phalcon/logger/abstractlogger.zep.c index 216724293a..d5f660d923 100644 --- a/ext/phalcon/logger/abstractlogger.zep.c +++ b/ext/phalcon/logger/abstractlogger.zep.c @@ -220,7 +220,7 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, __construct) ZEPHIR_SEPARATE_PARAM(clock); } if (Z_TYPE_P(timezone) == IS_NULL) { - ZEPHIR_CALL_FUNCTION(&defaultTimezone, "date_default_timezone_get", NULL, 241); + ZEPHIR_CALL_FUNCTION(&defaultTimezone, "date_default_timezone_get", NULL, 247); zephir_check_call_status(); if (UNEXPECTED(1 == ZEPHIR_IS_EMPTY(&defaultTimezone))) { ZEPHIR_INIT_NVAR(&defaultTimezone); @@ -231,15 +231,15 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, __construct) ZEPHIR_CALL_METHOD(NULL, timezone, "__construct", NULL, 0, &defaultTimezone); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 267, &name_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 268, timezone); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 268, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 269, timezone); if (Z_TYPE_P(clock) == IS_NULL) { ZEPHIR_INIT_NVAR(clock); object_init_ex(clock, phalcon_time_clock_systemclock_ce); - ZEPHIR_CALL_METHOD(NULL, clock, "__construct", NULL, 242, timezone); + ZEPHIR_CALL_METHOD(NULL, clock, "__construct", NULL, 248, timezone); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 269, clock); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 270, clock); ZEPHIR_CALL_METHOD(NULL, this_ptr, "setadapters", NULL, 0, &adapters); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -300,9 +300,9 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, begin) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 270, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 271, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&collection, "array_diff_key", NULL, 243, &_0, &_1); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 271, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 272, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_FUNCTION(&collection, "array_diff_key", NULL, 249, &_0, &_1); zephir_check_call_status(); zephir_is_iterable(&collection, 0, "phalcon/Logger/AbstractLogger.zep", 194); if (Z_TYPE_P(&collection) == IS_ARRAY) { @@ -368,9 +368,9 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, commit) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 270, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 271, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&collection, "array_diff_key", NULL, 243, &_0, &_1); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 271, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 272, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_FUNCTION(&collection, "array_diff_key", NULL, 249, &_0, &_1); zephir_check_call_status(); zephir_is_iterable(&collection, 0, "phalcon/Logger/AbstractLogger.zep", 211); if (Z_TYPE_P(&collection) == IS_ARRAY) { @@ -447,7 +447,7 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, excludeAdapters) zephir_get_arrval(&adapters, adapters_param); } zephir_memory_observe(®istered); - zephir_read_property_cached(®istered, this_ptr, _zephir_prop_0, 270, PH_NOISY_CC); + zephir_read_property_cached(®istered, this_ptr, _zephir_prop_0, 271, PH_NOISY_CC); zephir_is_iterable(&adapters, 0, "phalcon/Logger/AbstractLogger.zep", 243); if (Z_TYPE_P(&adapters) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&adapters), _0) @@ -518,17 +518,17 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, getAdapter) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 270, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 271, PH_NOISY_CC | PH_READONLY); if (1 != zephir_array_isset_value(&_0, &name_zv)) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_logger_exceptions_adapternotfound_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 244, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 250, &name_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Logger/AbstractLogger.zep", 257); ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 270, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 271, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_3, &_2, &name_zv, PH_NOISY | PH_READONLY, "phalcon/Logger/AbstractLogger.zep", 260); RETURN_CTOR(&_3); } @@ -594,18 +594,18 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, removeAdapter) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 270, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 271, PH_NOISY_CC | PH_READONLY); if (1 != zephir_array_isset_value(&_0, &name_zv)) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_logger_exceptions_adapternotfound_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 244, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 250, &name_zv); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Logger/AbstractLogger.zep", 300); ZEPHIR_MM_RESTORE(); return; } zephir_unset_property_array(this_ptr, ZEND_STRL("adapters"), &name_zv); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 270, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 271, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_2, &name_zv, PH_SEPARATE); RETURN_THIS(); } @@ -639,9 +639,9 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, rollback) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 270, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 271, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&collection, "array_diff_key", NULL, 243, &_0, &_1); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 271, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 272, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_FUNCTION(&collection, "array_diff_key", NULL, 249, &_0, &_1); zephir_check_call_status(); zephir_is_iterable(&collection, 0, "phalcon/Logger/AbstractLogger.zep", 322); if (Z_TYPE_P(&collection) == IS_ARRAY) { @@ -705,7 +705,7 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, setAdapters) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &adapters_param); zephir_get_arrval(&adapters, adapters_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 270, &adapters); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 271, &adapters); RETURN_THIS(); } @@ -750,7 +750,7 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, setLogLevel) ZEPHIR_INIT_NVAR(&_0); ZVAL_LONG(&_0, 8); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 272, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 273, &_0); RETURN_THIS(); } @@ -830,13 +830,13 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, addMessage) } else { zephir_get_arrval(&context, context_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 272, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_GE_LONG(&_0, level)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 270, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 271, PH_NOISY_CC | PH_READONLY); if (zephir_fast_count_int(&_1$$3) == 0) { ZEPHIR_INIT_VAR(&_2$$4); object_init_ex(&_2$$4, phalcon_logger_exceptions_noadaptersconfigured_ce); - ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 245); + ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 251); zephir_check_call_status(); zephir_throw_exception_debug(&_2$$4, "phalcon/Logger/AbstractLogger.zep", 380); ZEPHIR_MM_RESTORE(); @@ -853,15 +853,15 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, addMessage) } ZEPHIR_INIT_VAR(&item); object_init_ex(&item, phalcon_logger_item_ce); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 269, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 270, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_4$$3, &_3$$3, "now", NULL, 0); zephir_check_call_status(); ZVAL_LONG(&_5$$3, level); - ZEPHIR_CALL_METHOD(NULL, &item, "__construct", NULL, 246, &message_zv, &levelName, &_5$$3, &_4$$3, &context); + ZEPHIR_CALL_METHOD(NULL, &item, "__construct", NULL, 252, &message_zv, &levelName, &_5$$3, &_4$$3, &context); zephir_check_call_status(); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 270, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_3, 271, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&collection, "array_diff_key", NULL, 243, &_5$$3, &_6$$3); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 271, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_3, 272, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_FUNCTION(&collection, "array_diff_key", NULL, 249, &_5$$3, &_6$$3); zephir_check_call_status(); zephir_is_iterable(&collection, 0, "phalcon/Logger/AbstractLogger.zep", 405); if (Z_TYPE_P(&collection) == IS_ARRAY) { @@ -912,7 +912,7 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, addMessage) } ZEPHIR_INIT_VAR(&_12); array_init(&_12); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 271, &_12); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 272, &_12); RETURN_MM_BOOL(1); } @@ -946,7 +946,7 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, getLevelNumber) zephir_fast_strtolower(&levelName, level); ZEPHIR_CALL_METHOD(&_0$$3, this_ptr, "getlevels", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&levels, "array_flip", NULL, 247, &_0$$3); + ZEPHIR_CALL_FUNCTION(&levels, "array_flip", NULL, 253, &_0$$3); zephir_check_call_status(); if (zephir_array_isset_value(&levels, &levelName)) { zephir_array_fetch(&_1$$4, &levels, &levelName, PH_NOISY | PH_READONLY, "phalcon/Logger/AbstractLogger.zep", 436); diff --git a/ext/phalcon/logger/adapter/stream.zep.c b/ext/phalcon/logger/adapter/stream.zep.c index 3c7ecf56ca..e91a8b2288 100644 --- a/ext/phalcon/logger/adapter/stream.zep.c +++ b/ext/phalcon/logger/adapter/stream.zep.c @@ -144,8 +144,8 @@ PHP_METHOD(Phalcon_Logger_Adapter_Stream, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 906, &name_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 907, &mode); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 915, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 916, &mode); ZEPHIR_MM_RESTORE(); } @@ -170,11 +170,11 @@ PHP_METHOD(Phalcon_Logger_Adapter_Stream, close) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 917, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 917, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&handler, &_1$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 908, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 917, &__$null); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "phpfclose", NULL, 0, &handler); zephir_check_call_status(); RETURN_MM(); @@ -237,25 +237,25 @@ PHP_METHOD(Phalcon_Logger_Adapter_Stream, process) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &item); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 917, PH_NOISY_CC | PH_READONLY); if (!(Z_TYPE_P(&_0) == IS_RESOURCE)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 906, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 907, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 915, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 916, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&fileHandler, this_ptr, "phpfopen", NULL, 0, &_1$$3, &_2$$3); zephir_check_call_status(); if (!(Z_TYPE_P(&fileHandler) == IS_RESOURCE)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 908, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 917, &__$null); ZEPHIR_INIT_VAR(&_3$$4); object_init_ex(&_3$$4, phalcon_logger_adapter_exceptions_fileopenfailed_ce); - zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_1, 906, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_2, 907, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_1, 915, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_2, 916, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", NULL, 0, &_4$$4, &_5$$4); zephir_check_call_status(); zephir_throw_exception_debug(&_3$$4, "phalcon/Logger/Adapter/Stream.zep", 127); ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 908, &fileHandler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 917, &fileHandler); } ZEPHIR_CALL_METHOD(&_6, this_ptr, "getformatteditem", NULL, 0, item); zephir_check_call_status(); @@ -263,7 +263,7 @@ PHP_METHOD(Phalcon_Logger_Adapter_Stream, process) ZEPHIR_GET_CONSTANT(&_7, "PHP_EOL"); ZEPHIR_INIT_VAR(&message); ZEPHIR_CONCAT_VV(&message, &_6, &_7); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 917, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, this_ptr, "phpfwrite", NULL, 0, &_8, &message); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/logger/adapter/syslog.zep.c b/ext/phalcon/logger/adapter/syslog.zep.c index 228445e75a..8549156663 100644 --- a/ext/phalcon/logger/adapter/syslog.zep.c +++ b/ext/phalcon/logger/adapter/syslog.zep.c @@ -119,9 +119,9 @@ PHP_METHOD(Phalcon_Logger_Adapter_Syslog, __construct) ZEPHIR_INIT_NVAR(&option); ZVAL_LONG(&option, 4); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 909, &name_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 910, &option); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 911, &facility); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 918, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 919, &option); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 920, &facility); ZEPHIR_MM_RESTORE(); } @@ -143,7 +143,7 @@ PHP_METHOD(Phalcon_Logger_Adapter_Syslog, close) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 912, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 921, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { RETURN_MM_BOOL(1); } @@ -204,16 +204,16 @@ PHP_METHOD(Phalcon_Logger_Adapter_Syslog, process) zephir_fetch_params(1, 1, 0, &item); ZEPHIR_CALL_METHOD(&message, this_ptr, "getformatteditem", NULL, 0, item); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 909, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 910, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 911, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 919, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 920, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&result, this_ptr, "openlog", NULL, 0, &_0, &_1, &_2); zephir_check_call_status(); if (!zephir_is_true(&result)) { ZEPHIR_INIT_VAR(&_3$$3); object_init_ex(&_3$$3, phalcon_logger_adapter_exceptions_syslogopenfailed_ce); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 909, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 911, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 920, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 0, &_4$$3, &_5$$3); zephir_check_call_status(); zephir_throw_exception_debug(&_3$$3, "phalcon/Logger/Adapter/Syslog.zep", 100); @@ -221,9 +221,9 @@ PHP_METHOD(Phalcon_Logger_Adapter_Syslog, process) return; } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 912, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 921, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 912, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 921, &__$false); } ZEPHIR_CALL_METHOD(&_6, item, "getlevel", NULL, 0); zephir_check_call_status(); diff --git a/ext/phalcon/logger/formatter/json.zep.c b/ext/phalcon/logger/formatter/json.zep.c index 78c37ba669..933cefecac 100644 --- a/ext/phalcon/logger/formatter/json.zep.c +++ b/ext/phalcon/logger/formatter/json.zep.c @@ -101,9 +101,9 @@ PHP_METHOD(Phalcon_Logger_Formatter_Json, __construct) zephir_memory_observe(&interpolatorRight_zv); ZVAL_STR_COPY(&interpolatorRight_zv, interpolatorRight); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 913, &dateFormat_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 914, &interpolatorLeft_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 915, &interpolatorRight_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 922, &dateFormat_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 923, &interpolatorLeft_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 924, &interpolatorRight_zv); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/logger/formatter/line.zep.c b/ext/phalcon/logger/formatter/line.zep.c index ceccd03167..0f61280a9e 100644 --- a/ext/phalcon/logger/formatter/line.zep.c +++ b/ext/phalcon/logger/formatter/line.zep.c @@ -120,10 +120,10 @@ PHP_METHOD(Phalcon_Logger_Formatter_Line, __construct) zephir_memory_observe(&interpolatorRight_zv); ZVAL_STR_COPY(&interpolatorRight_zv, interpolatorRight); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 916, &format_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 917, &dateFormat_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 918, &interpolatorLeft_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 919, &interpolatorRight_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 925, &format_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 926, &dateFormat_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 927, &interpolatorLeft_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 928, &interpolatorRight_zv); ZEPHIR_MM_RESTORE(); } @@ -176,25 +176,25 @@ PHP_METHOD(Phalcon_Logger_Formatter_Line, format) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &item); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 916, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 925, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_create_array(&_1, 3, 0); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 918, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 919, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 927, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 928, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_4); ZEPHIR_CONCAT_VSV(&_4, &_2, "date", &_3); ZEPHIR_CALL_METHOD(&_5, this_ptr, "getformatteddate", NULL, 0, item); zephir_check_call_status(); zephir_array_update_zval(&_1, &_4, &_5, PH_COPY); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 918, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 919, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 927, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 928, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_8); ZEPHIR_CONCAT_VSV(&_8, &_6, "level", &_7); ZEPHIR_CALL_METHOD(&_5, item, "getlevelname", NULL, 0); zephir_check_call_status(); zephir_array_update_zval(&_1, &_8, &_5, PH_COPY); - zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 918, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 919, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 927, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 928, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_11); ZEPHIR_CONCAT_VSV(&_11, &_9, "message", &_10); ZEPHIR_CALL_METHOD(&_5, item, "getmessage", NULL, 0); @@ -241,7 +241,7 @@ PHP_METHOD(Phalcon_Logger_Formatter_Line, setFormat) Z_PARAM_STR(format) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&format_zv, format); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 916, &format_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 925, &format_zv); RETURN_THISW(); } diff --git a/ext/phalcon/logger/item.zep.c b/ext/phalcon/logger/item.zep.c index 4f51b20497..d4cfbf1f92 100644 --- a/ext/phalcon/logger/item.zep.c +++ b/ext/phalcon/logger/item.zep.c @@ -133,13 +133,13 @@ PHP_METHOD(Phalcon_Logger_Item, __construct) } else { zephir_get_arrval(&context, context_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 920, &message_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 921, &levelName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 929, &message_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 930, &levelName_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, level); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 922, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 923, dateTime); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 924, &context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 931, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 932, dateTime); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 933, &context); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/logger/loggerfactory.zep.c b/ext/phalcon/logger/loggerfactory.zep.c index 2b7e553f4e..7de341afab 100644 --- a/ext/phalcon/logger/loggerfactory.zep.c +++ b/ext/phalcon/logger/loggerfactory.zep.c @@ -60,7 +60,7 @@ PHP_METHOD(Phalcon_Logger_LoggerFactory, __construct) Z_PARAM_OBJECT_OF_CLASS(factory, phalcon_logger_adapterfactory_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &factory); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 925, factory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 934, factory); } /** @@ -182,7 +182,7 @@ PHP_METHOD(Phalcon_Logger_LoggerFactory, load) ZVAL_STRING(&_8$$3, "options"); ZEPHIR_CALL_METHOD(&adapterOptions, this_ptr, "getarrval", NULL, 0, &adapter, &_8$$3, &_7$$3); zephir_check_call_status(); - zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_0, 925, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_0, 934, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_10$$3, &_9$$3, "newinstance", NULL, 0, &adapterClass, &adapterFileName, &adapterOptions); zephir_check_call_status(); zephir_array_update_zval(&data, &adapterName, &_10$$3, PH_COPY | PH_SEPARATE); @@ -221,7 +221,7 @@ PHP_METHOD(Phalcon_Logger_LoggerFactory, load) ZVAL_STRING(&_14$$4, "options"); ZEPHIR_CALL_METHOD(&adapterOptions, this_ptr, "getarrval", NULL, 0, &adapter, &_14$$4, &_13$$4); zephir_check_call_status(); - zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 925, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 934, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_16$$4, &_15$$4, "newinstance", NULL, 0, &adapterClass, &adapterFileName, &adapterOptions); zephir_check_call_status(); zephir_array_update_zval(&data, &adapterName, &_16$$4, PH_COPY | PH_SEPARATE); diff --git a/ext/phalcon/messages/message.zep.c b/ext/phalcon/messages/message.zep.c index 932c0b105f..e4341b5eac 100644 --- a/ext/phalcon/messages/message.zep.c +++ b/ext/phalcon/messages/message.zep.c @@ -145,13 +145,13 @@ PHP_METHOD(Phalcon_Messages_Message, __construct) } else { zephir_get_arrval(&metaData, metaData_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 926, &message_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 927, &field_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 928, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 935, &message_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 936, &field_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 937, &type_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, code); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 929, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 930, &metaData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 938, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 939, &metaData); ZEPHIR_MM_RESTORE(); } @@ -244,19 +244,19 @@ PHP_METHOD(Phalcon_Messages_Message, jsonSerialize) zephir_create_array(return_value, 5, 0); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 927, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 936, PH_NOISY_CC); zephir_array_update_string(return_value, SL("field"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 926, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 935, PH_NOISY_CC); zephir_array_update_string(return_value, SL("message"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 928, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 937, PH_NOISY_CC); zephir_array_update_string(return_value, SL("type"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 929, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 938, PH_NOISY_CC); zephir_array_update_string(return_value, SL("code"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 930, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 939, PH_NOISY_CC); zephir_array_update_string(return_value, SL("metaData"), &_0, PH_COPY | PH_SEPARATE); RETURN_MM(); } @@ -282,7 +282,7 @@ PHP_METHOD(Phalcon_Messages_Message, setCode) zephir_fetch_params_without_memory_grow(1, 0, &code_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, code); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 929, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 938, &_0); RETURN_THISW(); } @@ -305,7 +305,7 @@ PHP_METHOD(Phalcon_Messages_Message, setField) Z_PARAM_STR(field) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&field_zv, field); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 927, &field_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 936, &field_zv); RETURN_THISW(); } @@ -328,7 +328,7 @@ PHP_METHOD(Phalcon_Messages_Message, setMessage) Z_PARAM_STR(message) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&message_zv, message); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 926, &message_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 935, &message_zv); RETURN_THISW(); } @@ -355,7 +355,7 @@ PHP_METHOD(Phalcon_Messages_Message, setMetaData) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &metaData_param); zephir_get_arrval(&metaData, metaData_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 930, &metaData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 939, &metaData); RETURN_THIS(); } @@ -378,7 +378,7 @@ PHP_METHOD(Phalcon_Messages_Message, setType) Z_PARAM_STR(type) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&type_zv, type); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 928, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 937, &type_zv); RETURN_THISW(); } diff --git a/ext/phalcon/messages/messages.zep.c b/ext/phalcon/messages/messages.zep.c index a552482004..66c3940bd3 100644 --- a/ext/phalcon/messages/messages.zep.c +++ b/ext/phalcon/messages/messages.zep.c @@ -85,7 +85,7 @@ PHP_METHOD(Phalcon_Messages_Messages, __construct) } else { zephir_get_arrval(&messages, messages_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 931, &messages); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 940, &messages); ZEPHIR_MM_RESTORE(); } @@ -164,7 +164,7 @@ PHP_METHOD(Phalcon_Messages_Messages, appendMessages) return; } zephir_memory_observe(¤tMessages); - zephir_read_property_cached(¤tMessages, this_ptr, _zephir_prop_0, 931, PH_NOISY_CC); + zephir_read_property_cached(¤tMessages, this_ptr, _zephir_prop_0, 940, PH_NOISY_CC); if (Z_TYPE_P(messages) == IS_ARRAY) { if (Z_TYPE_P(¤tMessages) == IS_ARRAY) { ZEPHIR_INIT_VAR(&finalMessages); @@ -172,7 +172,7 @@ PHP_METHOD(Phalcon_Messages_Messages, appendMessages) } else { ZEPHIR_CPY_WRT(&finalMessages, messages); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 931, &finalMessages); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 940, &finalMessages); } else { ZEPHIR_CALL_METHOD(NULL, messages, "rewind", NULL, 0); zephir_check_call_status(); @@ -206,7 +206,7 @@ PHP_METHOD(Phalcon_Messages_Messages, count) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("messages", 8, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 931, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 940, PH_NOISY_CC | PH_READONLY); RETURN_LONG(zephir_fast_count_int(&_0)); } @@ -233,9 +233,9 @@ PHP_METHOD(Phalcon_Messages_Messages, current) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 931, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 940, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 932, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 941, PH_NOISY_CC); zephir_array_fetch(&_1, &_0, &_2, PH_NOISY | PH_READONLY, "phalcon/Messages/Messages.zep", 121); RETURN_CTOR(&_1); } @@ -274,7 +274,7 @@ PHP_METHOD(Phalcon_Messages_Messages, filter) ZVAL_STR_COPY(&fieldName_zv, fieldName); ZEPHIR_INIT_VAR(&filtered); array_init(&filtered); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 931, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 940, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&messages, &_0); if (Z_TYPE_P(&messages) == IS_ARRAY) { zephir_is_iterable(&messages, 0, "phalcon/Messages/Messages.zep", 149); @@ -356,7 +356,7 @@ PHP_METHOD(Phalcon_Messages_Messages, jsonSerialize) ZEPHIR_INIT_VAR(&records); array_init(&records); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 931, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 940, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "phalcon/Messages/Messages.zep", 178); if (Z_TYPE_P(&_0) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1) @@ -456,7 +456,7 @@ PHP_METHOD(Phalcon_Messages_Messages, offsetExists) Z_PARAM_ZVAL(index) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &index); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 931, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 940, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, index)); } @@ -494,7 +494,7 @@ PHP_METHOD(Phalcon_Messages_Messages, offsetGet) ZEPHIR_INIT_VAR(&returnValue); ZVAL_NULL(&returnValue); zephir_memory_observe(&message); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 931, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 940, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&message, &_0, index, 0)) { ZEPHIR_CPY_WRT(&returnValue, &message); } @@ -580,9 +580,9 @@ PHP_METHOD(Phalcon_Messages_Messages, offsetUnset) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &index); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 931, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 940, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, index)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 931, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 940, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2$$3, 1); ZEPHIR_MAKE_REF(&_1$$3); ZEPHIR_CALL_FUNCTION(NULL, "array_splice", NULL, 0, &_1$$3, index, &_2$$3); @@ -607,7 +607,7 @@ PHP_METHOD(Phalcon_Messages_Messages, rewind) } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 932, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 941, &_0); } /** @@ -628,8 +628,8 @@ PHP_METHOD(Phalcon_Messages_Messages, valid) if (UNEXPECTED(!_zephir_prop_1)) { _zephir_prop_1 = zend_string_init("position", 8, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 931, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 932, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 940, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 941, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &_1)); } diff --git a/ext/phalcon/mvc/application.zep.c b/ext/phalcon/mvc/application.zep.c index 48ac31ab03..3ab1de6a46 100644 --- a/ext/phalcon/mvc/application.zep.c +++ b/ext/phalcon/mvc/application.zep.c @@ -201,7 +201,7 @@ PHP_METHOD(Phalcon_Mvc_Application, handle) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&uri_zv); ZVAL_STR_COPY(&uri_zv, uri); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 933, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 942, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (Z_TYPE_P(&container) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); @@ -212,7 +212,7 @@ PHP_METHOD(Phalcon_Mvc_Application, handle) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 934, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 943, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_0); _2 = Z_TYPE_P(&eventsManager) != IS_NULL; if (_2) { @@ -276,7 +276,7 @@ PHP_METHOD(Phalcon_Mvc_Application, handle) zephir_check_call_status(); if (!(zephir_is_true(&moduleName))) { ZEPHIR_OBS_NVAR(&moduleName); - zephir_read_property_cached(&moduleName, this_ptr, _zephir_prop_2, 935, PH_NOISY_CC); + zephir_read_property_cached(&moduleName, this_ptr, _zephir_prop_2, 944, PH_NOISY_CC); } ZEPHIR_INIT_VAR(&moduleObject); ZVAL_NULL(&moduleObject); @@ -365,7 +365,7 @@ PHP_METHOD(Phalcon_Mvc_Application, handle) zephir_check_call_status(); } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 936, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 945, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&implicitView, &_0); if (ZEPHIR_IS_TRUE_IDENTICAL(&implicitView)) { ZEPHIR_INIT_VAR(&_25$$23); @@ -492,12 +492,12 @@ PHP_METHOD(Phalcon_Mvc_Application, handle) ZEPHIR_CALL_METHOD(NULL, &eventsManager, "fire", NULL, 0, &_44$$40, this_ptr, &response); zephir_check_call_status(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 937, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 946, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(NULL, &response, "sendheaders", NULL, 0); zephir_check_call_status(); } - zephir_read_property_cached(&_45, this_ptr, _zephir_prop_5, 938, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_45, this_ptr, _zephir_prop_5, 947, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_45)) { ZEPHIR_CALL_METHOD(NULL, &response, "sendcookies", NULL, 0); zephir_check_call_status(); @@ -526,9 +526,9 @@ PHP_METHOD(Phalcon_Mvc_Application, sendCookiesOnHandleRequest) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &sendCookies_param); if (sendCookies) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 938, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 947, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 938, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 947, &__$false); } RETURN_THISW(); } @@ -554,9 +554,9 @@ PHP_METHOD(Phalcon_Mvc_Application, sendHeadersOnHandleRequest) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &sendHeaders_param); if (sendHeaders) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 937, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 946, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 937, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 946, &__$false); } RETURN_THISW(); } @@ -583,9 +583,9 @@ PHP_METHOD(Phalcon_Mvc_Application, useImplicitView) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &implicitView_param); if (implicitView) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 936, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 945, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 936, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 945, &__$false); } RETURN_THISW(); } diff --git a/ext/phalcon/mvc/controller.zep.c b/ext/phalcon/mvc/controller.zep.c index d727d691b7..54c96ea1d6 100644 --- a/ext/phalcon/mvc/controller.zep.c +++ b/ext/phalcon/mvc/controller.zep.c @@ -113,7 +113,7 @@ PHP_METHOD(Phalcon_Mvc_Controller, getEventsManager) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 939, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 948, PH_NOISY_CC); RETURN_CCTOR(&_0); } @@ -137,7 +137,7 @@ PHP_METHOD(Phalcon_Mvc_Controller, setEventsManager) Z_PARAM_OBJECT_OF_CLASS(eventsManager, phalcon_events_managerinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &eventsManager); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 939, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 948, eventsManager); } /** @@ -194,7 +194,7 @@ PHP_METHOD(Phalcon_Mvc_Controller, fireManagerEvent) } else { } zephir_memory_observe(&eventsManager); - zephir_read_property_cached(&eventsManager, this_ptr, _zephir_prop_0, 939, PH_NOISY_CC); + zephir_read_property_cached(&eventsManager, this_ptr, _zephir_prop_0, 948, PH_NOISY_CC); if (Z_TYPE_P(&eventsManager) != IS_NULL) { if (cancellable) { ZVAL_BOOL(&_0$$3, 1); diff --git a/ext/phalcon/mvc/dispatcher.zep.c b/ext/phalcon/mvc/dispatcher.zep.c index 769265a768..0dc4ae05cf 100644 --- a/ext/phalcon/mvc/dispatcher.zep.c +++ b/ext/phalcon/mvc/dispatcher.zep.c @@ -141,7 +141,7 @@ PHP_METHOD(Phalcon_Mvc_Dispatcher, forward) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &forward_param); zephir_get_arrval(&forward, forward_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 940, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 949, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_0); if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_1$$3); @@ -229,7 +229,7 @@ PHP_METHOD(Phalcon_Mvc_Dispatcher, setControllerName) Z_PARAM_STR(controllerName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&controllerName_zv, controllerName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 941, &controllerName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 950, &controllerName_zv); RETURN_THISW(); } @@ -252,7 +252,7 @@ PHP_METHOD(Phalcon_Mvc_Dispatcher, setControllerSuffix) Z_PARAM_STR(controllerSuffix) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&controllerSuffix_zv, controllerSuffix); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 942, &controllerSuffix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 951, &controllerSuffix_zv); RETURN_THISW(); } @@ -275,7 +275,7 @@ PHP_METHOD(Phalcon_Mvc_Dispatcher, setDefaultController) Z_PARAM_STR(controllerName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&controllerName_zv, controllerName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 943, &controllerName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 952, &controllerName_zv); RETURN_THISW(); } @@ -305,7 +305,7 @@ PHP_METHOD(Phalcon_Mvc_Dispatcher, handleException) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &exception); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 940, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 949, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_0); if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_2$$3); @@ -359,7 +359,7 @@ PHP_METHOD(Phalcon_Mvc_Dispatcher, throwDispatchException) exceptionCode = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 944, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 953, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (Z_TYPE_P(&container) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); diff --git a/ext/phalcon/mvc/micro.zep.c b/ext/phalcon/mvc/micro.zep.c index 2c3ca6641c..c44333fcbe 100644 --- a/ext/phalcon/mvc/micro.zep.c +++ b/ext/phalcon/mvc/micro.zep.c @@ -263,7 +263,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, error) Z_PARAM_ZVAL(handler) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &handler); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 945, handler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 954, handler); RETURN_THISW(); } @@ -348,7 +348,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, getBoundModels) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 946, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 955, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&modelBinder, &_0); if (Z_TYPE_P(&modelBinder) == IS_NULL) { array_init(return_value); @@ -386,7 +386,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, setEventsManager) Z_PARAM_OBJECT_OF_CLASS(eventsManager, phalcon_events_managerinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &eventsManager); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 947, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 956, eventsManager); } /** @@ -441,17 +441,17 @@ PHP_METHOD(Phalcon_Mvc_Micro, getRouter) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 948, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 957, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { ZEPHIR_INIT_VAR(&_2$$3); ZVAL_STRING(&_2$$3, "router"); ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "getsharedservice", NULL, 0, &_2$$3); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 948, &_1$$3); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 948, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 957, &_1$$3); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 957, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_3$$3, "clear", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 948, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 957, PH_NOISY_CC | PH_READONLY); ZVAL_BOOL(&_5$$3, 1); ZEPHIR_CALL_METHOD(NULL, &_4$$3, "removeextraslashes", NULL, 0, &_5$$3); zephir_check_call_status(); @@ -488,7 +488,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, getService) ZVAL_STR_COPY(&serviceName_zv, serviceName); ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkdicontainer", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 949, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 958, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "get", NULL, 0, &serviceName_zv); zephir_check_call_status(); RETURN_MM(); @@ -523,7 +523,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, getSharedService) ZVAL_STR_COPY(&serviceName_zv, serviceName); ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkdicontainer", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 949, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 958, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getshared", NULL, 0, &serviceName_zv); zephir_check_call_status(); RETURN_MM(); @@ -729,7 +729,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZVAL_NULL(&status); ZEPHIR_INIT_VAR(&realHandler); ZVAL_NULL(&realHandler); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 949, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 958, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (Z_TYPE_P(&container) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); @@ -745,9 +745,9 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_INIT_VAR(&returnedValue); ZVAL_NULL(&returnedValue); - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 956, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_2$$4) != IS_NULL) { - zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_1, 956, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_5$$5); ZVAL_STRING(&_5$$5, "micro:beforeHandleRoute"); ZEPHIR_CALL_METHOD(&_4$$5, &_3$$5, "fire", NULL, 0, &_5$$5, this_ptr); @@ -767,7 +767,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) zephir_check_call_status_or_jump(try_end_1); if (Z_TYPE_P(&matchedRoute) != IS_NULL) { zephir_memory_observe(&handler); - zephir_read_property_cached(&_8$$7, this_ptr, _zephir_prop_2, 950, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$7, this_ptr, _zephir_prop_2, 959, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_9$$7, &matchedRoute, "getrouteid", NULL, 0); zephir_check_call_status_or_jump(try_end_1); if (UNEXPECTED(!(zephir_array_isset_fetch(&handler, &_8$$7, &_9$$7, 0)))) { @@ -779,10 +779,10 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) goto try_end_1; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 951, &handler); - zephir_read_property_cached(&_11$$7, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 960, &handler); + zephir_read_property_cached(&_11$$7, this_ptr, _zephir_prop_1, 956, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_11$$7) != IS_NULL) { - zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_1, 956, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_14$$9); ZVAL_STRING(&_14$$9, "micro:beforeExecuteRoute"); ZEPHIR_CALL_METHOD(&_13$$9, &_12$$9, "fire", NULL, 0, &_14$$9, this_ptr); @@ -791,14 +791,14 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) RETURN_MM_BOOL(0); } ZEPHIR_OBS_NVAR(&handler); - zephir_read_property_cached(&handler, this_ptr, _zephir_prop_3, 951, PH_NOISY_CC); + zephir_read_property_cached(&handler, this_ptr, _zephir_prop_3, 960, PH_NOISY_CC); } - zephir_read_property_cached(&_15$$7, this_ptr, _zephir_prop_4, 952, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$7, this_ptr, _zephir_prop_4, 961, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&beforeHandlers, &_15$$7); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 953, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 962, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 953, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 962, &__$false); } zephir_is_iterable(&beforeHandlers, 0, "phalcon/Mvc/Micro.zep", 444); if (Z_TYPE_P(&beforeHandlers) == IS_ARRAY) { @@ -829,7 +829,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_CALL_USER_FUNC(&status, &before); zephir_check_call_status_or_jump(try_end_1); } - zephir_read_property_cached(&_21$$11, this_ptr, _zephir_prop_5, 953, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$11, this_ptr, _zephir_prop_5, 962, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_21$$11)) { RETURN_CCTOR(&status); } @@ -875,7 +875,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_CALL_USER_FUNC(&status, &before); zephir_check_call_status_or_jump(try_end_1); } - zephir_read_property_cached(&_27$$16, this_ptr, _zephir_prop_5, 953, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_27$$16, this_ptr, _zephir_prop_5, 962, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_27$$16)) { RETURN_CCTOR(&status); } @@ -884,7 +884,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_INIT_NVAR(&before); ZEPHIR_CALL_METHOD(¶ms, &router, "getparams", NULL, 0); zephir_check_call_status_or_jump(try_end_1); - zephir_read_property_cached(&_15$$7, this_ptr, _zephir_prop_6, 946, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$7, this_ptr, _zephir_prop_6, 955, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&modelBinder, &_15$$7); _28$$7 = Z_TYPE_P(&handler) == IS_OBJECT; if (_28$$7) { @@ -949,9 +949,9 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) zephir_check_call_status_or_jump(try_end_1); } ZEPHIR_CPY_WRT(&returnedValue, &lazyReturned); - zephir_read_property_cached(&_15$$7, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$7, this_ptr, _zephir_prop_1, 956, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_15$$7) != IS_NULL) { - zephir_read_property_cached(&_40$$29, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_40$$29, this_ptr, _zephir_prop_1, 956, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_42$$29); ZVAL_STRING(&_42$$29, "micro:afterBinding"); ZEPHIR_CALL_METHOD(&_41$$29, &_40$$29, "fire", NULL, 0, &_42$$29, this_ptr); @@ -960,12 +960,12 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) RETURN_MM_BOOL(0); } } - zephir_read_property_cached(&_43$$7, this_ptr, _zephir_prop_7, 954, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_43$$7, this_ptr, _zephir_prop_7, 963, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&afterBindingHandlers, &_43$$7); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 953, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 962, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 953, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 962, &__$false); } zephir_is_iterable(&afterBindingHandlers, 0, "phalcon/Mvc/Micro.zep", 556); if (Z_TYPE_P(&afterBindingHandlers) == IS_ARRAY) { @@ -996,7 +996,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_CALL_USER_FUNC(&status, &afterBinding); zephir_check_call_status_or_jump(try_end_1); } - zephir_read_property_cached(&_48$$31, this_ptr, _zephir_prop_5, 953, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_48$$31, this_ptr, _zephir_prop_5, 962, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_48$$31)) { RETURN_CCTOR(&status); } @@ -1042,28 +1042,28 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_CALL_USER_FUNC(&status, &afterBinding); zephir_check_call_status_or_jump(try_end_1); } - zephir_read_property_cached(&_54$$36, this_ptr, _zephir_prop_5, 953, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_54$$36, this_ptr, _zephir_prop_5, 962, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_54$$36)) { RETURN_CCTOR(&status); } } } ZEPHIR_INIT_NVAR(&afterBinding); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 955, &returnedValue); - zephir_read_property_cached(&_43$$7, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 964, &returnedValue); + zephir_read_property_cached(&_43$$7, this_ptr, _zephir_prop_1, 956, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_43$$7) != IS_NULL) { - zephir_read_property_cached(&_55$$41, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_55$$41, this_ptr, _zephir_prop_1, 956, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_56$$41); ZVAL_STRING(&_56$$41, "micro:afterExecuteRoute"); ZEPHIR_CALL_METHOD(NULL, &_55$$41, "fire", NULL, 0, &_56$$41, this_ptr); zephir_check_call_status_or_jump(try_end_1); } - zephir_read_property_cached(&_57$$7, this_ptr, _zephir_prop_9, 956, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_57$$7, this_ptr, _zephir_prop_9, 965, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&afterHandlers, &_57$$7); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 953, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 962, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 953, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 962, &__$false); } zephir_is_iterable(&afterHandlers, 0, "phalcon/Mvc/Micro.zep", 593); if (Z_TYPE_P(&afterHandlers) == IS_ARRAY) { @@ -1094,7 +1094,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_CALL_USER_FUNC(&status, &after); zephir_check_call_status_or_jump(try_end_1); } - zephir_read_property_cached(&_62$$42, this_ptr, _zephir_prop_5, 953, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_62$$42, this_ptr, _zephir_prop_5, 962, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_62$$42)) { break; } @@ -1140,7 +1140,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_CALL_USER_FUNC(&status, &after); zephir_check_call_status_or_jump(try_end_1); } - zephir_read_property_cached(&_68$$47, this_ptr, _zephir_prop_5, 953, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_68$$47, this_ptr, _zephir_prop_5, 962, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_68$$47)) { break; } @@ -1148,9 +1148,9 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) } ZEPHIR_INIT_NVAR(&after); } else { - zephir_read_property_cached(&_69$$52, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_69$$52, this_ptr, _zephir_prop_1, 956, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_69$$52) != IS_NULL) { - zephir_read_property_cached(&_70$$53, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_70$$53, this_ptr, _zephir_prop_1, 956, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_72$$53); ZVAL_STRING(&_72$$53, "micro:beforeNotFound"); ZEPHIR_CALL_METHOD(&_71$$53, &_70$$53, "fire", NULL, 0, &_72$$53, this_ptr); @@ -1159,7 +1159,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) RETURN_MM_BOOL(0); } } - zephir_read_property_cached(&_73$$52, this_ptr, _zephir_prop_10, 957, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_73$$52, this_ptr, _zephir_prop_10, 966, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(¬FoundHandler, &_73$$52); if (UNEXPECTED(!(zephir_is_callable(¬FoundHandler)))) { ZEPHIR_INIT_VAR(&_74$$55); @@ -1174,20 +1174,20 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_CALL_USER_FUNC(&returnedValue, ¬FoundHandler); zephir_check_call_status_or_jump(try_end_1); } - zephir_read_property_cached(&_75$$4, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_75$$4, this_ptr, _zephir_prop_1, 956, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_75$$4) != IS_NULL) { - zephir_read_property_cached(&_76$$56, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_76$$56, this_ptr, _zephir_prop_1, 956, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_77$$56); ZVAL_STRING(&_77$$56, "micro:afterHandleRoute"); ZEPHIR_CALL_METHOD(NULL, &_76$$56, "fire", NULL, 0, &_77$$56, this_ptr, &returnedValue); zephir_check_call_status_or_jump(try_end_1); } - zephir_read_property_cached(&_78$$4, this_ptr, _zephir_prop_11, 958, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_78$$4, this_ptr, _zephir_prop_11, 967, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&finishHandlers, &_78$$4); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 953, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 962, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 953, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 962, &__$false); } zephir_is_iterable(&finishHandlers, 0, "phalcon/Mvc/Micro.zep", 661); if (Z_TYPE_P(&finishHandlers) == IS_ARRAY) { @@ -1221,7 +1221,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_CALL_USER_FUNC_ARRAY(&status, &finish, &_83$$59); zephir_check_call_status_or_jump(try_end_1); } - zephir_read_property_cached(&_84$$57, this_ptr, _zephir_prop_5, 953, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_84$$57, this_ptr, _zephir_prop_5, 962, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_84$$57)) { break; } @@ -1270,7 +1270,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_CALL_USER_FUNC_ARRAY(&status, &finish, &_90$$64); zephir_check_call_status_or_jump(try_end_1); } - zephir_read_property_cached(&_91$$62, this_ptr, _zephir_prop_5, 953, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_91$$62, this_ptr, _zephir_prop_5, 962, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_91$$62)) { break; } @@ -1287,17 +1287,17 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) if (zephir_is_instance_of(&_92, SL("Throwable"))) { zend_clear_exception(); ZEPHIR_CPY_WRT(&e, &_92); - zephir_read_property_cached(&_93$$67, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_93$$67, this_ptr, _zephir_prop_1, 956, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_93$$67) != IS_NULL) { - zephir_read_property_cached(&_94$$68, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_94$$68, this_ptr, _zephir_prop_1, 956, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_95$$68); ZVAL_STRING(&_95$$68, "micro:beforeException"); ZEPHIR_CALL_METHOD(NULL, &_94$$68, "fire", NULL, 0, &_95$$68, this_ptr, &e); zephir_check_call_status(); } - zephir_read_property_cached(&_96$$67, this_ptr, _zephir_prop_12, 945, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_96$$67, this_ptr, _zephir_prop_12, 954, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_96$$67) != IS_NULL) { - zephir_read_property_cached(&_97$$69, this_ptr, _zephir_prop_12, 945, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_97$$69, this_ptr, _zephir_prop_12, 954, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(!(zephir_is_callable(&_97$$69)))) { ZEPHIR_INIT_VAR(&_98$$70); object_init_ex(&_98$$70, phalcon_mvc_micro_exceptions_errorhandlernotcallable_ce); @@ -1307,7 +1307,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_99$$69, this_ptr, _zephir_prop_12, 945, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_99$$69, this_ptr, _zephir_prop_12, 954, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_100$$69); zephir_create_array(&_100$$69, 1, 0); zephir_array_fast_append(&_100$$69, &e); @@ -1336,9 +1336,9 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) } } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_13, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_13, 968, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { - zephir_read_property_cached(&_101$$77, this_ptr, _zephir_prop_13, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_101$$77, this_ptr, _zephir_prop_13, 968, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(!(zephir_is_callable(&_101$$77)))) { ZEPHIR_INIT_VAR(&_102$$78); object_init_ex(&_102$$78, phalcon_mvc_micro_exceptions_responsehandlernotcallable_ce); @@ -1348,7 +1348,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_103$$77, this_ptr, _zephir_prop_13, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_103$$77, this_ptr, _zephir_prop_13, 968, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&returnedValue); ZEPHIR_CALL_USER_FUNC(&returnedValue, &_103$$77); zephir_check_call_status(); @@ -1413,7 +1413,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, hasService) ZVAL_STR_COPY(&serviceName_zv, serviceName); ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkdicontainer", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 949, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 958, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "has", NULL, 0, &serviceName_zv); zephir_check_call_status(); RETURN_MM(); @@ -1706,7 +1706,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, notFound) Z_PARAM_ZVAL(handler) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &handler); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 957, handler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 966, handler); RETURN_THISW(); } @@ -1825,7 +1825,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, offsetUnset) zephir_fetch_params(1, 1, 0, &offset); ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkdicontainer", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 949, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 958, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "remove", NULL, 0, offset); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -1979,7 +1979,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, setActiveHandler) Z_PARAM_ZVAL(activeHandler) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &activeHandler); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 951, activeHandler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 960, activeHandler); RETURN_THISW(); } @@ -2001,7 +2001,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, setDI) Z_PARAM_OBJECT_OF_CLASS(container, phalcon_di_diinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &container); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 949, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 958, container); } /** @@ -2061,7 +2061,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, setModelBinder) ZEPHIR_CALL_METHOD(NULL, modelBinder, "setcache", NULL, 0, cache); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 946, modelBinder); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 955, modelBinder); RETURN_THIS(); } @@ -2086,7 +2086,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, setResponseHandler) Z_PARAM_ZVAL(handler) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &handler); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 959, handler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 968, handler); RETURN_THISW(); } @@ -2131,7 +2131,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, setService) } ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkdicontainer", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 949, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 958, PH_NOISY_CC | PH_READONLY); if (isShared) { ZVAL_BOOL(&_1, 1); } else { @@ -2158,9 +2158,9 @@ PHP_METHOD(Phalcon_Mvc_Micro, stop) _zephir_prop_0 = zend_string_init("stopped", 7, 1); } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 953, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 962, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 953, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 962, &__$false); } } @@ -2228,13 +2228,13 @@ PHP_METHOD(Phalcon_Mvc_Micro, checkDiContainer) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 949, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 958, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_di_factorydefault_ce); ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 949, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 958, &_1$$3); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/mvc/micro/collection.zep.c b/ext/phalcon/mvc/micro/collection.zep.c index 2675c846e2..ddb5603545 100644 --- a/ext/phalcon/mvc/micro/collection.zep.c +++ b/ext/phalcon/mvc/micro/collection.zep.c @@ -570,11 +570,11 @@ PHP_METHOD(Phalcon_Mvc_Micro_Collection, setHandler) isLazy = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 960, handler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 969, handler); if (isLazy) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 961, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 970, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 961, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 970, &__$false); } RETURN_THISW(); } @@ -604,9 +604,9 @@ PHP_METHOD(Phalcon_Mvc_Micro_Collection, setLazy) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &isLazy_param); if (isLazy) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 961, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 970, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 961, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 970, &__$false); } RETURN_THISW(); } @@ -634,7 +634,7 @@ PHP_METHOD(Phalcon_Mvc_Micro_Collection, setPrefix) Z_PARAM_STR(prefix) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&prefix_zv, prefix); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 962, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 971, &prefix_zv); RETURN_THISW(); } diff --git a/ext/phalcon/mvc/micro/lazyloader.zep.c b/ext/phalcon/mvc/micro/lazyloader.zep.c index 2a7f4000b7..957c7e1fa2 100644 --- a/ext/phalcon/mvc/micro/lazyloader.zep.c +++ b/ext/phalcon/mvc/micro/lazyloader.zep.c @@ -68,7 +68,7 @@ PHP_METHOD(Phalcon_Mvc_Micro_LazyLoader, __construct) Z_PARAM_STR(definition) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&definition_zv, definition); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 963, &definition_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 972, &definition_zv); } /** @@ -127,9 +127,9 @@ PHP_METHOD(Phalcon_Mvc_Micro_LazyLoader, callMethod) modelBinder = &modelBinder_sub; modelBinder = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 964, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 973, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&handler, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 963, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 972, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&definition, &_0); if (Z_TYPE_P(&handler) != IS_OBJECT) { if (!(zephir_class_exists(&definition, 1))) { @@ -144,7 +144,7 @@ PHP_METHOD(Phalcon_Mvc_Micro_LazyLoader, callMethod) ZEPHIR_INIT_NVAR(&handler); ZEPHIR_LAST_CALL_STATUS = zephir_create_instance(&handler, &definition); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 964, &handler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 973, &handler); } if (Z_TYPE_P(modelBinder) != IS_NULL) { ZEPHIR_INIT_VAR(&bindCacheKey); diff --git a/ext/phalcon/mvc/model.zep.c b/ext/phalcon/mvc/model.zep.c index ef8ab89093..69bd56454a 100644 --- a/ext/phalcon/mvc/model.zep.c +++ b/ext/phalcon/mvc/model.zep.c @@ -283,7 +283,7 @@ PHP_METHOD(Phalcon_Mvc_Model, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 965, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 974, container); if (Z_TYPE_P(modelsManager) == IS_NULL) { ZEPHIR_INIT_VAR(&_3$$5); ZVAL_STRING(&_3$$5, "modelsManager"); @@ -302,7 +302,7 @@ PHP_METHOD(Phalcon_Mvc_Model, __construct) return; } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 966, modelsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 975, modelsManager); ZEPHIR_CALL_METHOD(NULL, modelsManager, "initialize", NULL, 0, this_ptr); zephir_check_call_status(); if ((zephir_method_exists_ex(this_ptr, ZEND_STRL("onconstruct")) == SUCCESS)) { @@ -366,7 +366,7 @@ PHP_METHOD(Phalcon_Mvc_Model, __call) if (!ZEPHIR_IS_FALSE_IDENTICAL(&records)) { RETURN_CCTOR(&records); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&status, &_1, "missingmethod", NULL, 0, this_ptr, &method_zv, &arguments); zephir_check_call_status(); if (Z_TYPE_P(&status) != IS_NULL) { @@ -490,13 +490,13 @@ PHP_METHOD(Phalcon_Mvc_Model, __get) zephir_check_call_status(); ZEPHIR_CPY_WRT(&relation, &_0); if (Z_TYPE_P(&relation) == IS_OBJECT) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 967, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 976, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_1$$3, &lowerProperty)) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 967, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 976, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_3$$4, &_2$$4, &lowerProperty, PH_NOISY | PH_READONLY, "phalcon/Mvc/Model.zep", 407); RETURN_CTOR(&_3$$4); } - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 968, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 977, PH_NOISY_CC | PH_READONLY); _5$$3 = zephir_array_isset_value(&_4$$3, &lowerProperty); if (_5$$3) { ZEPHIR_CALL_METHOD(&_6$$3, &relation, "isreusable", NULL, 0); @@ -504,18 +504,18 @@ PHP_METHOD(Phalcon_Mvc_Model, __get) _5$$3 = !zephir_is_true(&_6$$3); } if (_5$$3) { - zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_1, 968, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_1, 977, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_8$$5); zephir_array_fetch(&_8$$5, &_7$$5, &lowerProperty, PH_NOISY, "phalcon/Mvc/Model.zep", 418); _9$$5 = Z_TYPE_P(&_8$$5) == IS_OBJECT; if (_9$$5) { - zephir_read_property_cached(&_10$$5, this_ptr, _zephir_prop_1, 968, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$5, this_ptr, _zephir_prop_1, 977, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_11$$5); zephir_array_fetch(&_11$$5, &_10$$5, &lowerProperty, PH_NOISY, "phalcon/Mvc/Model.zep", 418); _9$$5 = zephir_instance_of_ev(&_11$$5, phalcon_mvc_modelinterface_ce); } if (_9$$5) { - zephir_read_property_cached(&_12$$6, this_ptr, _zephir_prop_1, 968, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$6, this_ptr, _zephir_prop_1, 977, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_13$$6, &_12$$6, &lowerProperty, PH_NOISY | PH_READONLY, "phalcon/Mvc/Model.zep", 419); RETURN_CTOR(&_13$$6); } @@ -625,7 +625,7 @@ PHP_METHOD(Phalcon_Mvc_Model, __serialize) ZVAL_BOOL(&_1, 0); ZEPHIR_CALL_METHOD(&attributes, this_ptr, "toarray", NULL, 0, &_0, &_1); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 969, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 978, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&dirtyState, &_0); ZEPHIR_CALL_METHOD(&_2, this_ptr, "getmodelsmanager", NULL, 0); zephir_check_call_status(); @@ -634,16 +634,16 @@ PHP_METHOD(Phalcon_Mvc_Model, __serialize) zephir_check_call_status(); _3 = zephir_is_true(&_2); if (_3) { - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 970, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 979, PH_NOISY_CC | PH_READONLY); _3 = Z_TYPE_P(&_0) != IS_NULL; } _4 = _3; if (_4) { - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 970, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 979, PH_NOISY_CC | PH_READONLY); _4 = !ZEPHIR_IS_EQUAL(&attributes, &_1); } if (_4) { - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 970, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 979, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&snapshot, &_5$$3); } zephir_create_array(return_value, 3, 0); @@ -737,7 +737,7 @@ PHP_METHOD(Phalcon_Mvc_Model, __set) zephir_check_call_status(); ZEPHIR_CPY_WRT(&relation, &_1$$3); if (Z_TYPE_P(&relation) == IS_OBJECT) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 969, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 978, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&dirtyState, &_2$$4); ZEPHIR_CALL_METHOD(&_3$$4, value, "getdirtystate", NULL, 0); zephir_check_call_status(); @@ -746,10 +746,10 @@ PHP_METHOD(Phalcon_Mvc_Model, __set) ZVAL_LONG(&dirtyState, 1); } zephir_unset_property_array(this_ptr, ZEND_STRL("related"), &lowerProperty); - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 968, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 977, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_2$$4, &lowerProperty, PH_SEPARATE); zephir_update_property_array(this_ptr, SL("dirtyRelated"), &lowerProperty, value); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 969, &dirtyState); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 978, &dirtyState); RETVAL_ZVAL(value, 1, 0); RETURN_MM(); } @@ -776,12 +776,12 @@ PHP_METHOD(Phalcon_Mvc_Model, __set) ZEPHIR_CALL_METHOD(NULL, &referencedModel, "assign", NULL, 0, value); zephir_check_call_status(); zephir_unset_property_array(this_ptr, ZEND_STRL("related"), &lowerProperty); - zephir_read_property_cached(&_7$$9, this_ptr, _zephir_prop_1, 968, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$9, this_ptr, _zephir_prop_1, 977, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_7$$9, &lowerProperty, PH_SEPARATE); zephir_update_property_array(this_ptr, SL("dirtyRelated"), &lowerProperty, &referencedModel); ZVAL_UNDEF(&_8$$9); ZVAL_LONG(&_8$$9, 1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 969, &_8$$9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 978, &_8$$9); RETVAL_ZVAL(value, 1, 0); RETURN_MM(); } @@ -829,7 +829,7 @@ PHP_METHOD(Phalcon_Mvc_Model, __set) } ZEPHIR_INIT_NVAR(&item); zephir_unset_property_array(this_ptr, ZEND_STRL("related"), &lowerProperty); - zephir_read_property_cached(&_12$$10, this_ptr, _zephir_prop_1, 968, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$10, this_ptr, _zephir_prop_1, 977, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_12$$10, &lowerProperty, PH_SEPARATE); _13$$10 = zephir_fast_count_int(&related) > 0; if (!(_13$$10)) { @@ -841,10 +841,10 @@ PHP_METHOD(Phalcon_Mvc_Model, __set) zephir_update_property_array(this_ptr, SL("dirtyRelated"), &lowerProperty, &related); ZVAL_UNDEF(&_15$$17); ZVAL_LONG(&_15$$17, 1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 969, &_15$$17); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 978, &_15$$17); } else { zephir_unset_property_array(this_ptr, ZEND_STRL("dirtyRelated"), &lowerProperty); - zephir_read_property_cached(&_16$$18, this_ptr, _zephir_prop_2, 967, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$18, this_ptr, _zephir_prop_2, 976, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_16$$18, &lowerProperty, PH_SEPARATE); } RETVAL_ZVAL(value, 1, 0); @@ -865,10 +865,10 @@ PHP_METHOD(Phalcon_Mvc_Model, __set) ZEPHIR_CPY_WRT(&relation, &_17$$19); if (Z_TYPE_P(&relation) == IS_OBJECT) { zephir_unset_property_array(this_ptr, ZEND_STRL("related"), &lowerProperty); - zephir_read_property_cached(&_18$$20, this_ptr, _zephir_prop_1, 968, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$20, this_ptr, _zephir_prop_1, 977, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_18$$20, &lowerProperty, PH_SEPARATE); zephir_unset_property_array(this_ptr, ZEND_STRL("dirtyRelated"), &lowerProperty); - zephir_read_property_cached(&_19$$20, this_ptr, _zephir_prop_2, 967, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19$$20, this_ptr, _zephir_prop_2, 976, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_19$$20, &lowerProperty, PH_SEPARATE); zephir_update_property_zval_zval(this_ptr, &property_zv, &__$null); RETURN_MM_NULL(); @@ -978,7 +978,7 @@ PHP_METHOD(Phalcon_Mvc_Model, __unserialize) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 965, &container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 974, &container); ZEPHIR_INIT_VAR(&_4); ZVAL_STRING(&_4, "modelsManager"); ZEPHIR_CALL_METHOD(&_3, &container, "getshared", NULL, 0, &_4); @@ -995,7 +995,7 @@ PHP_METHOD(Phalcon_Mvc_Model, __unserialize) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 966, &manager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 975, &manager); ZEPHIR_CALL_METHOD(NULL, &manager, "initialize", NULL, 0, this_ptr); zephir_check_call_status(); if ((zephir_method_exists_ex(this_ptr, ZEND_STRL("onconstruct")) == SUCCESS)) { @@ -1049,7 +1049,7 @@ PHP_METHOD(Phalcon_Mvc_Model, __unserialize) } zephir_memory_observe(&dirtyState); if (zephir_array_isset_string_fetch(&dirtyState, &data, SL("dirtyState"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 969, &dirtyState); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 978, &dirtyState); } ZEPHIR_CALL_METHOD(&_3, &manager, "iskeepingsnapshots", NULL, 0, this_ptr); zephir_check_call_status(); @@ -1061,9 +1061,9 @@ PHP_METHOD(Phalcon_Mvc_Model, __unserialize) } else { ZEPHIR_CPY_WRT(&_12$$13, &properties); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 970, &_12$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 979, &_12$$13); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 970, &properties); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 979, &properties); } } ZEPHIR_MM_RESTORE(); @@ -1125,7 +1125,7 @@ PHP_METHOD(Phalcon_Mvc_Model, addBehavior) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &behavior); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "addbehavior", NULL, 0, this_ptr, behavior); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -1290,7 +1290,7 @@ PHP_METHOD(Phalcon_Mvc_Model, assign) } ZEPHIR_INIT_VAR(&rawValues); array_init(&rawValues); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 971, &rawValues); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 980, &rawValues); ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "orm.disable_assign_setters"); ZEPHIR_CALL_CE_STATIC(&disableAssignSetters, phalcon_support_settings_ce, "get", NULL, 0, &_0); @@ -1514,7 +1514,7 @@ PHP_METHOD(Phalcon_Mvc_Model, assign) } } ZEPHIR_INIT_NVAR(&attribute); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 971, &rawValues); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 980, &rawValues); RETURN_THIS(); } @@ -2585,9 +2585,9 @@ PHP_METHOD(Phalcon_Mvc_Model, collectRelatedToSave) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 968, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 977, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&related, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 967, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 976, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&dirtyRelated, &_1); zephir_is_iterable(&related, 0, "phalcon/Mvc/Model.zep", 1378); ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&related), _3, _4, _2) @@ -2772,7 +2772,7 @@ PHP_METHOD(Phalcon_Mvc_Model, create) ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 5, &_5$$3, &_6$$3, &_7$$3, &_8$$3, &_4$$3); zephir_check_call_status(); zephir_array_fast_append(&_2$$3, &_3$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 972, &_2$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 981, &_2$$3); RETURN_MM_BOOL(0); } ZEPHIR_RETURN_CALL_METHOD(this_ptr, "save", NULL, 0); @@ -2898,10 +2898,10 @@ PHP_METHOD(Phalcon_Mvc_Model, delete) zephir_check_call_status(); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 973, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 982, &_0); ZEPHIR_INIT_VAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 972, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 981, &_1); ZEPHIR_INIT_VAR(&_3); ZVAL_STRING(&_3, "orm.virtual_foreign_keys"); ZEPHIR_CALL_CE_STATIC(&_2, phalcon_support_settings_ce, "get", NULL, 0, &_3); @@ -3073,9 +3073,9 @@ PHP_METHOD(Phalcon_Mvc_Model, delete) zephir_check_call_status(); if (zephir_is_true(&_32)) { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 974, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 983, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 974, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 983, &__$false); } ZEPHIR_INIT_VAR(&_34$$20); ZVAL_STRING(&_34$$20, "beforeDelete"); @@ -3084,7 +3084,7 @@ PHP_METHOD(Phalcon_Mvc_Model, delete) if (ZEPHIR_IS_FALSE_IDENTICAL(&_33$$20)) { RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_35$$20, this_ptr, _zephir_prop_2, 974, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_35$$20, this_ptr, _zephir_prop_2, 983, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_35$$20)) { RETURN_MM_BOOL(1); } @@ -3129,22 +3129,22 @@ PHP_METHOD(Phalcon_Mvc_Model, delete) } } if (zephir_is_true(&success)) { - zephir_read_property_cached(&_41$$29, this_ptr, _zephir_prop_3, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_41$$29, this_ptr, _zephir_prop_3, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_41$$29, "registerwrite", NULL, 0, this_ptr); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_42$$29); array_init(&_42$$29); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 968, &_42$$29); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 977, &_42$$29); ZEPHIR_INIT_VAR(&_43$$29); array_init(&_43$$29); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 967, &_43$$29); - zephir_read_property_cached(&_44$$29, this_ptr, _zephir_prop_3, 966, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 976, &_43$$29); + zephir_read_property_cached(&_44$$29, this_ptr, _zephir_prop_3, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_44$$29, "clearreusableobjects", NULL, 0); zephir_check_call_status(); } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 969, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 978, &_0); RETURN_CCTOR(&success); } @@ -3166,7 +3166,7 @@ PHP_METHOD(Phalcon_Mvc_Model, dump) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - ZEPHIR_RETURN_CALL_FUNCTION("get_object_vars", NULL, 313, this_ptr); + ZEPHIR_RETURN_CALL_FUNCTION("get_object_vars", NULL, 325, this_ptr); zephir_check_call_status(); RETURN_MM(); } @@ -3579,7 +3579,7 @@ PHP_METHOD(Phalcon_Mvc_Model, fireEvent) ZEPHIR_CALL_METHOD_ZVAL(NULL, this_ptr, &eventName_zv, NULL, 0); zephir_check_call_status(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "notifyevent", NULL, 0, &eventName_zv, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -3620,7 +3620,7 @@ PHP_METHOD(Phalcon_Mvc_Model, fireEventCancel) RETURN_MM_BOOL(0); } } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_1, "notifyevent", NULL, 0, &eventName_zv, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -3671,7 +3671,7 @@ PHP_METHOD(Phalcon_Mvc_Model, getChangedFields) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 970, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 979, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&snapshot, &_0); if (UNEXPECTED(Z_TYPE_P(&snapshot) != IS_ARRAY)) { ZEPHIR_INIT_VAR(&_1$$3); @@ -3793,7 +3793,7 @@ PHP_METHOD(Phalcon_Mvc_Model, getEventsManager) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getcustomeventsmanager", NULL, 0, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -3876,7 +3876,7 @@ PHP_METHOD(Phalcon_Mvc_Model, getMessages) zephir_array_fast_append(&_2$$4, filter); ZEPHIR_CPY_WRT(filter, &_2$$4); } - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 972, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 981, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_3$$3, 0, "phalcon/Mvc/Model.zep", 2191); if (Z_TYPE_P(&_3$$3) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_3$$3), _4$$3) @@ -3958,9 +3958,9 @@ PHP_METHOD(Phalcon_Mvc_Model, getModelsMetaData) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&metaData); - zephir_read_property_cached(&metaData, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC); + zephir_read_property_cached(&metaData, this_ptr, _zephir_prop_0, 984, PH_NOISY_CC); if (Z_TYPE_P(&metaData) == IS_NULL) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_1, 965, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_1, 974, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0$$3); ZEPHIR_INIT_VAR(&_2$$3); ZVAL_STRING(&_2$$3, "modelsMetadata"); @@ -3978,7 +3978,7 @@ PHP_METHOD(Phalcon_Mvc_Model, getModelsMetaData) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 975, &metaData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 984, &metaData); } RETURN_CCTOR(&metaData); } @@ -4026,14 +4026,14 @@ PHP_METHOD(Phalcon_Mvc_Model, getReadConnection) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 976, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 985, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 976, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 985, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_1$$3, "getconnection", NULL, 0); zephir_check_call_status(); RETURN_MM(); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_2, "getreadconnection", NULL, 0, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -4058,7 +4058,7 @@ PHP_METHOD(Phalcon_Mvc_Model, getReadConnectionService) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getreadconnectionservice", NULL, 0, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -4127,7 +4127,7 @@ PHP_METHOD(Phalcon_Mvc_Model, getRelated) } ZEPHIR_INIT_VAR(&className); zephir_get_class(&className, this_ptr, 0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); ZEPHIR_INIT_VAR(&lowerAlias); zephir_fast_strtolower(&lowerAlias, &alias_zv); @@ -4144,15 +4144,15 @@ PHP_METHOD(Phalcon_Mvc_Model, getRelated) return; } if (Z_TYPE_P(arguments) == IS_NULL) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 967, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 976, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_3$$4, &lowerAlias)) { - zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_1, 967, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_1, 976, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_5$$5, &_4$$5, &lowerAlias, PH_NOISY | PH_READONLY, "phalcon/Mvc/Model.zep", 2321); RETURN_CTOR(&_5$$5); } - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_2, 968, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_2, 977, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_6$$4, &lowerAlias)) { - zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_2, 968, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_2, 977, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_8$$6, &_7$$6, &lowerAlias, PH_NOISY | PH_READONLY, "phalcon/Mvc/Model.zep", 2324); RETURN_CTOR(&_8$$6); } @@ -4208,7 +4208,7 @@ PHP_METHOD(Phalcon_Mvc_Model, isRelationshipLoaded) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&relationshipAlias_zv); ZVAL_STR_COPY(&relationshipAlias_zv, relationshipAlias); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 968, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 977, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_fast_strtolower(&_1, &relationshipAlias_zv); RETURN_MM_BOOL(zephir_array_isset_value(&_0, &_1)); @@ -4232,7 +4232,7 @@ PHP_METHOD(Phalcon_Mvc_Model, getSchema) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getmodelschema", NULL, 0, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -4265,7 +4265,7 @@ PHP_METHOD(Phalcon_Mvc_Model, getSource) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getmodelsource", NULL, 0, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -4330,9 +4330,9 @@ PHP_METHOD(Phalcon_Mvc_Model, getUpdatedFields) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 970, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 979, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&snapshot, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 977, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 986, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&oldSnapshot, &_0); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "orm.update_snapshot_on_save"); @@ -4360,7 +4360,7 @@ PHP_METHOD(Phalcon_Mvc_Model, getUpdatedFields) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 969, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 978, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(!ZEPHIR_IS_LONG(&_0, 0))) { ZEPHIR_INIT_VAR(&_7$$5); object_init_ex(&_7$$5, phalcon_mvc_model_exceptions_recordnotpersisted_ce); @@ -4454,14 +4454,14 @@ PHP_METHOD(Phalcon_Mvc_Model, getWriteConnection) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 976, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 985, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 976, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 985, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_1$$3, "getconnection", NULL, 0); zephir_check_call_status(); RETURN_MM(); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_2, "getwriteconnection", NULL, 0, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -4486,7 +4486,7 @@ PHP_METHOD(Phalcon_Mvc_Model, getWriteConnectionService) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getwriteconnectionservice", NULL, 0, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -4573,7 +4573,7 @@ PHP_METHOD(Phalcon_Mvc_Model, hasSnapshotData) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("snapshot", 8, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 970, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 979, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(!(ZEPHIR_IS_EMPTY(&_0))); } @@ -4922,7 +4922,7 @@ PHP_METHOD(Phalcon_Mvc_Model, refresh) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 969, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 978, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(!ZEPHIR_IS_LONG(&_0, 0))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_mvc_model_exceptions_recordcannotrefresh_ce); @@ -4938,7 +4938,7 @@ PHP_METHOD(Phalcon_Mvc_Model, refresh) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&readConnection, this_ptr, "getreadconnection", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_3); ZEPHIR_CALL_METHOD(&schema, this_ptr, "getschema", NULL, 0); zephir_check_call_status(); @@ -4952,7 +4952,7 @@ PHP_METHOD(Phalcon_Mvc_Model, refresh) } else { ZEPHIR_CPY_WRT(&table, &source); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 978, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 987, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueKey, &_3); if (!(zephir_is_true(&uniqueKey))) { ZEPHIR_CALL_METHOD(&_4$$6, this_ptr, "has", NULL, 0, &metaData, &readConnection); @@ -4968,10 +4968,10 @@ PHP_METHOD(Phalcon_Mvc_Model, refresh) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_2, 978, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_2, 987, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueKey, &_7$$6); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 979, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 988, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueParams, &_3); if (UNEXPECTED(Z_TYPE_P(&uniqueParams) != IS_ARRAY)) { ZEPHIR_INIT_VAR(&_8$$8); @@ -5035,7 +5035,7 @@ PHP_METHOD(Phalcon_Mvc_Model, refresh) zephir_array_update_string(&_16, SL("where"), &uniqueKey, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(&tables, &dialect, "select", NULL, 0, &_16); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_4, 980, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_4, 989, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_18, 2); ZEPHIR_CALL_METHOD(&row, &readConnection, "fetchone", NULL, 0, &tables, &_18, &uniqueParams, &_3); zephir_check_call_status(); @@ -5228,7 +5228,7 @@ PHP_METHOD(Phalcon_Mvc_Model, doSave) if (ZEPHIR_IS_FALSE_IDENTICAL(&_2$$4)) { ZEPHIR_INIT_VAR(&_3$$5); array_init(&_3$$5); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 981, &_3$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 990, &_3$$5); RETURN_MM_BOOL(0); } } @@ -5249,15 +5249,15 @@ PHP_METHOD(Phalcon_Mvc_Model, doSave) if (zephir_is_true(&exists)) { ZVAL_UNDEF(&_4$$8); ZVAL_LONG(&_4$$8, 2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 973, &_4$$8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 982, &_4$$8); } else { ZVAL_UNDEF(&_5$$9); ZVAL_LONG(&_5$$9, 1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 973, &_5$$9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 982, &_5$$9); } ZEPHIR_INIT_NVAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 972, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 981, &_1); ZEPHIR_CALL_METHOD(&identityField, &metaData, "getidentityfield", NULL, 0, this_ptr); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_6, this_ptr, "presave", NULL, 0, &metaData, &exists, &identityField); @@ -5270,7 +5270,7 @@ PHP_METHOD(Phalcon_Mvc_Model, doSave) } ZEPHIR_INIT_VAR(&_8$$10); array_init(&_8$$10); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 981, &_8$$10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 990, &_8$$10); ZEPHIR_INIT_VAR(&_10$$10); ZVAL_STRING(&_10$$10, "orm.exception_on_failed_save"); ZEPHIR_CALL_CE_STATIC(&_9$$10, phalcon_support_settings_ce, "get", NULL, 0, &_10$$10); @@ -5302,9 +5302,9 @@ PHP_METHOD(Phalcon_Mvc_Model, doSave) } if (_14) { zephir_memory_observe(&savedSnapshot); - zephir_read_property_cached(&savedSnapshot, this_ptr, _zephir_prop_3, 970, PH_NOISY_CC); + zephir_read_property_cached(&savedSnapshot, this_ptr, _zephir_prop_3, 979, PH_NOISY_CC); zephir_memory_observe(&savedOldSnapshot); - zephir_read_property_cached(&savedOldSnapshot, this_ptr, _zephir_prop_4, 977, PH_NOISY_CC); + zephir_read_property_cached(&savedOldSnapshot, this_ptr, _zephir_prop_4, 986, PH_NOISY_CC); } if (zephir_is_true(&exists)) { ZEPHIR_CALL_METHOD(&success, this_ptr, "dolowupdate", NULL, 0, &metaData, &writeConnection, &table); @@ -5316,7 +5316,7 @@ PHP_METHOD(Phalcon_Mvc_Model, doSave) if (ZEPHIR_IS_TRUE_IDENTICAL(&success)) { ZVAL_UNDEF(&_17$$16); ZVAL_LONG(&_17$$16, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 969, &_17$$16); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 978, &_17$$16); } if (hasRelatedToSave) { if (ZEPHIR_IS_FALSE_IDENTICAL(&success)) { @@ -5351,19 +5351,19 @@ PHP_METHOD(Phalcon_Mvc_Model, doSave) _22$$21 = zephir_is_true(&_23$$21); } if (_22$$21) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 970, &savedSnapshot); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 977, &savedOldSnapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 979, &savedSnapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 986, &savedOldSnapshot); } } else { if (hasRelatedToSave) { ZEPHIR_INIT_VAR(&_25$$24); array_init(&_25$$24); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 967, &_25$$24); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 976, &_25$$24); } ZEPHIR_INIT_VAR(&_26$$23); array_init(&_26$$23); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 968, &_26$$23); - zephir_read_property_cached(&_27$$23, this_ptr, _zephir_prop_8, 966, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 977, &_26$$23); + zephir_read_property_cached(&_27$$23, this_ptr, _zephir_prop_8, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_27$$23, "clearreusableobjects", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_28$$23); @@ -5373,7 +5373,7 @@ PHP_METHOD(Phalcon_Mvc_Model, doSave) } ZEPHIR_INIT_NVAR(&_16); array_init(&_16); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 981, &_16); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 990, &_16); RETURN_CCTOR(&success); } @@ -5416,7 +5416,7 @@ PHP_METHOD(Phalcon_Mvc_Model, serialize) ZVAL_BOOL(&_1, 0); ZEPHIR_CALL_METHOD(&attributes, this_ptr, "toarray", NULL, 0, &_0, &_1); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 969, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 978, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&dirtyState, &_0); ZEPHIR_CALL_METHOD(&_2, this_ptr, "getmodelsmanager", NULL, 0); zephir_check_call_status(); @@ -5425,16 +5425,16 @@ PHP_METHOD(Phalcon_Mvc_Model, serialize) zephir_check_call_status(); _3 = zephir_is_true(&_2); if (_3) { - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 970, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 979, PH_NOISY_CC | PH_READONLY); _3 = Z_TYPE_P(&_0) != IS_NULL; } _4 = _3; if (_4) { - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 970, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 979, PH_NOISY_CC | PH_READONLY); _4 = !ZEPHIR_IS_EQUAL(&attributes, &_1); } if (_4) { - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 970, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 979, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&snapshot, &_5$$3); } ZEPHIR_INIT_VAR(&_6); @@ -5528,7 +5528,7 @@ PHP_METHOD(Phalcon_Mvc_Model, unserialize) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 965, &container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 974, &container); ZEPHIR_INIT_VAR(&_4$$3); ZVAL_STRING(&_4$$3, "modelsManager"); ZEPHIR_CALL_METHOD(&_3$$3, &container, "getshared", NULL, 0, &_4$$3); @@ -5545,7 +5545,7 @@ PHP_METHOD(Phalcon_Mvc_Model, unserialize) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 966, &manager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 975, &manager); ZEPHIR_CALL_METHOD(NULL, &manager, "initialize", NULL, 0, this_ptr); zephir_check_call_status(); if ((zephir_method_exists_ex(this_ptr, ZEND_STRL("onconstruct")) == SUCCESS)) { @@ -5631,7 +5631,7 @@ PHP_METHOD(Phalcon_Mvc_Model, unserialize) } zephir_memory_observe(&dirtyState); if (zephir_array_isset_string_fetch(&dirtyState, &attributes, SL("dirtyState"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 969, &dirtyState); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 978, &dirtyState); } ZEPHIR_CALL_METHOD(&_3$$3, &manager, "iskeepingsnapshots", NULL, 0, this_ptr); zephir_check_call_status(); @@ -5643,9 +5643,9 @@ PHP_METHOD(Phalcon_Mvc_Model, unserialize) } else { ZEPHIR_CPY_WRT(&_16$$18, &properties); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 970, &_16$$18); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 979, &_16$$18); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 970, &properties); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 979, &properties); } } } @@ -5677,7 +5677,7 @@ PHP_METHOD(Phalcon_Mvc_Model, setConnectionService) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&connectionService_zv); ZVAL_STR_COPY(&connectionService_zv, connectionService); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "setconnectionservice", NULL, 0, this_ptr, &connectionService_zv); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -5704,7 +5704,7 @@ PHP_METHOD(Phalcon_Mvc_Model, setDirtyState) zephir_fetch_params_without_memory_grow(1, 0, &dirtyState_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, dirtyState); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 969, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 978, &_0); RETURN_THISW(); } @@ -5731,7 +5731,7 @@ PHP_METHOD(Phalcon_Mvc_Model, setEventsManager) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &eventsManager); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "setcustomeventsmanager", NULL, 0, this_ptr, eventsManager); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -5762,7 +5762,7 @@ PHP_METHOD(Phalcon_Mvc_Model, setReadConnectionService) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&connectionService_zv); ZVAL_STR_COPY(&connectionService_zv, connectionService); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "setreadconnectionservice", NULL, 0, this_ptr, &connectionService_zv); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -5962,7 +5962,7 @@ PHP_METHOD(Phalcon_Mvc_Model, setOldSnapshotData) } else { ZEPHIR_CPY_WRT(&snapshot, &data); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 977, &snapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 986, &snapshot); ZEPHIR_MM_RESTORE(); } @@ -6191,7 +6191,7 @@ PHP_METHOD(Phalcon_Mvc_Model, setSnapshotData) } else { ZEPHIR_CPY_WRT(&snapshot, &data); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 970, &snapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 979, &snapshot); ZEPHIR_MM_RESTORE(); } @@ -6371,7 +6371,7 @@ PHP_METHOD(Phalcon_Mvc_Model, setTransaction) Z_PARAM_OBJECT_OF_CLASS(transaction, phalcon_mvc_model_transactioninterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &transaction); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 976, transaction); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 985, transaction); RETURN_THISW(); } @@ -6598,7 +6598,7 @@ PHP_METHOD(Phalcon_Mvc_Model, setWriteConnectionService) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&connectionService_zv); ZVAL_STR_COPY(&connectionService_zv, connectionService); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "setwriteconnectionservice", NULL, 0, this_ptr, &connectionService_zv); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -6625,9 +6625,9 @@ PHP_METHOD(Phalcon_Mvc_Model, skipOperation) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &skip_param); if (skip) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 974, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 983, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 974, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 983, &__$false); } } @@ -7031,7 +7031,7 @@ PHP_METHOD(Phalcon_Mvc_Model, update) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 969, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 978, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(&metaData, this_ptr, "getmodelsmetadata", NULL, 0); zephir_check_call_status(); @@ -7059,7 +7059,7 @@ PHP_METHOD(Phalcon_Mvc_Model, update) ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 5, &_6$$4, &_7$$4, &_8$$4, &_9$$4, &_5$$4); zephir_check_call_status(); zephir_array_fast_append(&_3$$4, &_4$$4); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 972, &_3$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 981, &_3$$4); RETURN_MM_BOOL(0); } } @@ -7170,7 +7170,7 @@ PHP_METHOD(Phalcon_Mvc_Model, checkForeignKeysRestrict) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); ZEPHIR_CALL_METHOD(&belongsTo, &manager, "getbelongsto", NULL, 0, this_ptr); zephir_check_call_status(); @@ -7560,7 +7560,7 @@ PHP_METHOD(Phalcon_Mvc_Model, checkForeignKeysReverseCascade) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); ZEPHIR_CALL_METHOD(&relations, &manager, "gethasoneandhasmany", NULL, 0, this_ptr); zephir_check_call_status(); @@ -7698,7 +7698,7 @@ PHP_METHOD(Phalcon_Mvc_Model, checkForeignKeysReverseRestrict) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); ZEPHIR_CALL_METHOD(&relations, &manager, "gethasoneandhasmany", NULL, 0, this_ptr); zephir_check_call_status(); @@ -7976,7 +7976,7 @@ PHP_METHOD(Phalcon_Mvc_Model, doLowInsert) ZEPHIR_SEPARATE_PARAM(table); ZEPHIR_INIT_VAR(&bindSkip); ZVAL_LONG(&bindSkip, 1024); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); ZEPHIR_INIT_VAR(&fields); array_init(&fields); @@ -7988,7 +7988,7 @@ PHP_METHOD(Phalcon_Mvc_Model, doLowInsert) array_init(&bindTypes); ZEPHIR_INIT_VAR(&unsetDefaultValues); array_init(&unsetDefaultValues); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 971, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 980, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&rawValues, &_0); ZEPHIR_CALL_METHOD(&attributes, metaData, "getattributes", NULL, 0, this_ptr); zephir_check_call_status(); @@ -8360,8 +8360,8 @@ PHP_METHOD(Phalcon_Mvc_Model, doLowInsert) } zephir_update_property_zval_zval(this_ptr, &attributeField, &lastInsertedId); zephir_array_update_zval(&snapshot, &attributeField, &lastInsertedId, PH_COPY | PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 978, &__$null); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 979, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 987, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 988, &__$null); } if (zephir_is_true(&success)) { ZEPHIR_CALL_METHOD(NULL, &manager, "registerwrite", NULL, 0, this_ptr); @@ -8392,7 +8392,7 @@ PHP_METHOD(Phalcon_Mvc_Model, doLowInsert) _64$$64 = zephir_is_true(&_65$$64); } if (_64$$64) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 970, &snapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 979, &snapshot); } } RETURN_CCTOR(&success); @@ -8553,14 +8553,14 @@ PHP_METHOD(Phalcon_Mvc_Model, doLowUpdate) array_init(&bindTypes); ZEPHIR_INIT_VAR(&newSnapshot); array_init(&newSnapshot); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 971, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 980, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&rawValues, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); ZEPHIR_CALL_METHOD(&_1, &manager, "isusingdynamicupdate", NULL, 0, this_ptr); zephir_check_call_status(); useDynamicUpdate = zephir_get_boolval(&_1); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 970, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 979, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&snapshot, &_0); ZEPHIR_CALL_METHOD(&dataTypes, metaData, "getdatatypes", NULL, 0, this_ptr); zephir_check_call_status(); @@ -8859,7 +8859,7 @@ PHP_METHOD(Phalcon_Mvc_Model, doLowUpdate) } ZEPHIR_INIT_NVAR(&field); if (!(zephir_fast_count_int(&fields))) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 977, &snapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 986, &snapshot); RETURN_MM_BOOL(1); } } else { @@ -9041,9 +9041,9 @@ PHP_METHOD(Phalcon_Mvc_Model, doLowUpdate) if (!(zephir_fast_count_int(&fields))) { RETURN_MM_BOOL(1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 978, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 987, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueKey, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 979, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 988, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueParams, &_0); if (Z_TYPE_P(&uniqueParams) != IS_ARRAY) { ZEPHIR_CALL_METHOD(&primaryKeys, metaData, "getprimarykeyattributes", NULL, 0, this_ptr); @@ -9150,7 +9150,7 @@ PHP_METHOD(Phalcon_Mvc_Model, doLowUpdate) zephir_array_update_string(&_77, SL("conditions"), &uniqueKey, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_77, SL("bind"), &uniqueParams, PH_COPY | PH_SEPARATE); zephir_memory_observe(&_78); - zephir_read_property_cached(&_78, this_ptr, _zephir_prop_6, 980, PH_NOISY_CC); + zephir_read_property_cached(&_78, this_ptr, _zephir_prop_6, 989, PH_NOISY_CC); zephir_array_update_string(&_77, SL("bindTypes"), &_78, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(&success, connection, "update", NULL, 0, table, &fields, &values, &_77, &bindTypes); zephir_check_call_status(); @@ -9174,15 +9174,15 @@ PHP_METHOD(Phalcon_Mvc_Model, doLowUpdate) } if (_81) { if (Z_TYPE_P(&snapshot) == IS_ARRAY) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 977, &snapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 986, &snapshot); ZEPHIR_INIT_VAR(&_83$$96); zephir_fast_array_merge(&_83$$96, &snapshot, &newSnapshot); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 970, &_83$$96); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 979, &_83$$96); } else { ZEPHIR_INIT_VAR(&_84$$97); array_init(&_84$$97); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 977, &_84$$97); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 970, &newSnapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 986, &_84$$97); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 979, &newSnapshot); } } RETURN_CCTOR(&success); @@ -9274,7 +9274,7 @@ PHP_METHOD(Phalcon_Mvc_Model, has) ZVAL_NULL(&uniqueParams); ZEPHIR_INIT_VAR(&uniqueTypes); ZVAL_NULL(&uniqueTypes); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 978, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 987, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueKey, &_0); if (Z_TYPE_P(&uniqueKey) == IS_NULL) { ZEPHIR_CALL_METHOD(&primaryKeys, metaData, "getprimarykeyattributes", NULL, 0, this_ptr); @@ -9436,25 +9436,25 @@ PHP_METHOD(Phalcon_Mvc_Model, has) } ZEPHIR_INIT_VAR(&joinWhere); zephir_fast_join_str(&joinWhere, SL(" AND "), &wherePk); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 978, &joinWhere); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 979, &uniqueParams); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 980, &uniqueTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 987, &joinWhere); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 988, &uniqueParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 989, &uniqueTypes); ZEPHIR_CPY_WRT(&uniqueKey, &joinWhere); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 969, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 978, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { RETURN_MM_BOOL(1); } if (Z_TYPE_P(&uniqueKey) == IS_NULL) { - zephir_read_property_cached(&_24$$25, this_ptr, _zephir_prop_0, 978, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24$$25, this_ptr, _zephir_prop_0, 987, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueKey, &_24$$25); } if (Z_TYPE_P(&uniqueParams) == IS_NULL) { - zephir_read_property_cached(&_25$$26, this_ptr, _zephir_prop_1, 979, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$26, this_ptr, _zephir_prop_1, 988, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueParams, &_25$$26); } if (Z_TYPE_P(&uniqueTypes) == IS_NULL) { - zephir_read_property_cached(&_26$$27, this_ptr, _zephir_prop_2, 980, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_26$$27, this_ptr, _zephir_prop_2, 989, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueTypes, &_26$$27); } ZEPHIR_CALL_METHOD(&schema, this_ptr, "getschema", NULL, 0); @@ -9480,12 +9480,12 @@ PHP_METHOD(Phalcon_Mvc_Model, has) if (zephir_is_true(&_30)) { ZVAL_UNDEF(&_31$$30); ZVAL_LONG(&_31$$30, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 969, &_31$$30); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 978, &_31$$30); RETURN_MM_BOOL(1); } else { ZVAL_UNDEF(&_32$$31); ZVAL_LONG(&_32$$31, 1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 969, &_32$$31); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 978, &_32$$31); } RETURN_MM_BOOL(0); } @@ -9541,7 +9541,7 @@ PHP_METHOD(Phalcon_Mvc_Model, getRelatedRecords) zephir_memory_observe(&method_zv); ZVAL_STR_COPY(&method_zv, method); zephir_get_arrval(&arguments, arguments_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); ZEPHIR_INIT_VAR(&relation); ZVAL_BOOL(&relation, 0); @@ -10373,9 +10373,9 @@ PHP_METHOD(Phalcon_Mvc_Model, preSave) RETURN_MM_BOOL(0); } if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 974, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 983, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 974, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 983, &__$false); } if (exists) { ZEPHIR_INIT_NVAR(&eventName); @@ -10389,7 +10389,7 @@ PHP_METHOD(Phalcon_Mvc_Model, preSave) if (ZEPHIR_IS_FALSE_IDENTICAL(&_54$$60)) { RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_55$$60, this_ptr, _zephir_prop_0, 974, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_55$$60, this_ptr, _zephir_prop_0, 983, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_55$$60)) { RETURN_MM_BOOL(1); } @@ -11075,12 +11075,12 @@ PHP_METHOD(Phalcon_Mvc_Model, postSaveRelatedRecords) zephir_check_call_status(); doSync = zephir_get_boolval(&_13$$9); ZEPHIR_OBS_NVAR(&override); - zephir_read_property_cached(&_15$$9, this_ptr, _zephir_prop_0, 981, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$9, this_ptr, _zephir_prop_0, 990, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&override, &_15$$9, &name, 0)) { doSync = zephir_get_boolval(&override); } else { ZEPHIR_OBS_NVAR(&override); - zephir_read_property_cached(&_16$$9, this_ptr, _zephir_prop_0, 981, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$9, this_ptr, _zephir_prop_0, 990, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_string_fetch(&override, &_16$$9, SL("*"), 0)) { doSync = zephir_get_boolval(&override); } @@ -12026,12 +12026,12 @@ PHP_METHOD(Phalcon_Mvc_Model, postSaveRelatedRecords) zephir_check_call_status(); doSync = zephir_get_boolval(&_201$$91); ZEPHIR_OBS_NVAR(&override); - zephir_read_property_cached(&_203$$91, this_ptr, _zephir_prop_0, 981, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_203$$91, this_ptr, _zephir_prop_0, 990, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&override, &_203$$91, &name, 0)) { doSync = zephir_get_boolval(&override); } else { ZEPHIR_OBS_NVAR(&override); - zephir_read_property_cached(&_204$$91, this_ptr, _zephir_prop_0, 981, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_204$$91, this_ptr, _zephir_prop_0, 990, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_string_fetch(&override, &_204$$91, SL("*"), 0)) { doSync = zephir_get_boolval(&override); } @@ -13003,7 +13003,7 @@ PHP_METHOD(Phalcon_Mvc_Model, cancelOperation) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 973, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 982, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_LONG(&_0, 3)) { ZEPHIR_INIT_VAR(&_1$$3); ZVAL_STRING(&_1$$3, "notDeleted"); @@ -13103,7 +13103,7 @@ PHP_METHOD(Phalcon_Mvc_Model, belongsTo) } else { zephir_get_arrval(&options, options_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "addbelongsto", NULL, 0, this_ptr, fields, &referenceModel_zv, referencedFields, &options); zephir_check_call_status(); RETURN_MM(); @@ -13283,7 +13283,7 @@ PHP_METHOD(Phalcon_Mvc_Model, hasMany) } else { zephir_get_arrval(&options, options_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "addhasmany", NULL, 0, this_ptr, fields, &referenceModel_zv, referencedFields, &options); zephir_check_call_status(); RETURN_MM(); @@ -13395,7 +13395,7 @@ PHP_METHOD(Phalcon_Mvc_Model, hasManyToMany) } else { zephir_get_arrval(&options, options_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "addhasmanytomany", NULL, 0, this_ptr, fields, &intermediateModel_zv, intermediateFields, intermediateReferencedFields, &referenceModel_zv, referencedFields, &options); zephir_check_call_status(); RETURN_MM(); @@ -13486,7 +13486,7 @@ PHP_METHOD(Phalcon_Mvc_Model, hasOne) } else { zephir_get_arrval(&options, options_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "addhasone", NULL, 0, this_ptr, fields, &referenceModel_zv, referencedFields, &options); zephir_check_call_status(); RETURN_MM(); @@ -13571,7 +13571,7 @@ PHP_METHOD(Phalcon_Mvc_Model, hasOneThrough) } else { zephir_get_arrval(&options, options_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "addhasonethrough", NULL, 0, this_ptr, fields, &intermediateModel_zv, intermediateFields, intermediateReferencedFields, &referenceModel_zv, referencedFields, &options); zephir_check_call_status(); RETURN_MM(); @@ -13613,7 +13613,7 @@ PHP_METHOD(Phalcon_Mvc_Model, keepSnapshots) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &keepSnapshot_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); if (keepSnapshot) { ZVAL_BOOL(&_1, 1); } else { @@ -13649,7 +13649,7 @@ PHP_METHOD(Phalcon_Mvc_Model, setSchema) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&schema_zv); ZVAL_STR_COPY(&schema_zv, schema); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "setmodelschema", NULL, 0, this_ptr, &schema_zv); zephir_check_call_status(); RETURN_THIS(); @@ -13680,7 +13680,7 @@ PHP_METHOD(Phalcon_Mvc_Model, setSource) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&source_zv); ZVAL_STR_COPY(&source_zv, source); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "setmodelsource", NULL, 0, this_ptr, &source_zv); zephir_check_call_status(); RETURN_THIS(); @@ -13921,7 +13921,7 @@ PHP_METHOD(Phalcon_Mvc_Model, useDynamicUpdate) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &dynamicUpdate_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC | PH_READONLY); if (dynamicUpdate) { ZVAL_BOOL(&_1, 1); } else { @@ -14064,7 +14064,7 @@ PHP_METHOD(Phalcon_Mvc_Model, validationHasFailed) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("errorMessages", 13, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 972, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 981, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_fast_count_int(&_0) > 0); } @@ -14158,14 +14158,14 @@ PHP_METHOD(Phalcon_Mvc_Model, getPrivateProperties) array_init(&privateProperties); ZEPHIR_INIT_VAR(&reflection); object_init_ex(&reflection, zephir_get_internal_ce(SL("reflectionclass"))); - ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 233, &className_zv); + ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 239, &className_zv); zephir_check_call_status(); while (1) { if (!(Z_TYPE_P(&reflection) == IS_OBJECT)) { break; } ZVAL_LONG(&_0$$4, 4); - ZEPHIR_CALL_METHOD(&reflectionProperties, &reflection, "getproperties", &_1, 325, &_0$$4); + ZEPHIR_CALL_METHOD(&reflectionProperties, &reflection, "getproperties", &_1, 337, &_0$$4); zephir_check_call_status(); zephir_is_iterable(&reflectionProperties, 0, "phalcon/Mvc/Model.zep", 6522); if (Z_TYPE_P(&reflectionProperties) == IS_ARRAY) { diff --git a/ext/phalcon/mvc/model/binder.zep.c b/ext/phalcon/mvc/model/binder.zep.c index 207abd5590..ad5fd2b02d 100644 --- a/ext/phalcon/mvc/model/binder.zep.c +++ b/ext/phalcon/mvc/model/binder.zep.c @@ -93,7 +93,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Binder, __construct) cache = &cache_sub; cache = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 982, cache); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 991, cache); } /** @@ -156,7 +156,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Binder, bindToHandler) } ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 983, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 992, &_0); _1 = !((zephir_is_instance_of(handler, SL("Closure")))); if (_1) { _1 = ZEPHIR_IS_NULL(&methodName_zv); @@ -172,7 +172,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Binder, bindToHandler) } ZEPHIR_INIT_VAR(&_3); array_init(&_3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 984, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 993, &_3); ZEPHIR_CALL_METHOD(¶msCache, this_ptr, "getparamsfromcache", NULL, 0, &cacheKey_zv); zephir_check_call_status(); if (Z_TYPE_P(¶msCache) == IS_ARRAY) { @@ -283,7 +283,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Binder, setCache) Z_PARAM_OBJECT_OF_CLASS(cache, phalcon_cache_adapter_adapterinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &cache); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 982, cache); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 991, cache); RETURN_THISW(); } @@ -352,11 +352,11 @@ PHP_METHOD(Phalcon_Mvc_Model_Binder, getParamsFromCache) zephir_memory_observe(&cacheKey_zv); ZVAL_STR_COPY(&cacheKey_zv, cacheKey); zephir_memory_observe(&internalParams); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 985, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 994, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&internalParams, &_0, &cacheKey_zv, 0)) { RETURN_CCTOR(&internalParams); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 982, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 991, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cache, &_1); _2 = Z_TYPE_P(&cache) == IS_NULL; if (!(_2)) { @@ -451,12 +451,12 @@ PHP_METHOD(Phalcon_Mvc_Model_Binder, getParamsFromReflection) zephir_check_call_status(); } else { object_init_ex(&reflection, zephir_get_internal_ce(SL("reflectionfunction"))); - ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 230, handler); + ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 236, handler); zephir_check_call_status(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 982, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 991, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cache, &_0); - ZEPHIR_CALL_METHOD(&methodParams, &reflection, "getparameters", NULL, 231); + ZEPHIR_CALL_METHOD(&methodParams, &reflection, "getparameters", NULL, 237); zephir_check_call_status(); ZEPHIR_INIT_VAR(¶msKeys); zephir_array_keys(¶msKeys, ¶ms); diff --git a/ext/phalcon/mvc/model/criteria.zep.c b/ext/phalcon/mvc/model/criteria.zep.c index d7e25f9cb2..dd87cd0721 100644 --- a/ext/phalcon/mvc/model/criteria.zep.c +++ b/ext/phalcon/mvc/model/criteria.zep.c @@ -121,7 +121,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, andWhere) bindTypes = &__$null; } zephir_memory_observe(¤tConditions); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_string_fetch(¤tConditions, &_0, SL("conditions"), 0)) { ZEPHIR_INIT_VAR(&_1$$3); ZEPHIR_CONCAT_SVSVS(&_1$$3, "(", ¤tConditions, ") AND (", &conditions, ")"); @@ -174,7 +174,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, betweenWhere) zephir_memory_observe(&expr_zv); ZVAL_STR_COPY(&expr_zv, expr); zephir_memory_observe(&hiddenParam); - zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 987, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 996, PH_NOISY_CC); ZEPHIR_INIT_VAR(&nextHiddenParam); ZVAL_LONG(&nextHiddenParam, (zephir_get_numberval(&hiddenParam) + 1)); ZEPHIR_INIT_VAR(&minimumKey); @@ -191,7 +191,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, betweenWhere) zephir_check_call_status(); SEPARATE_ZVAL(&nextHiddenParam); zephir_increment(&nextHiddenParam); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 987, &nextHiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 996, &nextHiddenParam); RETURN_THIS(); } @@ -236,7 +236,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, bind) merge = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value_string(&_0, SL("bind")))) { ZEPHIR_INIT_VAR(&_1$$3); array_init(&_1$$3); @@ -244,7 +244,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, bind) ZVAL_STRING(&_2$$3, "bind"); zephir_update_property_array(this_ptr, SL("params"), &_2$$3, &_1$$3); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_4); zephir_array_fetch_string(&_4, &_3, SL("bind"), PH_NOISY, "phalcon/Mvc/Model/Criteria.zep", 130); _5 = Z_TYPE_P(&_4) == IS_ARRAY; @@ -252,7 +252,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, bind) _5 = merge; } if (_5) { - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_7$$4, &_6$$4, SL("bind"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Criteria.zep", 131); ZEPHIR_INIT_VAR(&_8$$4); zephir_add_function(&_8$$4, &_7$$4, &bindParams); @@ -461,10 +461,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, createBuilder) ZEPHIR_CALL_METHOD(&_0, &container, "getshared", NULL, 0, &_1); zephir_check_call_status(); ZEPHIR_CPY_WRT(&manager, &_0); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&builder, &manager, "createbuilder", NULL, 0, &_2); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 988, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &builder, "from", NULL, 0, &_3); zephir_check_call_status(); RETURN_CCTOR(&builder); @@ -788,7 +788,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, getColumns) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&columns); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_string_fetch(&columns, &_0, SL("columns"), 0))) { RETURN_MM_NULL(); } @@ -814,7 +814,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, getConditions) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&conditions); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_string_fetch(&conditions, &_0, SL("conditions"), 0))) { RETURN_MM_NULL(); } @@ -835,7 +835,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, getDI) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("params", 6, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_1, &_0, SL("di"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Criteria.zep", 415); RETURN_CTORW(&_1); } @@ -859,7 +859,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, getGroupBy) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&group); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_string_fetch(&group, &_0, SL("group"), 0))) { RETURN_MM_NULL(); } @@ -885,7 +885,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, getHaving) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&having); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_string_fetch(&having, &_0, SL("having"), 0))) { RETURN_MM_NULL(); } @@ -915,7 +915,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, getLimit) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&limit); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_string_fetch(&limit, &_0, SL("limit"), 0))) { RETURN_MM_NULL(); } @@ -950,7 +950,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, getOrderBy) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&order); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_string_fetch(&order, &_0, SL("order"), 0))) { RETURN_MM_NULL(); } @@ -985,7 +985,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, getWhere) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&conditions); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_string_fetch(&conditions, &_0, SL("conditions"), 0))) { RETURN_MM_NULL(); } @@ -1093,7 +1093,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, inWhere) RETURN_THIS(); } zephir_memory_observe(&hiddenParam); - zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 987, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 996, PH_NOISY_CC); ZEPHIR_INIT_VAR(&bindParams); array_init(&bindParams); ZEPHIR_INIT_VAR(&bindKeys); @@ -1150,7 +1150,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, inWhere) ZEPHIR_CONCAT_VSVS(&_7, &expr_zv, " IN (", &_6, ")"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "andwhere", NULL, 0, &_7, &bindParams); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 987, &hiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 996, &hiddenParam); RETURN_THIS(); } @@ -1473,7 +1473,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, notBetweenWhere) zephir_memory_observe(&expr_zv); ZVAL_STR_COPY(&expr_zv, expr); zephir_memory_observe(&hiddenParam); - zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 987, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 996, PH_NOISY_CC); ZEPHIR_INIT_VAR(&nextHiddenParam); ZVAL_LONG(&nextHiddenParam, (zephir_get_numberval(&hiddenParam) + 1)); ZEPHIR_INIT_VAR(&_0); @@ -1492,7 +1492,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, notBetweenWhere) zephir_check_call_status(); SEPARATE_ZVAL(&nextHiddenParam); zephir_increment(&nextHiddenParam); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 987, &nextHiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 996, &nextHiddenParam); RETURN_THIS(); } @@ -1544,7 +1544,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, notInWhere) ZVAL_STR_COPY(&expr_zv, expr); zephir_get_arrval(&values, values_param); zephir_memory_observe(&hiddenParam); - zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 987, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 996, PH_NOISY_CC); ZEPHIR_INIT_VAR(&bindParams); array_init(&bindParams); ZEPHIR_INIT_VAR(&bindKeys); @@ -1601,7 +1601,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, notInWhere) ZEPHIR_CONCAT_VSVS(&_8, &expr_zv, " NOT IN (", &_7, ")"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "andwhere", NULL, 0, &_8, &bindParams); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 987, &hiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 996, &hiddenParam); RETURN_THIS(); } @@ -1648,7 +1648,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, orWhere) bindTypes = &__$null; } zephir_memory_observe(¤tConditions); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_string_fetch(¤tConditions, &_0, SL("conditions"), 0)) { ZEPHIR_INIT_VAR(&_1$$3); ZEPHIR_CONCAT_SVSVS(&_1$$3, "(", ¤tConditions, ") OR (", &conditions, ")"); @@ -1784,7 +1784,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, setModelName) Z_PARAM_STR(modelName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&modelName_zv, modelName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 988, &modelName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 997, &modelName_zv); RETURN_THISW(); } @@ -1879,7 +1879,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, where) zephir_update_property_array(this_ptr, SL("params"), &_0, &conditions_zv); if (Z_TYPE_P(bindParams) == IS_ARRAY) { zephir_memory_observe(¤tBindParams); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_string_fetch(¤tBindParams, &_1$$3, SL("bind"), 0)) { ZEPHIR_INIT_VAR(&_2$$4); zephir_fast_array_merge(&_2$$4, ¤tBindParams, bindParams); @@ -1894,7 +1894,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, where) } if (Z_TYPE_P(bindTypes) == IS_ARRAY) { zephir_memory_observe(¤tBindTypes); - zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_string_fetch(¤tBindTypes, &_5$$6, SL("bindTypes"), 0)) { ZEPHIR_INIT_VAR(&_6$$7); zephir_fast_array_merge(&_6$$7, ¤tBindTypes, bindTypes); @@ -1983,7 +1983,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, addJoinClause) zephir_array_fast_append(&join, alias); zephir_array_fast_append(&join, type); zephir_memory_observe(¤tJoins); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_string_fetch(¤tJoins, &_0, SL("joins"), 0)) { if (Z_TYPE_P(¤tJoins) == IS_ARRAY) { ZEPHIR_INIT_VAR(&_1$$4); diff --git a/ext/phalcon/mvc/model/manager.zep.c b/ext/phalcon/mvc/model/manager.zep.c index 212ce12bb7..c15804cc70 100644 --- a/ext/phalcon/mvc/model/manager.zep.c +++ b/ext/phalcon/mvc/model/manager.zep.c @@ -274,7 +274,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, addBehavior) zephir_fetch_params(1, 2, 0, &model, &behavior); ZEPHIR_INIT_VAR(&entityName); zephir_get_class(&entityName, model, 1); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 989, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 998, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_0, &entityName))) { ZEPHIR_INIT_VAR(&_1$$3); array_init(&_1$$3); @@ -367,7 +367,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, addBelongsTo) ZEPHIR_CONCAT_VSV(&_0, &entityName, "$", &referencedEntity); zephir_get_strval(&keyRelation, &_0); zephir_memory_observe(&relations); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 990, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 999, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&relations, &_1, &keyRelation, 0))) { ZEPHIR_INIT_NVAR(&relations); array_init(&relations); @@ -414,7 +414,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, addBelongsTo) zephir_update_property_array(this_ptr, SL("aliases"), &_7, &relation); zephir_update_property_array(this_ptr, SL("belongsTo"), &keyRelation, &relations); zephir_memory_observe(&singleRelations); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 991, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1000, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&singleRelations, &_4, &entityName, 0))) { ZEPHIR_INIT_NVAR(&singleRelations); array_init(&singleRelations); @@ -506,7 +506,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, addHasMany) ZEPHIR_INIT_VAR(&_0); ZEPHIR_CONCAT_VSV(&_0, &entityName, "$", &referencedEntity); zephir_get_strval(&keyRelation, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 992, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1001, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&hasMany, &_1); zephir_memory_observe(&relations); if (!(zephir_array_isset_fetch(&relations, &hasMany, &keyRelation, 0))) { @@ -555,7 +555,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, addHasMany) zephir_update_property_array(this_ptr, SL("aliases"), &_6, &relation); zephir_update_property_array(this_ptr, SL("hasMany"), &keyRelation, &relations); zephir_memory_observe(&singleRelations); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 993, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1002, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&singleRelations, &_1, &entityName, 0))) { ZEPHIR_INIT_NVAR(&singleRelations); array_init(&singleRelations); @@ -665,7 +665,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, addHasManyToMany) ZEPHIR_INIT_VAR(&_0); ZEPHIR_CONCAT_VSV(&_0, &entityName, "$", &referencedEntity); zephir_get_strval(&keyRelation, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 994, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1003, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&hasManyToMany, &_1); zephir_memory_observe(&relations); if (!(zephir_array_isset_fetch(&relations, &hasManyToMany, &keyRelation, 0))) { @@ -729,7 +729,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, addHasManyToMany) zephir_update_property_array(this_ptr, SL("aliases"), &_8, &relation); zephir_update_property_array(this_ptr, SL("hasManyToMany"), &keyRelation, &relations); zephir_memory_observe(&singleRelations); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 995, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1004, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&singleRelations, &_1, &entityName, 0))) { ZEPHIR_INIT_NVAR(&singleRelations); array_init(&singleRelations); @@ -822,7 +822,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, addHasOne) ZEPHIR_CONCAT_VSV(&_0, &entityName, "$", &referencedEntity); zephir_get_strval(&keyRelation, &_0); zephir_memory_observe(&relations); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1005, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&relations, &_1, &keyRelation, 0))) { ZEPHIR_INIT_NVAR(&relations); array_init(&relations); @@ -869,7 +869,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, addHasOne) zephir_update_property_array(this_ptr, SL("aliases"), &_7, &relation); zephir_update_property_array(this_ptr, SL("hasOne"), &keyRelation, &relations); zephir_memory_observe(&singleRelations); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1006, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&singleRelations, &_4, &entityName, 0))) { ZEPHIR_INIT_NVAR(&singleRelations); array_init(&singleRelations); @@ -979,7 +979,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, addHasOneThrough) ZEPHIR_INIT_VAR(&_0); ZEPHIR_CONCAT_VSV(&_0, &entityName, "$", &referencedEntity); zephir_get_strval(&keyRelation, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 998, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1007, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&hasOneThrough, &_1); zephir_memory_observe(&relations); if (!(zephir_array_isset_fetch(&relations, &hasOneThrough, &keyRelation, 0))) { @@ -1043,7 +1043,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, addHasOneThrough) zephir_update_property_array(this_ptr, SL("aliases"), &_8, &relation); zephir_update_property_array(this_ptr, SL("hasOneThrough"), &keyRelation, &relations); zephir_memory_observe(&singleRelations); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 999, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1008, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&singleRelations, &_1, &entityName, 0))) { ZEPHIR_INIT_NVAR(&singleRelations); array_init(&singleRelations); @@ -1072,7 +1072,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, clearReusableObjects) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1000, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1009, &_0); ZEPHIR_MM_RESTORE(); } @@ -1118,7 +1118,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, createBuilder) params = ¶ms_sub; params = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1001, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1010, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (UNEXPECTED(Z_TYPE_P(&container) != IS_OBJECT)) { ZEPHIR_INIT_VAR(&_1$$3); @@ -1137,7 +1137,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, createBuilder) ZVAL_STRING(&_4, "Phalcon\\Mvc\\Model\\Query\\Builder"); ZEPHIR_CALL_METHOD(&_2, &container, "get", NULL, 0, &_4, &_3); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1002, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1011, &_2); RETURN_MM_MEMBER(getThis(), "builder"); } @@ -1181,7 +1181,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, createQuery) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&phql_zv); ZVAL_STR_COPY(&phql_zv, phql); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1001, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1010, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (UNEXPECTED(Z_TYPE_P(&container) != IS_OBJECT)) { ZEPHIR_INIT_VAR(&_1$$3); @@ -1201,7 +1201,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, createQuery) ZEPHIR_CALL_METHOD(&_2, &container, "get", NULL, 0, &_4, &_3); zephir_check_call_status(); ZEPHIR_CPY_WRT(&query, &_2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1003, &query); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1012, &query); RETURN_CCTOR(&query); } @@ -1467,7 +1467,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getBelongsTo) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &model); zephir_memory_observe(&relations); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 991, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1000, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (!(zephir_array_isset_fetch(&relations, &_0, &_1, 0))) { @@ -1552,7 +1552,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getBelongsToRecords) ZEPHIR_CONCAT_VSV(&_2, &_0, "$", &_1); zephir_get_strval(&keyRelation, &_2); zephir_memory_observe(&relations); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 992, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1001, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&relations, &_3, &keyRelation, 0))) { RETURN_MM_BOOL(0); } @@ -1639,7 +1639,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getCustomEventsManager) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &model); zephir_memory_observe(&eventsManager); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1004, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1013, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (zephir_array_isset_fetch(&eventsManager, &_0, &_1, 0)) { @@ -1691,7 +1691,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getHasMany) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &model); zephir_memory_observe(&relations); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 993, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1002, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (!(zephir_array_isset_fetch(&relations, &_0, &_1, 0))) { @@ -1768,7 +1768,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getHasManyRecords) ZEPHIR_CONCAT_VSV(&_2, &_0, "$", &_1); zephir_get_strval(&keyRelation, &_2); zephir_memory_observe(&relations); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 992, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1001, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&relations, &_3, &keyRelation, 0))) { RETURN_MM_BOOL(0); } @@ -1803,7 +1803,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getHasManyToMany) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &model); zephir_memory_observe(&relations); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1004, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (!(zephir_array_isset_fetch(&relations, &_0, &_1, 0))) { @@ -1838,7 +1838,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getHasOne) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &model); zephir_memory_observe(&relations); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 997, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1006, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (!(zephir_array_isset_fetch(&relations, &_0, &_1, 0))) { @@ -1942,7 +1942,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getHasOneRecords) ZEPHIR_CONCAT_VSV(&_2, &_0, "$", &_1); zephir_get_strval(&keyRelation, &_2); zephir_memory_observe(&relations); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1005, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&relations, &_3, &keyRelation, 0))) { RETURN_MM_BOOL(0); } @@ -1977,7 +1977,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getHasOneThrough) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &model); zephir_memory_observe(&relations); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 999, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1008, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (!(zephir_array_isset_fetch(&relations, &_0, &_1, 0))) { @@ -2039,7 +2039,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getModelSchema) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &model); zephir_memory_observe(&schema); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1005, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (!(zephir_array_isset_fetch(&schema, &_0, &_1, 0))) { @@ -2083,7 +2083,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getModelSource) zephir_fetch_params(1, 1, 0, &model); ZEPHIR_INIT_VAR(&entityName); zephir_get_class(&entityName, model, 1); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1006, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1015, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_0, &entityName))) { ZEPHIR_INIT_VAR(&_1$$3); ZEPHIR_INIT_VAR(&_2$$3); @@ -2092,8 +2092,8 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getModelSource) ZEPHIR_CALL_METHOD(NULL, this_ptr, "setmodelsource", NULL, 0, model, &_1$$3); zephir_check_call_status(); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 1007, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 1006, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 1016, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 1015, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_5, &_4, &entityName, PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Manager.zep", 1294); ZEPHIR_CONCAT_VV(return_value, &_3, &_5); RETURN_MM(); @@ -2139,20 +2139,20 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getReadConnection) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &model); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1008, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1017, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1009, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1018, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&writeService, this_ptr, "getconnectionservice", NULL, 0, model, &_1$$3); zephir_check_call_status(); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 1010, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 1019, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_2$$3, &writeService)) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 1009, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 1018, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getconnection", NULL, 0, model, &_3$$4); zephir_check_call_status(); RETURN_MM(); } } - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 1011, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 1020, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getconnection", NULL, 0, model, &_4); zephir_check_call_status(); RETURN_MM(); @@ -2181,7 +2181,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getReadConnectionService) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &model); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1011, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1020, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getconnectionservice", NULL, 0, model, &_0); zephir_check_call_status(); RETURN_MM(); @@ -2225,7 +2225,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getRelationByAlias) zephir_memory_observe(&alias_zv); ZVAL_STR_COPY(&alias_zv, alias); zephir_memory_observe(&relation); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1012, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1021, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZEPHIR_INIT_VAR(&_2); ZEPHIR_CONCAT_VSV(&_2, &modelName_zv, "$", &alias_zv); @@ -2763,7 +2763,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getRelations) ZEPHIR_INIT_VAR(&allRelations); array_init(&allRelations); zephir_memory_observe(&relations); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 991, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1000, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&relations, &_0, &entityName, 0)) { zephir_is_iterable(&relations, 0, "phalcon/Mvc/Model/Manager.zep", 1638); if (Z_TYPE_P(&relations) == IS_ARRAY) { @@ -2797,7 +2797,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getRelations) ZEPHIR_INIT_NVAR(&relation); } ZEPHIR_OBS_NVAR(&relations); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 993, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1002, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&relations, &_4, &entityName, 0)) { zephir_is_iterable(&relations, 0, "phalcon/Mvc/Model/Manager.zep", 1647); if (Z_TYPE_P(&relations) == IS_ARRAY) { @@ -2831,7 +2831,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getRelations) ZEPHIR_INIT_NVAR(&relation); } ZEPHIR_OBS_NVAR(&relations); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 997, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 1006, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&relations, &_8, &entityName, 0)) { zephir_is_iterable(&relations, 0, "phalcon/Mvc/Model/Manager.zep", 1656); if (Z_TYPE_P(&relations) == IS_ARRAY) { @@ -2865,7 +2865,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getRelations) ZEPHIR_INIT_NVAR(&relation); } ZEPHIR_OBS_NVAR(&relations); - zephir_read_property_cached(&_12, this_ptr, _zephir_prop_3, 999, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12, this_ptr, _zephir_prop_3, 1008, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&relations, &_12, &entityName, 0)) { zephir_is_iterable(&relations, 0, "phalcon/Mvc/Model/Manager.zep", 1665); if (Z_TYPE_P(&relations) == IS_ARRAY) { @@ -2899,7 +2899,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getRelations) ZEPHIR_INIT_NVAR(&relation); } ZEPHIR_OBS_NVAR(&relations); - zephir_read_property_cached(&_16, this_ptr, _zephir_prop_4, 995, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16, this_ptr, _zephir_prop_4, 1004, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&relations, &_16, &entityName, 0)) { zephir_is_iterable(&relations, 0, "phalcon/Mvc/Model/Manager.zep", 1674); if (Z_TYPE_P(&relations) == IS_ARRAY) { @@ -3002,27 +3002,27 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getRelationsBetween) ZEPHIR_CONCAT_VSV(&_2, &_0, "$", &_1); zephir_get_strval(&keyRelation, &_2); zephir_memory_observe(&relations); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 990, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 999, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&relations, &_3, &keyRelation, 0)) { RETURN_CCTOR(&relations); } ZEPHIR_OBS_NVAR(&relations); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 992, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1001, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&relations, &_4, &keyRelation, 0)) { RETURN_CCTOR(&relations); } ZEPHIR_OBS_NVAR(&relations); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 1005, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&relations, &_5, &keyRelation, 0)) { RETURN_CCTOR(&relations); } ZEPHIR_OBS_NVAR(&relations); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_3, 998, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_3, 1007, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&relations, &_6, &keyRelation, 0)) { RETURN_CCTOR(&relations); } ZEPHIR_OBS_NVAR(&relations); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_4, 994, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_4, 1003, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&relations, &_7, &keyRelation, 0)) { RETURN_CCTOR(&relations); } @@ -3064,7 +3064,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getReusableRecords) zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); zephir_memory_observe(&records); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1000, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1009, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&records, &_0, &key_zv, 0))) { RETURN_MM_NULL(); } @@ -3098,7 +3098,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getWriteConnection) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &model); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1009, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1018, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getconnection", NULL, 0, model, &_0); zephir_check_call_status(); RETURN_MM(); @@ -3131,7 +3131,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getWriteConnectionService) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &model); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1009, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1018, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getconnectionservice", NULL, 0, model, &_0); zephir_check_call_status(); RETURN_MM(); @@ -3360,7 +3360,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, initialize) zephir_fetch_params(1, 1, 0, &model); ZEPHIR_INIT_VAR(&className); zephir_get_class(&className, model, 1); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1022, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, &className)) { RETURN_MM_BOOL(0); } @@ -3369,8 +3369,8 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, initialize) ZEPHIR_CALL_METHOD(NULL, model, "initialize", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1014, model); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1015, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1023, model); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1024, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_1); if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_2$$5); @@ -3378,7 +3378,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, initialize) ZEPHIR_CALL_METHOD(NULL, &eventsManager, "fire", NULL, 0, &_2$$5, this_ptr, model); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1014, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1023, &__$null); RETURN_MM_BOOL(1); } @@ -3411,7 +3411,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, isInitialized) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&className_zv); ZVAL_STR_COPY(&className_zv, className); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1022, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_fast_strtolower(&_1, &className_zv); RETURN_MM_BOOL(zephir_array_isset_value(&_0, &_1)); @@ -3454,7 +3454,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, isKeepingSnapshots) if (zephir_is_true(&_0)) { RETURN_MM_BOOL(1); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1016, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1025, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_1); zephir_get_class(&_1, model, 1); if (!(zephir_array_isset_fetch(&isKeeping, &_2, &_1, 1))) { @@ -3500,7 +3500,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, isUsingDynamicUpdate) if (zephir_is_true(&_0)) { RETURN_MM_BOOL(1); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1017, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1026, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_1); zephir_get_class(&_1, model, 1); if (!(zephir_array_isset_fetch(&isUsing, &_2, &_1, 1))) { @@ -3568,16 +3568,16 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, isVisibleModelProperty) ZVAL_STR_COPY(&property_zv, property); ZEPHIR_INIT_VAR(&className); zephir_get_class(&className, model, 0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1018, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1027, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_0, &className))) { ZEPHIR_INIT_VAR(&publicProperties); array_init(&publicProperties); ZEPHIR_INIT_VAR(&classReflection); object_init_ex(&classReflection, zephir_get_internal_ce(SL("reflectionclass"))); - ZEPHIR_CALL_METHOD(NULL, &classReflection, "__construct", NULL, 233, &className); + ZEPHIR_CALL_METHOD(NULL, &classReflection, "__construct", NULL, 239, &className); zephir_check_call_status(); ZVAL_LONG(&_1$$3, 1); - ZEPHIR_CALL_METHOD(&reflectionProperties, &classReflection, "getproperties", NULL, 325, &_1$$3); + ZEPHIR_CALL_METHOD(&reflectionProperties, &classReflection, "getproperties", NULL, 337, &_1$$3); zephir_check_call_status(); zephir_is_iterable(&reflectionProperties, 0, "phalcon/Mvc/Model/Manager.zep", 1986); if (Z_TYPE_P(&reflectionProperties) == IS_ARRAY) { @@ -3615,7 +3615,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, isVisibleModelProperty) ZEPHIR_INIT_NVAR(&reflectionProperty); zephir_update_property_array(this_ptr, SL("modelVisibility"), &className, &publicProperties); } - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 1018, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 1027, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&properties); zephir_array_fetch(&properties, &_7, &className, PH_NOISY, "phalcon/Mvc/Model/Manager.zep", 1989); RETURN_MM_BOOL(zephir_array_key_exists(&properties, &property_zv)); @@ -3701,7 +3701,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, load) zephir_create_array(&_1, 3, 0); zephir_array_fast_append(&_1, &__$null); zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1001, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1010, PH_NOISY_CC); zephir_array_fast_append(&_1, &_2); zephir_array_fast_append(&_1, this_ptr); ZEPHIR_INIT_VAR(&model); @@ -3762,7 +3762,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, missingMethod) zephir_memory_observe(&eventName_zv); ZVAL_STR_COPY(&eventName_zv, eventName); zephir_memory_observe(&modelsBehaviors); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 989, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 998, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (zephir_array_isset_fetch(&modelsBehaviors, &_0, &_1, 0)) { @@ -3805,7 +3805,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, missingMethod) } ZEPHIR_INIT_NVAR(&behavior); } - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 1015, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 1024, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_5); if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_6$$8); @@ -3874,7 +3874,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, notifyEvent) ZEPHIR_INIT_VAR(&status); ZVAL_BOOL(&status, 1); zephir_memory_observe(&modelsBehaviors); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 989, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 998, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (zephir_array_isset_fetch(&modelsBehaviors, &_0, &_1, 0)) { @@ -3917,7 +3917,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, notifyEvent) } ZEPHIR_INIT_NVAR(&behavior); } - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 1015, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 1024, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_5); if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_6$$8); @@ -3929,7 +3929,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, notifyEvent) } } zephir_memory_observe(&customEventsManager); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 1004, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 1013, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_7); zephir_get_class(&_7, model, 1); if (zephir_array_isset_fetch(&customEventsManager, &_5, &_7, 0)) { @@ -3980,11 +3980,11 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, registerWrite) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &model); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1008, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1017, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1009, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1018, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getconnectionservice", NULL, 0, model, &_2); zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("dirtyWriteServices"), &_1, &__$true); @@ -4043,9 +4043,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, removeBehavior) ZVAL_STR_COPY(&behaviorClass_zv, behaviorClass); ZEPHIR_INIT_VAR(&entityName); zephir_get_class(&entityName, model, 1); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 989, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 998, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, &entityName)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 989, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 998, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_2$$3, &_1$$3, &entityName, PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Manager.zep", 2184); zephir_is_iterable(&_2$$3, 0, "phalcon/Mvc/Model/Manager.zep", 2190); if (Z_TYPE_P(&_2$$3) == IS_ARRAY) { @@ -4062,7 +4062,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, removeBehavior) ZEPHIR_INIT_NVAR(&_6$$4); zephir_get_class(&_6$$4, &behavior, 0); if (ZEPHIR_IS_IDENTICAL(&_6$$4, &behaviorClass_zv)) { - zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_0, 989, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_0, 998, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_8$$5, &_7$$5, &entityName, PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Manager.zep", 2186); zephir_array_unset(&_8$$5, &key, PH_SEPARATE); } @@ -4090,7 +4090,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, removeBehavior) ZEPHIR_INIT_NVAR(&_11$$6); zephir_get_class(&_11$$6, &behavior, 0); if (ZEPHIR_IS_IDENTICAL(&_11$$6, &behaviorClass_zv)) { - zephir_read_property_cached(&_12$$7, this_ptr, _zephir_prop_0, 989, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$7, this_ptr, _zephir_prop_0, 998, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_13$$7, &_12$$7, &entityName, PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Manager.zep", 2186); zephir_array_unset(&_13$$7, &key, PH_SEPARATE); } @@ -4098,7 +4098,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, removeBehavior) } ZEPHIR_INIT_NVAR(&behavior); ZEPHIR_INIT_NVAR(&key); - zephir_read_property_cached(&_14$$3, this_ptr, _zephir_prop_0, 989, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$3, this_ptr, _zephir_prop_0, 998, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_15$$3, &_14$$3, &entityName, PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Manager.zep", 2190); ZEPHIR_CALL_FUNCTION(&_16$$3, "array_values", NULL, 27, &_15$$3); zephir_check_call_status(); @@ -4130,7 +4130,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, resetConnectionState) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1010, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1019, &_0); ZEPHIR_MM_RESTORE(); } @@ -4220,7 +4220,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, setDI) Z_PARAM_OBJECT_OF_CLASS(container, phalcon_di_diinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &container); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1001, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1010, container); } /** @@ -4245,7 +4245,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, setEventsManager) Z_PARAM_OBJECT_OF_CLASS(eventsManager, phalcon_events_managerinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &eventsManager); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1015, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1024, eventsManager); } /** @@ -4290,7 +4290,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, setModelPrefix) Z_PARAM_STR(prefix) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&prefix_zv, prefix); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1007, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1016, &prefix_zv); } /** @@ -4448,9 +4448,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, setSticky) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &sticky_param); if (sticky) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1008, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1017, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1008, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1017, &__$false); } } @@ -4565,7 +4565,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getConnection) zephir_get_arrval(&connectionServices, connectionServices_param); ZEPHIR_CALL_METHOD(&service, this_ptr, "getconnectionservice", NULL, 0, model, &connectionServices); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1001, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1010, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (UNEXPECTED(Z_TYPE_P(&container) != IS_OBJECT)) { ZEPHIR_INIT_VAR(&_1$$3); @@ -4882,7 +4882,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, checkHasRelationship) ZEPHIR_INIT_VAR(&_1); ZEPHIR_CONCAT_VSV(&_1, &entityName, "$", &_0); zephir_get_strval(&keyRelation, &_1); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1022, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_2, &entityName))) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "load", NULL, 0, &modelName_zv); zephir_check_call_status(); diff --git a/ext/phalcon/mvc/model/metadata/apcu.zep.c b/ext/phalcon/mvc/model/metadata/apcu.zep.c index 31910b72cf..9f78d0c05c 100644 --- a/ext/phalcon/mvc/model/metadata/apcu.zep.c +++ b/ext/phalcon/mvc/model/metadata/apcu.zep.c @@ -109,7 +109,7 @@ PHP_METHOD(Phalcon_Mvc_Model_MetaData_Apcu, __construct) ZVAL_STRING(&_1, "apcu"); ZEPHIR_CALL_METHOD(&_5, factory, "newinstance", NULL, 0, &_1, &options); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1019, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1028, &_5); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/mvc/model/metadata/libmemcached.zep.c b/ext/phalcon/mvc/model/metadata/libmemcached.zep.c index 69e60f953c..2764166ecb 100644 --- a/ext/phalcon/mvc/model/metadata/libmemcached.zep.c +++ b/ext/phalcon/mvc/model/metadata/libmemcached.zep.c @@ -106,7 +106,7 @@ PHP_METHOD(Phalcon_Mvc_Model_MetaData_Libmemcached, __construct) ZVAL_STRING(&_1, "libmemcached"); ZEPHIR_CALL_METHOD(&_6, factory, "newinstance", NULL, 0, &_1, &options); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1020, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1029, &_6); ZEPHIR_MM_RESTORE(); } @@ -128,7 +128,7 @@ PHP_METHOD(Phalcon_Mvc_Model_MetaData_Libmemcached, reset) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1020, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1029, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "clear", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_PARENT(NULL, phalcon_mvc_model_metadata_libmemcached_ce, getThis(), "reset", NULL, 0); diff --git a/ext/phalcon/mvc/model/metadata/redis.zep.c b/ext/phalcon/mvc/model/metadata/redis.zep.c index 166561c5f6..9f4847db61 100644 --- a/ext/phalcon/mvc/model/metadata/redis.zep.c +++ b/ext/phalcon/mvc/model/metadata/redis.zep.c @@ -112,7 +112,7 @@ PHP_METHOD(Phalcon_Mvc_Model_MetaData_Redis, __construct) ZVAL_STRING(&_1, "redis"); ZEPHIR_CALL_METHOD(&_5, factory, "newinstance", NULL, 0, &_1, &options); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1021, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1030, &_5); ZEPHIR_MM_RESTORE(); } @@ -134,7 +134,7 @@ PHP_METHOD(Phalcon_Mvc_Model_MetaData_Redis, reset) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1021, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1030, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "clear", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_PARENT(NULL, phalcon_mvc_model_metadata_redis_ce, getThis(), "reset", NULL, 0); diff --git a/ext/phalcon/mvc/model/metadata/stream.zep.c b/ext/phalcon/mvc/model/metadata/stream.zep.c index 365528ab17..bdbb729bfb 100644 --- a/ext/phalcon/mvc/model/metadata/stream.zep.c +++ b/ext/phalcon/mvc/model/metadata/stream.zep.c @@ -90,7 +90,7 @@ PHP_METHOD(Phalcon_Mvc_Model_MetaData_Stream, __construct) } zephir_memory_observe(&metaDataDir); if (zephir_array_isset_string_fetch(&metaDataDir, &options, SL("metaDataDir"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1022, &metaDataDir); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1031, &metaDataDir); } ZEPHIR_MM_RESTORE(); } @@ -126,7 +126,7 @@ PHP_METHOD(Phalcon_Mvc_Model_MetaData_Stream, read) if (Z_TYPE_P(key) == IS_NULL) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1022, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1031, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "_"); @@ -188,7 +188,7 @@ PHP_METHOD(Phalcon_Mvc_Model_MetaData_Stream, write) /* try_start_1: */ - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1022, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1031, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2$$3); ZEPHIR_INIT_VAR(&_3$$3); ZVAL_STRING(&_3$$3, "_"); diff --git a/ext/phalcon/mvc/model/query.zep.c b/ext/phalcon/mvc/model/query.zep.c index 2fcbd52981..65ac712803 100644 --- a/ext/phalcon/mvc/model/query.zep.c +++ b/ext/phalcon/mvc/model/query.zep.c @@ -293,7 +293,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, __construct) } else { zephir_get_arrval(&options, options_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1023, &phql_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1032, &phql_zv); if (Z_TYPE_P(container) == IS_OBJECT) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "setdi", NULL, 0, container); zephir_check_call_status(); @@ -301,23 +301,23 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, __construct) zephir_memory_observe(&enableImplicitJoins); if (zephir_array_isset_string_fetch(&enableImplicitJoins, &options, SL("enable_implicit_joins"), 0)) { if (ZEPHIR_IS_TRUE(&enableImplicitJoins)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1024, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1033, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1024, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1033, &__$false); } } else { ZEPHIR_INIT_VAR(&_1$$5); ZVAL_STRING(&_1$$5, "orm.enable_implicit_joins"); ZEPHIR_CALL_CE_STATIC(&_0$$5, phalcon_support_settings_ce, "get", NULL, 0, &_1$$5); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1024, &_0$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1033, &_0$$5); } ZEPHIR_INIT_VAR(&_2); array_init(&_2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1025, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1034, &_2); ZEPHIR_INIT_VAR(&_3); array_init(&_3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1026, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1035, &_3); ZEPHIR_MM_RESTORE(); } @@ -344,7 +344,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, cache) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &cacheOptions_param); zephir_get_arrval(&cacheOptions, cacheOptions_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1027, &cacheOptions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1036, &cacheOptions); RETURN_THIS(); } @@ -458,9 +458,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, execute) } else { zephir_get_arrval(&bindTypes, bindTypes_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1028, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1037, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueRow, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1027, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1036, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cacheOptions, &_0); if (Z_TYPE_P(&cacheOptions) != IS_NULL) { if (UNEXPECTED(Z_TYPE_P(&cacheOptions) != IS_ARRAY)) { @@ -487,7 +487,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, execute) ZEPHIR_INIT_NVAR(&cacheService); ZVAL_STRING(&cacheService, "modelsCache"); } - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 1029, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 1038, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&cache, &_3$$3, "getshared", NULL, 0, &cacheService); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_4$$3); @@ -540,23 +540,23 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, execute) } RETURN_CCTOR(&preparedResult); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1030, &cache); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1039, &cache); } ZEPHIR_CALL_METHOD(&intermediate, this_ptr, "parse", NULL, 0); zephir_check_call_status(); zephir_memory_observe(&defaultBindParams); - zephir_read_property_cached(&defaultBindParams, this_ptr, _zephir_prop_4, 1025, PH_NOISY_CC); + zephir_read_property_cached(&defaultBindParams, this_ptr, _zephir_prop_4, 1034, PH_NOISY_CC); ZEPHIR_INIT_VAR(&mergedParams); zephir_add_function(&mergedParams, &defaultBindParams, &bindParams); zephir_memory_observe(&defaultBindTypes); - zephir_read_property_cached(&defaultBindTypes, this_ptr, _zephir_prop_5, 1026, PH_NOISY_CC); + zephir_read_property_cached(&defaultBindTypes, this_ptr, _zephir_prop_5, 1035, PH_NOISY_CC); if (Z_TYPE_P(&defaultBindTypes) == IS_ARRAY) { ZEPHIR_INIT_VAR(&mergedTypes); zephir_add_function(&mergedTypes, &defaultBindTypes, &bindTypes); } else { ZEPHIR_CPY_WRT(&mergedTypes, &bindTypes); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 1031, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 1040, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&type, &_0); do { if (ZEPHIR_IS_LONG(&type, 309)) { @@ -704,7 +704,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getSingleResult) } else { zephir_get_arrval(&bindTypes, bindTypes_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1028, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1037, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_RETURN_CALL_METHOD(this_ptr, "execute", NULL, 0, &bindParams, &bindTypes); zephir_check_call_status(); @@ -759,10 +759,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getSql) ZEPHIR_CALL_METHOD(&intermediate, this_ptr, "parse", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1031, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1040, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_LONG(&_0, 309)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1025, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 1026, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1034, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 1035, PH_NOISY_CC | PH_READONLY); ZVAL_BOOL(&_3$$3, 1); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "executeselect", NULL, 0, &intermediate, &_1$$3, &_2$$3, &_3$$3); zephir_check_call_status(); @@ -862,12 +862,12 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, parse) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1032, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1041, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&intermediate, &_0); if (Z_TYPE_P(&intermediate) == IS_ARRAY) { RETURN_CCTOR(&intermediate); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&phql, &_0); ZEPHIR_CALL_CE_STATIC(&ast, phalcon_mvc_model_query_lang_ce, "parsephql", NULL, 0, &phql); zephir_check_call_status(); @@ -883,7 +883,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, parse) if (zephir_array_isset_fetch(&irPhql, &_1$$5, &uniqueId, 0)) { if (Z_TYPE_P(&irPhql) == IS_ARRAY) { zephir_array_fetch_string(&_2$$7, &ast, SL("type"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 661); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1031, &_2$$7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1040, &_2$$7); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "refreshschemasinintermediate", NULL, 0, &irPhql); zephir_check_call_status(); RETURN_MM(); @@ -892,8 +892,8 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, parse) } zephir_memory_observe(&type); if (zephir_array_isset_string_fetch(&type, &ast, SL("type"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1033, &ast); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1031, &type); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1042, &ast); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1040, &type); do { if (ZEPHIR_IS_LONG(&type, 309)) { ZEPHIR_CALL_METHOD(&irPhql, this_ptr, "prepareselect", NULL, 0); @@ -938,7 +938,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, parse) if (Z_TYPE_P(&uniqueId) == IS_LONG) { zephir_update_static_property_array_multi_ce(phalcon_mvc_model_query_ce, SL("internalPhqlCache"), &irPhql, SL("z"), 1, &uniqueId); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1032, &irPhql); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1041, &irPhql); RETURN_CCTOR(&irPhql); } @@ -976,12 +976,12 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, setBindParams) } if (merge) { zephir_memory_observe(¤tBindParams); - zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_0, 1025, PH_NOISY_CC); + zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_0, 1034, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_0$$3); zephir_add_function(&_0$$3, ¤tBindParams, &bindParams); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1025, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1034, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1025, &bindParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1034, &bindParams); } RETURN_THIS(); } @@ -1020,16 +1020,16 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, setBindTypes) } if (UNEXPECTED(merge)) { zephir_memory_observe(¤tBindTypes); - zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_0, 1026, PH_NOISY_CC); + zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_0, 1035, PH_NOISY_CC); if (Z_TYPE_P(¤tBindTypes) == IS_ARRAY) { ZEPHIR_INIT_VAR(&_0$$4); zephir_add_function(&_0$$4, ¤tBindTypes, &bindTypes); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1026, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1035, &_0$$4); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1026, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1035, &bindTypes); } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1026, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1035, &bindTypes); } RETURN_THIS(); } @@ -1095,9 +1095,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, setDI) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1034, &manager); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1035, &metaData); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1029, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1043, &manager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1044, &metaData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1038, container); ZEPHIR_MM_RESTORE(); } @@ -1124,7 +1124,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, setIntermediate) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &intermediate_param); zephir_get_arrval(&intermediate, intermediate_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1032, &intermediate); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1041, &intermediate); RETURN_THIS(); } @@ -1154,9 +1154,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, setSharedLock) } else { } if (sharedLock) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1036, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1045, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1036, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1045, &__$false); } RETURN_THISW(); } @@ -1179,7 +1179,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, setTransaction) Z_PARAM_OBJECT_OF_CLASS(transaction, phalcon_mvc_model_transactioninterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &transaction); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1037, transaction); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1046, transaction); RETURN_THISW(); } @@ -1204,7 +1204,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, setType) zephir_fetch_params_without_memory_grow(1, 0, &type_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, type); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1031, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1040, &_0); RETURN_THISW(); } @@ -1260,7 +1260,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, setResultsetRowClass) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1038, &resultsetRowClass_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1047, &resultsetRowClass_zv); RETURN_THIS(); } @@ -1286,9 +1286,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, setUniqueRow) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &uniqueRow_param); if (uniqueRow) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1028, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1037, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1028, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1037, &__$false); } RETURN_THISW(); } @@ -1359,9 +1359,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeDelete) zephir_memory_observe(&modelName); zephir_array_fetch_long(&modelName, &models, 0, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 871); zephir_memory_observe(&model); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1039, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1048, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&model, &_1, &modelName, 0))) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 1034, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 1043, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&model, &_2$$4, "load", NULL, 0, &modelName); zephir_check_call_status(); } @@ -1516,17 +1516,17 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeInsert) zephir_get_arrval(&bindTypes, bindTypes_param); zephir_memory_observe(&modelName); zephir_array_fetch_string(&modelName, &intermediate, SL("model"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 958); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1034, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1043, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); zephir_memory_observe(&model); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1039, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1048, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&model, &_0, &modelName, 0))) { ZEPHIR_CALL_METHOD(&model, &manager, "load", NULL, 0, &modelName); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(&connection, this_ptr, "getwriteconnection", NULL, 0, &model, &intermediate, &bindParams, &bindTypes); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1035, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1044, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&metaData, &_1); ZEPHIR_CALL_METHOD(&attributes, &metaData, "getattributes", NULL, 0, &model); zephir_check_call_status(); @@ -1926,7 +1926,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeSelect) simulate = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1034, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1043, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); ZEPHIR_INIT_VAR(&connectionTypes); array_init(&connectionTypes); @@ -1939,7 +1939,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeSelect) ZEPHIR_INIT_NVAR(&modelName); ZVAL_COPY(&modelName, _1); ZEPHIR_OBS_NVAR(&model); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 1039, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 1048, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&model, &_2$$3, &modelName, 0))) { ZEPHIR_CALL_METHOD(&model, &manager, "load", &_3, 0, &modelName); zephir_check_call_status(); @@ -1991,7 +1991,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeSelect) ZEPHIR_CALL_METHOD(&modelName, &models, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&model); - zephir_read_property_cached(&_13$$9, this_ptr, _zephir_prop_1, 1039, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$9, this_ptr, _zephir_prop_1, 1048, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&model, &_13$$9, &modelName, 0))) { ZEPHIR_CALL_METHOD(&model, &manager, "load", &_14, 0, &modelName); zephir_check_call_status(); @@ -2120,7 +2120,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeSelect) array_init(&selectColumns); ZEPHIR_INIT_VAR(&simpleColumnMap); array_init(&simpleColumnMap); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1035, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1044, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&metaData, &_0); zephir_is_iterable(&columns, 0, "phalcon/Mvc/Model/Query.zep", 1273); if (Z_TYPE_P(&columns) == IS_ARRAY) { @@ -2141,7 +2141,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeSelect) ZEPHIR_OBS_NVAR(&modelName); zephir_array_fetch_string(&modelName, &column, SL("model"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1194); ZEPHIR_OBS_NVAR(&instance); - zephir_read_property_cached(&_31$$33, this_ptr, _zephir_prop_1, 1039, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_31$$33, this_ptr, _zephir_prop_1, 1048, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&instance, &_31$$33, &modelName, 0))) { ZEPHIR_CALL_METHOD(&instance, &manager, "load", &_32, 0, &modelName); zephir_check_call_status(); @@ -2314,7 +2314,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeSelect) ZEPHIR_OBS_NVAR(&modelName); zephir_array_fetch_string(&modelName, &column, SL("model"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1194); ZEPHIR_OBS_NVAR(&instance); - zephir_read_property_cached(&_59$$51, this_ptr, _zephir_prop_1, 1039, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_59$$51, this_ptr, _zephir_prop_1, 1048, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&instance, &_59$$51, &modelName, 0))) { ZEPHIR_CALL_METHOD(&instance, &manager, "load", &_60, 0, &modelName); zephir_check_call_status(); @@ -2588,7 +2588,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeSelect) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&sqlSelect, &dialect, "select", NULL, 0, &intermediate); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1036, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1045, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(&_97$$83, &dialect, "sharedlock", NULL, 0, &sqlSelect); zephir_check_call_status(); @@ -2648,13 +2648,13 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeSelect) ZEPHIR_INIT_NVAR(&resultData); ZVAL_NULL(&resultData); } - zephir_read_property_cached(&_110, this_ptr, _zephir_prop_4, 1030, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_110, this_ptr, _zephir_prop_4, 1039, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cache, &_110); if (!(isComplex)) { if (isSimpleStd) { - zephir_read_property_cached(&_111$$92, this_ptr, _zephir_prop_5, 1038, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_111$$92, this_ptr, _zephir_prop_5, 1047, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_STRING_IDENTICAL(&_111$$92, "")) { - zephir_read_property_cached(&_112$$93, this_ptr, _zephir_prop_5, 1038, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_112$$93, this_ptr, _zephir_prop_5, 1047, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&resultObject); ZEPHIR_LAST_CALL_STATUS = zephir_create_instance(&resultObject, &_112$$93); zephir_check_call_status(); @@ -2847,7 +2847,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeSelect) RETURN_MM(); } object_init_ex(return_value, phalcon_mvc_model_resultset_complex_ce); - zephir_read_property_cached(&_110, this_ptr, _zephir_prop_5, 1038, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_110, this_ptr, _zephir_prop_5, 1047, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &columns1, &resultData, &cache, &_110); zephir_check_call_status(); RETURN_MM(); @@ -3008,9 +3008,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeUpdate) zephir_memory_observe(&modelName); zephir_array_fetch_long(&modelName, &models, 0, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1499); zephir_memory_observe(&model); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1039, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1048, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&model, &_1, &modelName, 0))) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 1034, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 1043, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&model, &_2$$4, "load", NULL, 0, &modelName); zephir_check_call_status(); } @@ -3096,11 +3096,11 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeUpdate) zephir_preg_match(&_16$$12, &_17$$12, &sqlExpr, &namedParams, 1, 0 , 0 ); if (zephir_is_true(&_16$$12)) { zephir_array_fetch_long(&_18$$13, &namedParams, 1, PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 1590); - ZEPHIR_CALL_FUNCTION(¶mKeys, "array_unique", &_19, 390, &_18$$13); + ZEPHIR_CALL_FUNCTION(¶mKeys, "array_unique", &_19, 402, &_18$$13); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_20$$13); ZEPHIR_INIT_NVAR(&_20$$13); - zephir_create_closure_ex(&_20$$13, NULL, phalcon_87__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_20$$13, NULL, phalcon_89__closure_ce, SL("__invoke")); ZEPHIR_MAKE_REF(¶mKeys); ZEPHIR_CALL_FUNCTION(NULL, "usort", &_21, 0, ¶mKeys, &_20$$13); ZEPHIR_UNREF(¶mKeys); @@ -3289,11 +3289,11 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeUpdate) zephir_preg_match(&_65$$29, &_66$$29, &sqlExpr, &namedParams, 1, 0 , 0 ); if (zephir_is_true(&_65$$29)) { zephir_array_fetch_long(&_67$$30, &namedParams, 1, PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 1590); - ZEPHIR_CALL_FUNCTION(¶mKeys, "array_unique", &_19, 390, &_67$$30); + ZEPHIR_CALL_FUNCTION(¶mKeys, "array_unique", &_19, 402, &_67$$30); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_68$$30); ZEPHIR_INIT_NVAR(&_68$$30); - zephir_create_closure_ex(&_68$$30, NULL, phalcon_88__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_68$$30, NULL, phalcon_90__closure_ce, SL("__invoke")); ZEPHIR_MAKE_REF(¶mKeys); ZEPHIR_CALL_FUNCTION(NULL, "usort", &_21, 0, ¶mKeys, &_68$$30); ZEPHIR_UNREF(¶mKeys); @@ -4230,7 +4230,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getExpression) } if (ZEPHIR_IS_STRING(&bindType, "array") || ZEPHIR_IS_STRING(&bindType, "array-str") || ZEPHIR_IS_STRING(&bindType, "array-int")) { zephir_memory_observe(&bind); - zephir_read_property_cached(&_58$$52, this_ptr, _zephir_prop_0, 1025, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_58$$52, this_ptr, _zephir_prop_0, 1034, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(!(zephir_array_isset_fetch(&bind, &_58$$52, &name, 0)))) { ZEPHIR_INIT_VAR(&_59$$53); object_init_ex(&_59$$53, phalcon_mvc_model_query_exceptions_bindvaluerequired_ce); @@ -4852,7 +4852,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoinType) ZEPHIR_INIT_VAR(&_1); object_init_ex(&_1, phalcon_mvc_model_query_exceptions_unknownjointype_ce); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 0, &type, &_2); zephir_check_call_status(); zephir_throw_exception_debug(&_1, "phalcon/Mvc/Model/Query.zep", 2561); @@ -5002,17 +5002,17 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoins) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &select_param); zephir_get_arrval(&select, select_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1040, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1049, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&models, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1041, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1050, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlAliases, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1042, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1051, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlAliasesModels, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1043, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1052, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlModelsAliases, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1044, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1053, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlAliasesModelsInstances, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 1039, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 1048, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&modelsInstances, &_0); ZEPHIR_CPY_WRT(&fromModels, &models); ZEPHIR_INIT_VAR(&sqlJoins); @@ -5027,7 +5027,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoins) array_init(&joinPreCondition); ZEPHIR_INIT_VAR(&joinPrepared); array_init(&joinPrepared); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 1034, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 1043, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); zephir_memory_observe(&tables); zephir_array_fetch_string(&tables, &select, SL("tables"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2597); @@ -5076,7 +5076,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoins) if (UNEXPECTED(zephir_array_isset_value(&joinModels, &alias))) { ZEPHIR_INIT_NVAR(&_4$$9); object_init_ex(&_4$$9, phalcon_mvc_model_query_exceptions_joinaliasalreadyused_ce); - zephir_read_property_cached(&_5$$9, this_ptr, _zephir_prop_7, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$9, this_ptr, _zephir_prop_7, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_4$$9, "__construct", &_6, 0, &alias, &_5$$9); zephir_check_call_status(); zephir_throw_exception_debug(&_4$$9, "phalcon/Mvc/Model/Query.zep", 2640); @@ -5097,7 +5097,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoins) if (UNEXPECTED(zephir_array_isset_value(&joinModels, &realModelName))) { ZEPHIR_INIT_NVAR(&_7$$11); object_init_ex(&_7$$11, phalcon_mvc_model_query_exceptions_joinaliasalreadyused_ce); - zephir_read_property_cached(&_8$$11, this_ptr, _zephir_prop_7, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$11, this_ptr, _zephir_prop_7, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_7$$11, "__construct", &_6, 0, &realModelName, &_8$$11); zephir_check_call_status(); zephir_throw_exception_debug(&_7$$11, "phalcon/Mvc/Model/Query.zep", 2697); @@ -5158,7 +5158,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoins) if (UNEXPECTED(zephir_array_isset_value(&joinModels, &alias))) { ZEPHIR_INIT_NVAR(&_12$$14); object_init_ex(&_12$$14, phalcon_mvc_model_query_exceptions_joinaliasalreadyused_ce); - zephir_read_property_cached(&_13$$14, this_ptr, _zephir_prop_7, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$14, this_ptr, _zephir_prop_7, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_12$$14, "__construct", &_6, 0, &alias, &_13$$14); zephir_check_call_status(); zephir_throw_exception_debug(&_12$$14, "phalcon/Mvc/Model/Query.zep", 2640); @@ -5179,7 +5179,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoins) if (UNEXPECTED(zephir_array_isset_value(&joinModels, &realModelName))) { ZEPHIR_INIT_NVAR(&_14$$16); object_init_ex(&_14$$16, phalcon_mvc_model_query_exceptions_joinaliasalreadyused_ce); - zephir_read_property_cached(&_15$$16, this_ptr, _zephir_prop_7, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$16, this_ptr, _zephir_prop_7, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_14$$16, "__construct", &_6, 0, &realModelName, &_15$$16); zephir_check_call_status(); zephir_throw_exception_debug(&_14$$16, "phalcon/Mvc/Model/Query.zep", 2697); @@ -5200,12 +5200,12 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoins) } } ZEPHIR_INIT_NVAR(&joinItem); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1040, &models); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1041, &sqlAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1042, &sqlAliasesModels); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1043, &sqlModelsAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1044, &sqlAliasesModelsInstances); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1039, &modelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1049, &models); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1050, &sqlAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1051, &sqlAliasesModels); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1052, &sqlModelsAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1053, &sqlAliasesModelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1048, &modelsInstances); zephir_is_iterable(&joinPrepared, 0, "phalcon/Mvc/Model/Query.zep", 2772); ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&joinPrepared), _17, _18, _16) { @@ -5226,7 +5226,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoins) } ZEND_HASH_FOREACH_END(); ZEPHIR_INIT_NVAR(&joinItem); ZEPHIR_INIT_NVAR(&joinAliasName); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_8, 1024, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_8, 1033, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_INIT_VAR(&_21$$19); zephir_is_iterable(&joinPrepared, 0, "phalcon/Mvc/Model/Query.zep", 2784); @@ -5339,7 +5339,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoins) if (UNEXPECTED(zephir_fast_count_int(&relations) != 1)) { ZEPHIR_INIT_NVAR(&_43$$28); object_init_ex(&_43$$28, phalcon_mvc_model_query_exceptions_ambiguousjoinrelation_ce); - zephir_read_property_cached(&_44$$28, this_ptr, _zephir_prop_7, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_44$$28, this_ptr, _zephir_prop_7, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_43$$28, "__construct", &_45, 0, &fromModelName, &joinModel, &_44$$28); zephir_check_call_status(); zephir_throw_exception_debug(&_43$$28, "phalcon/Mvc/Model/Query.zep", 2842); @@ -5469,7 +5469,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoins) if (UNEXPECTED(zephir_fast_count_int(&relations) != 1)) { ZEPHIR_INIT_NVAR(&_63$$43); object_init_ex(&_63$$43, phalcon_mvc_model_query_exceptions_ambiguousjoinrelation_ce); - zephir_read_property_cached(&_64$$43, this_ptr, _zephir_prop_7, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_64$$43, this_ptr, _zephir_prop_7, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_63$$43, "__construct", &_45, 0, &fromModelName, &joinModel, &_64$$43); zephir_check_call_status(); zephir_throw_exception_debug(&_63$$43, "phalcon/Mvc/Model/Query.zep", 2842); @@ -5691,7 +5691,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getMultiJoin) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&intermediateModelName, relation, "getintermediatemodel", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1034, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1043, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); ZEPHIR_CALL_METHOD(&intermediateModel, &manager, "load", NULL, 0, &intermediateModelName); zephir_check_call_status(); @@ -5723,7 +5723,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getMultiJoin) if (UNEXPECTED(!(zephir_array_isset_value(&referencedFields, &position)))) { ZEPHIR_INIT_NVAR(&_4$$5); object_init_ex(&_4$$5, phalcon_mvc_model_query_exceptions_joinfieldcountmismatch_ce); - zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_4$$5, "__construct", &_6, 0, &modelAlias_zv, &joinAlias_zv, &_5$$5); zephir_check_call_status(); zephir_throw_exception_debug(&_4$$5, "phalcon/Mvc/Model/Query.zep", 3018); @@ -5776,7 +5776,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getMultiJoin) if (UNEXPECTED(!(zephir_array_isset_value(&referencedFields, &position)))) { ZEPHIR_INIT_NVAR(&_13$$7); object_init_ex(&_13$$7, phalcon_mvc_model_query_exceptions_joinfieldcountmismatch_ce); - zephir_read_property_cached(&_14$$7, this_ptr, _zephir_prop_1, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$7, this_ptr, _zephir_prop_1, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_13$$7, "__construct", &_6, 0, &modelAlias_zv, &joinAlias_zv, &_14$$7); zephir_check_call_status(); zephir_throw_exception_debug(&_13$$7, "phalcon/Mvc/Model/Query.zep", 3018); @@ -6123,11 +6123,11 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) zephir_get_arrval(&expr, expr_param); zephir_memory_observe(&columnName); zephir_array_fetch_string(&columnName, &expr, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3174); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1045, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1054, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&nestingLevel, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1046, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1055, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, &nestingLevel)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1046, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1055, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_2$$3, &_1$$3, &nestingLevel, PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 3182); ZEPHIR_CPY_WRT(&sqlColumnAliases, &_2$$3); } else { @@ -6149,17 +6149,17 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) zephir_array_update_string(return_value, SL("name"), &columnName, PH_COPY | PH_SEPARATE); RETURN_MM(); } - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 1035, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 1044, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&metaData, &_6); zephir_memory_observe(&columnDomain); if (zephir_array_isset_string_fetch(&columnDomain, &expr, SL("domain"), 0)) { - zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_3, 1041, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_3, 1050, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlAliases, &_7$$6); zephir_memory_observe(&source); if (UNEXPECTED(!(zephir_array_isset_fetch(&source, &sqlAliases, &columnDomain, 0)))) { ZEPHIR_INIT_VAR(&_8$$7); object_init_ex(&_8$$7, phalcon_mvc_model_query_exceptions_unknownmodeloralias_ce); - zephir_read_property_cached(&_9$$7, this_ptr, _zephir_prop_4, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$7, this_ptr, _zephir_prop_4, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_10$$7); ZVAL_STRING(&_10$$7, "11"); ZEPHIR_CALL_METHOD(NULL, &_8$$7, "__construct", NULL, 0, &columnDomain, &_10$$7, &_9$$7); @@ -6173,13 +6173,13 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) ZEPHIR_CALL_CE_STATIC(&_11$$6, phalcon_support_settings_ce, "get", NULL, 0, &_12$$6); zephir_check_call_status(); if (zephir_is_true(&_11$$6)) { - zephir_read_property_cached(&_13$$8, this_ptr, _zephir_prop_5, 1044, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$8, this_ptr, _zephir_prop_5, 1053, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlAliasesModelsInstances, &_13$$8); zephir_memory_observe(&model); if (UNEXPECTED(!(zephir_array_isset_fetch(&model, &sqlAliasesModelsInstances, &columnDomain, 0)))) { ZEPHIR_INIT_VAR(&_14$$9); object_init_ex(&_14$$9, phalcon_mvc_model_query_exceptions_nomodelforalias_ce); - zephir_read_property_cached(&_15$$9, this_ptr, _zephir_prop_4, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$9, this_ptr, _zephir_prop_4, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_14$$9, "__construct", NULL, 0, &columnDomain, &_15$$9); zephir_check_call_status(); zephir_throw_exception_debug(&_14$$9, "phalcon/Mvc/Model/Query.zep", 3223); @@ -6197,7 +6197,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) if (UNEXPECTED(!(zephir_array_isset_fetch(&realColumnName, &columnMap, &columnName, 0)))) { ZEPHIR_INIT_VAR(&_16$$12); object_init_ex(&_16$$12, phalcon_mvc_model_query_exceptions_columnnotindomain_ce); - zephir_read_property_cached(&_17$$12, this_ptr, _zephir_prop_4, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$12, this_ptr, _zephir_prop_4, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_16$$12, "__construct", NULL, 0, &columnName, &columnDomain, &_17$$12); zephir_check_call_status(); zephir_throw_exception_debug(&_16$$12, "phalcon/Mvc/Model/Query.zep", 3233); @@ -6211,7 +6211,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) number = 0; ZEPHIR_INIT_VAR(&hasModel); ZVAL_BOOL(&hasModel, 0); - zephir_read_property_cached(&_18$$14, this_ptr, _zephir_prop_6, 1039, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$14, this_ptr, _zephir_prop_6, 1048, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_18$$14, 0, "phalcon/Mvc/Model/Query.zep", 3265); if (Z_TYPE_P(&_18$$14) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_18$$14), _19$$14) @@ -6225,7 +6225,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) if (UNEXPECTED(number > 1)) { ZEPHIR_INIT_NVAR(&_22$$17); object_init_ex(&_22$$17, phalcon_mvc_model_query_exceptions_ambiguouscolumn_ce); - zephir_read_property_cached(&_23$$17, this_ptr, _zephir_prop_4, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$17, this_ptr, _zephir_prop_4, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_22$$17, "__construct", &_24, 0, &columnName, &_23$$17); zephir_check_call_status(); zephir_throw_exception_debug(&_22$$17, "phalcon/Mvc/Model/Query.zep", 3254); @@ -6260,7 +6260,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) if (UNEXPECTED(number > 1)) { ZEPHIR_INIT_NVAR(&_29$$20); object_init_ex(&_29$$20, phalcon_mvc_model_query_exceptions_ambiguouscolumn_ce); - zephir_read_property_cached(&_30$$20, this_ptr, _zephir_prop_4, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_30$$20, this_ptr, _zephir_prop_4, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_29$$20, "__construct", &_24, 0, &columnName, &_30$$20); zephir_check_call_status(); zephir_throw_exception_debug(&_29$$20, "phalcon/Mvc/Model/Query.zep", 3254); @@ -6275,7 +6275,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) if (UNEXPECTED(ZEPHIR_IS_FALSE_IDENTICAL(&hasModel))) { ZEPHIR_INIT_VAR(&_31$$21); object_init_ex(&_31$$21, phalcon_mvc_model_query_exceptions_columnnotinselectedmodels_ce); - zephir_read_property_cached(&_32$$21, this_ptr, _zephir_prop_4, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_32$$21, this_ptr, _zephir_prop_4, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_33$$21); ZVAL_STRING(&_33$$21, "1"); ZEPHIR_CALL_METHOD(NULL, &_31$$21, "__construct", NULL, 0, &columnName, &_33$$21, &_32$$21); @@ -6284,7 +6284,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_34$$14, this_ptr, _zephir_prop_7, 1040, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_34$$14, this_ptr, _zephir_prop_7, 1049, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&models, &_34$$14); if (UNEXPECTED(Z_TYPE_P(&models) != IS_ARRAY)) { ZEPHIR_INIT_VAR(&_35$$22); @@ -6301,7 +6301,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) if (UNEXPECTED(!(zephir_array_isset_fetch(&source, &models, &className, 0)))) { ZEPHIR_INIT_VAR(&_36$$23); object_init_ex(&_36$$23, phalcon_mvc_model_query_exceptions_modelsourcenotfound_ce); - zephir_read_property_cached(&_37$$23, this_ptr, _zephir_prop_4, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_37$$23, this_ptr, _zephir_prop_4, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_36$$23, "__construct", NULL, 0, &className, &_37$$23); zephir_check_call_status(); zephir_throw_exception_debug(&_36$$23, "phalcon/Mvc/Model/Query.zep", 3284); @@ -6324,7 +6324,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) if (UNEXPECTED(!(zephir_array_isset_fetch(&realColumnName, &columnMap, &columnName, 0)))) { ZEPHIR_INIT_VAR(&_40$$27); object_init_ex(&_40$$27, phalcon_mvc_model_query_exceptions_columnnotinselectedmodels_ce); - zephir_read_property_cached(&_41$$27, this_ptr, _zephir_prop_4, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_41$$27, this_ptr, _zephir_prop_4, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_42$$27); ZVAL_STRING(&_42$$27, "3"); ZEPHIR_CALL_METHOD(NULL, &_40$$27, "__construct", NULL, 0, &columnName, &_42$$27, &_41$$27); @@ -6401,7 +6401,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getReadConnection) } ZEPHIR_INIT_VAR(&connection); ZVAL_NULL(&connection); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1037, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1046, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&transaction, &_0); _1 = Z_TYPE_P(&transaction) == IS_OBJECT; if (_1) { @@ -6514,7 +6514,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getRelatedRecords) object_init_ex(&query, phalcon_mvc_model_query_ce); ZEPHIR_CALL_METHOD(NULL, &query, "__construct", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 1029, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 1038, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &query, "setdi", NULL, 0, &_5); zephir_check_call_status(); ZVAL_LONG(&_6, 309); @@ -6621,7 +6621,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getSelectColumn) zephir_memory_observe(&eager); zephir_array_isset_string_fetch(&eager, &column, SL("eager"), 0); if (ZEPHIR_IS_LONG(&columnType, 352)) { - zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_0, 1040, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_0, 1049, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_1$$4, 0, "phalcon/Mvc/Model/Query.zep", 3453); if (Z_TYPE_P(&_1$$4) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_1$$4), _3$$4, _4$$4, _2$$4) @@ -6718,7 +6718,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getSelectColumn) return; } if (ZEPHIR_IS_LONG(&columnType, 353)) { - zephir_read_property_cached(&_18$$10, this_ptr, _zephir_prop_1, 1041, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$10, this_ptr, _zephir_prop_1, 1050, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlAliases, &_18$$10); zephir_memory_observe(&columnDomain); zephir_array_fetch_string(&columnDomain, &column, SL("column"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3469); @@ -6726,7 +6726,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getSelectColumn) if (UNEXPECTED(!(zephir_array_isset_fetch(&source, &sqlAliases, &columnDomain, 0)))) { ZEPHIR_INIT_VAR(&_19$$11); object_init_ex(&_19$$11, phalcon_mvc_model_query_exceptions_unknownmodeloralias_ce); - zephir_read_property_cached(&_20$$11, this_ptr, _zephir_prop_2, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$11, this_ptr, _zephir_prop_2, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_21$$11); ZVAL_STRING(&_21$$11, "2"); ZEPHIR_CALL_METHOD(NULL, &_19$$11, "__construct", NULL, 0, &columnDomain, &_21$$11, &_20$$11); @@ -6738,7 +6738,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getSelectColumn) ZEPHIR_CPY_WRT(&sqlColumnAlias, &source); zephir_memory_observe(&preparedAlias); zephir_array_isset_string_fetch(&preparedAlias, &column, SL("balias"), 0); - zephir_read_property_cached(&_18$$10, this_ptr, _zephir_prop_3, 1042, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$10, this_ptr, _zephir_prop_3, 1051, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlAliasesModels, &_18$$10); ZEPHIR_OBS_NVAR(&modelName); zephir_array_fetch(&modelName, &sqlAliasesModels, &columnDomain, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3486); @@ -6924,7 +6924,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getSingleJoin) if (UNEXPECTED(!(zephir_array_isset_fetch(&referencedField, &referencedFields, &position, 0)))) { ZEPHIR_INIT_NVAR(&_8$$6); object_init_ex(&_8$$6, phalcon_mvc_model_query_exceptions_joinfieldcountmismatch_ce); - zephir_read_property_cached(&_9$$6, this_ptr, _zephir_prop_0, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$6, this_ptr, _zephir_prop_0, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_8$$6, "__construct", &_10, 0, &modelAlias_zv, &joinAlias_zv, &_9$$6); zephir_check_call_status(); zephir_throw_exception_debug(&_8$$6, "phalcon/Mvc/Model/Query.zep", 3607); @@ -6977,7 +6977,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getSingleJoin) if (UNEXPECTED(!(zephir_array_isset_fetch(&referencedField, &referencedFields, &position, 0)))) { ZEPHIR_INIT_NVAR(&_17$$8); object_init_ex(&_17$$8, phalcon_mvc_model_query_exceptions_joinfieldcountmismatch_ce); - zephir_read_property_cached(&_18$$8, this_ptr, _zephir_prop_0, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$8, this_ptr, _zephir_prop_0, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_17$$8, "__construct", &_10, 0, &modelAlias_zv, &joinAlias_zv, &_18$$8); zephir_check_call_status(); zephir_throw_exception_debug(&_17$$8, "phalcon/Mvc/Model/Query.zep", 3607); @@ -7125,7 +7125,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getWriteConnection) } ZEPHIR_INIT_VAR(&connection); ZVAL_NULL(&connection); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1037, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1046, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&transaction, &_0); _1 = Z_TYPE_P(&transaction) == IS_OBJECT; if (_1) { @@ -7229,7 +7229,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareDelete) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1042, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&ast, &_0); zephir_memory_observe(&delete); if (UNEXPECTED(!(zephir_array_isset_string_fetch(&delete, &ast, SL("delete"), 0)))) { @@ -7270,7 +7270,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareDelete) } else { ZEPHIR_CPY_WRT(&deleteTables, &tables); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1034, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1043, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); zephir_is_iterable(&deleteTables, 0, "phalcon/Mvc/Model/Query.zep", 3779); if (Z_TYPE_P(&deleteTables) == IS_ARRAY) { @@ -7377,10 +7377,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareDelete) } } ZEPHIR_INIT_NVAR(&table); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1040, &models); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1039, &modelsInstances); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1041, &sqlAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1044, &sqlAliasesModelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1049, &models); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1048, &modelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1050, &sqlAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1053, &sqlAliasesModelsInstances); ZEPHIR_INIT_VAR(&sqlDelete); array_init(&sqlDelete); zephir_array_update_string(&sqlDelete, SL("tables"), &sqlTables, PH_COPY | PH_SEPARATE); @@ -7471,7 +7471,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareInsert) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1042, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&ast, &_0); if (UNEXPECTED(!(zephir_array_isset_value_string(&ast, SL("qualifiedName"))))) { ZEPHIR_INIT_VAR(&_1$$3); @@ -7502,7 +7502,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareInsert) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1034, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1043, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); zephir_memory_observe(&modelName); zephir_array_fetch_string(&modelName, &qualifiedName, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3828); @@ -7583,7 +7583,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareInsert) zephir_create_array(&sqlInsert, 2, 0); zephir_array_update_string(&sqlInsert, SL("model"), &modelName, PH_COPY | PH_SEPARATE); zephir_array_update_string(&sqlInsert, SL("table"), &source, PH_COPY | PH_SEPARATE); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1035, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1044, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&metaData, &_0); zephir_memory_observe(&fields); if (zephir_array_isset_string_fetch(&fields, &ast, SL("fields"), 0)) { @@ -7602,7 +7602,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareInsert) if (UNEXPECTED(!zephir_is_true(&_19$$10))) { ZEPHIR_INIT_NVAR(&_21$$11); object_init_ex(&_21$$11, phalcon_mvc_model_query_exceptions_missingmodelattribute_ce); - zephir_read_property_cached(&_22$$11, this_ptr, _zephir_prop_3, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$11, this_ptr, _zephir_prop_3, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_21$$11, "__construct", &_23, 0, &modelName, &name, &_22$$11); zephir_check_call_status(); zephir_throw_exception_debug(&_21$$11, "phalcon/Mvc/Model/Query.zep", 3864); @@ -7636,7 +7636,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareInsert) if (UNEXPECTED(!zephir_is_true(&_26$$12))) { ZEPHIR_INIT_NVAR(&_28$$13); object_init_ex(&_28$$13, phalcon_mvc_model_query_exceptions_missingmodelattribute_ce); - zephir_read_property_cached(&_29$$13, this_ptr, _zephir_prop_3, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$13, this_ptr, _zephir_prop_3, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_28$$13, "__construct", &_23, 0, &modelName, &name, &_29$$13); zephir_check_call_status(); zephir_throw_exception_debug(&_28$$13, "phalcon/Mvc/Model/Query.zep", 3864); @@ -7867,7 +7867,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) } else { } if (ZEPHIR_IS_EMPTY(ast)) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1042, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(ast, &_0$$3); } zephir_memory_observe(&select); @@ -7927,9 +7927,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) } else { ZEPHIR_CPY_WRT(&selectColumns, &columns); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 1034, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 1043, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1035, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1044, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&metaData, &_3); if (UNEXPECTED(Z_TYPE_P(&manager) != IS_OBJECT)) { ZEPHIR_INIT_VAR(&_4$$11); @@ -7981,7 +7981,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) if (UNEXPECTED(zephir_array_isset_value(&sqlAliases, &alias))) { ZEPHIR_INIT_NVAR(&_8$$17); object_init_ex(&_8$$17, phalcon_mvc_model_query_exceptions_duplicatealias_ce); - zephir_read_property_cached(&_9$$17, this_ptr, _zephir_prop_3, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$17, this_ptr, _zephir_prop_3, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_8$$17, "__construct", &_10, 0, &alias, &_9$$17); zephir_check_call_status(); zephir_throw_exception_debug(&_8$$17, "phalcon/Mvc/Model/Query.zep", 4012); @@ -8050,7 +8050,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) if (UNEXPECTED(Z_TYPE_P(&relation) != IS_OBJECT)) { ZEPHIR_INIT_NVAR(&_18$$27); object_init_ex(&_18$$27, phalcon_mvc_model_query_exceptions_relationshipnotfound_ce); - zephir_read_property_cached(&_19$$27, this_ptr, _zephir_prop_3, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19$$27, this_ptr, _zephir_prop_3, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_18$$27, "__construct", &_20, 0, &modelName, &relationModel, &_19$$27); zephir_check_call_status(); zephir_throw_exception_debug(&_18$$27, "phalcon/Mvc/Model/Query.zep", 4068); @@ -8132,7 +8132,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) if (UNEXPECTED(Z_TYPE_P(&relation) != IS_OBJECT)) { ZEPHIR_INIT_NVAR(&_32$$31); object_init_ex(&_32$$31, phalcon_mvc_model_query_exceptions_relationshipnotfound_ce); - zephir_read_property_cached(&_33$$31, this_ptr, _zephir_prop_3, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_33$$31, this_ptr, _zephir_prop_3, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_32$$31, "__construct", &_20, 0, &modelName, &relationModel, &_33$$31); zephir_check_call_status(); zephir_throw_exception_debug(&_32$$31, "phalcon/Mvc/Model/Query.zep", 4068); @@ -8221,7 +8221,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) if (UNEXPECTED(zephir_array_isset_value(&sqlAliases, &alias))) { ZEPHIR_INIT_NVAR(&_42$$36); object_init_ex(&_42$$36, phalcon_mvc_model_query_exceptions_duplicatealias_ce); - zephir_read_property_cached(&_43$$36, this_ptr, _zephir_prop_3, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_43$$36, this_ptr, _zephir_prop_3, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_42$$36, "__construct", &_10, 0, &alias, &_43$$36); zephir_check_call_status(); zephir_throw_exception_debug(&_42$$36, "phalcon/Mvc/Model/Query.zep", 4012); @@ -8291,7 +8291,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) if (UNEXPECTED(Z_TYPE_P(&relation) != IS_OBJECT)) { ZEPHIR_INIT_NVAR(&_52$$46); object_init_ex(&_52$$46, phalcon_mvc_model_query_exceptions_relationshipnotfound_ce); - zephir_read_property_cached(&_53$$46, this_ptr, _zephir_prop_3, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_53$$46, this_ptr, _zephir_prop_3, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_52$$46, "__construct", &_20, 0, &modelName, &relationModel, &_53$$46); zephir_check_call_status(); zephir_throw_exception_debug(&_52$$46, "phalcon/Mvc/Model/Query.zep", 4068); @@ -8373,7 +8373,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) if (UNEXPECTED(Z_TYPE_P(&relation) != IS_OBJECT)) { ZEPHIR_INIT_NVAR(&_65$$50); object_init_ex(&_65$$50, phalcon_mvc_model_query_exceptions_relationshipnotfound_ce); - zephir_read_property_cached(&_66$$50, this_ptr, _zephir_prop_3, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_66$$50, this_ptr, _zephir_prop_3, 1032, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_65$$50, "__construct", &_20, 0, &modelName, &relationModel, &_66$$50); zephir_check_call_status(); zephir_throw_exception_debug(&_65$$50, "phalcon/Mvc/Model/Query.zep", 4068); @@ -8423,25 +8423,25 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) } ZEPHIR_INIT_NVAR(&selectedModel); if (!(merge)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1040, &models); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1039, &modelsInstances); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1041, &sqlAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1042, &sqlAliasesModels); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1043, &sqlModelsAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1044, &sqlAliasesModelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1049, &models); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1048, &modelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1050, &sqlAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1051, &sqlAliasesModels); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1052, &sqlModelsAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1053, &sqlAliasesModelsInstances); } else { zephir_memory_observe(&tempModels); - zephir_read_property_cached(&tempModels, this_ptr, _zephir_prop_4, 1040, PH_NOISY_CC); + zephir_read_property_cached(&tempModels, this_ptr, _zephir_prop_4, 1049, PH_NOISY_CC); zephir_memory_observe(&tempModelsInstances); - zephir_read_property_cached(&tempModelsInstances, this_ptr, _zephir_prop_5, 1039, PH_NOISY_CC); + zephir_read_property_cached(&tempModelsInstances, this_ptr, _zephir_prop_5, 1048, PH_NOISY_CC); zephir_memory_observe(&tempSqlAliases); - zephir_read_property_cached(&tempSqlAliases, this_ptr, _zephir_prop_6, 1041, PH_NOISY_CC); + zephir_read_property_cached(&tempSqlAliases, this_ptr, _zephir_prop_6, 1050, PH_NOISY_CC); zephir_memory_observe(&tempSqlAliasesModels); - zephir_read_property_cached(&tempSqlAliasesModels, this_ptr, _zephir_prop_7, 1042, PH_NOISY_CC); + zephir_read_property_cached(&tempSqlAliasesModels, this_ptr, _zephir_prop_7, 1051, PH_NOISY_CC); zephir_memory_observe(&tempSqlModelsAliases); - zephir_read_property_cached(&tempSqlModelsAliases, this_ptr, _zephir_prop_8, 1043, PH_NOISY_CC); + zephir_read_property_cached(&tempSqlModelsAliases, this_ptr, _zephir_prop_8, 1052, PH_NOISY_CC); zephir_memory_observe(&tempSqlAliasesModelsInstances); - zephir_read_property_cached(&tempSqlAliasesModelsInstances, this_ptr, _zephir_prop_9, 1044, PH_NOISY_CC); + zephir_read_property_cached(&tempSqlAliasesModelsInstances, this_ptr, _zephir_prop_9, 1053, PH_NOISY_CC); zephir_is_iterable(&models, 0, "phalcon/Mvc/Model/Query.zep", 4130); ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&models), _72$$52, _73$$52, _71$$52) { @@ -8746,7 +8746,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) } ZEPHIR_INIT_NVAR(&column); zephir_memory_observe(&_114); - zephir_read_property_cached(&_114, this_ptr, _zephir_prop_10, 1045, PH_NOISY_CC); + zephir_read_property_cached(&_114, this_ptr, _zephir_prop_10, 1054, PH_NOISY_CC); zephir_update_property_array(this_ptr, SL("sqlColumnAliases"), &_114, &sqlColumnAliases); ZEPHIR_INIT_VAR(&sqlSelect); zephir_create_array(&sqlSelect, 3, 0); @@ -8794,12 +8794,12 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) zephir_array_update_string(&sqlSelect, SL("forUpdate"), &__$true, PH_COPY | PH_SEPARATE); } if (merge) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1040, &tempModels); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1039, &tempModelsInstances); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1041, &tempSqlAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1042, &tempSqlAliasesModels); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1043, &tempSqlModelsAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1044, &tempSqlAliasesModelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1049, &tempModels); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1048, &tempModelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1050, &tempSqlAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1051, &tempSqlAliasesModels); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1052, &tempSqlModelsAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1053, &tempSqlAliasesModelsInstances); } RETURN_ON_FAILURE(zephir_property_decr(this_ptr, SL("nestingLevel"))); RETURN_CCTOR(&sqlSelect); @@ -8914,7 +8914,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareUpdate) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1042, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&ast, &_0); zephir_memory_observe(&update); if (UNEXPECTED(!(zephir_array_isset_string_fetch(&update, &ast, SL("update"), 0)))) { @@ -8969,7 +8969,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareUpdate) } else { ZEPHIR_CPY_WRT(&updateTables, &tables); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1034, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1043, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); zephir_is_iterable(&updateTables, 0, "phalcon/Mvc/Model/Query.zep", 4368); if (Z_TYPE_P(&updateTables) == IS_ARRAY) { @@ -9084,12 +9084,12 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareUpdate) } } ZEPHIR_INIT_NVAR(&table); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1040, &models); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1039, &modelsInstances); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1041, &sqlAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1042, &sqlAliasesModels); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1043, &sqlModelsAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1044, &sqlAliasesModelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1049, &models); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1048, &modelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1050, &sqlAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1051, &sqlAliasesModels); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1052, &sqlModelsAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1053, &sqlAliasesModelsInstances); ZEPHIR_INIT_VAR(&sqlJoins); array_init(&sqlJoins); zephir_memory_observe(&joins); @@ -9263,7 +9263,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, refreshSchemasInIntermediate) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &irPhql_param); zephir_get_arrval(&irPhql, irPhql_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1034, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1043, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); if (Z_TYPE_P(&manager) != IS_OBJECT) { RETURN_CTOR(&irPhql); diff --git a/ext/phalcon/mvc/model/query/builder.zep.c b/ext/phalcon/mvc/model/query/builder.zep.c index b5e50789f3..90b89f6a00 100644 --- a/ext/phalcon/mvc/model/query/builder.zep.c +++ b/ext/phalcon/mvc/model/query/builder.zep.c @@ -267,11 +267,11 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, __construct) if (Z_TYPE_P(params) == IS_ARRAY) { zephir_memory_observe(&conditions); if (zephir_array_isset_long_fetch(&conditions, params, 0, 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1047, &conditions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1056, &conditions); } else { ZEPHIR_OBS_NVAR(&conditions); if (zephir_array_isset_string_fetch(&conditions, params, SL("conditions"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1047, &conditions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1056, &conditions); } } if (Z_TYPE_P(&conditions) == IS_ARRAY) { @@ -353,33 +353,33 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, __construct) ZEPHIR_INIT_NVAR(&singleConditionArray); ZEPHIR_INIT_VAR(&_7$$7); zephir_fast_join_str(&_7$$7, SL(" AND "), &mergedConditions); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1047, &_7$$7); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1048, &mergedParams); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1049, &mergedTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1056, &_7$$7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1057, &mergedParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1058, &mergedTypes); } zephir_memory_observe(&bind); if (zephir_array_isset_string_fetch(&bind, params, SL("bind"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1048, &bind); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1057, &bind); } zephir_memory_observe(&bindTypes); if (zephir_array_isset_string_fetch(&bindTypes, params, SL("bindTypes"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1049, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1058, &bindTypes); } zephir_memory_observe(&distinct); if (zephir_array_isset_string_fetch(&distinct, params, SL("distinct"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1050, &distinct); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1059, &distinct); } zephir_memory_observe(&fromClause); if (zephir_array_isset_string_fetch(&fromClause, params, SL("models"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1051, &fromClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1060, &fromClause); } zephir_memory_observe(&columns); if (zephir_array_isset_string_fetch(&columns, params, SL("columns"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1052, &columns); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1061, &columns); } zephir_memory_observe(&joinsClause); if (zephir_array_isset_string_fetch(&joinsClause, params, SL("joins"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1053, &joinsClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1062, &joinsClause); } zephir_memory_observe(&groupClause); if (zephir_array_isset_string_fetch(&groupClause, params, SL("group"), 0)) { @@ -388,11 +388,11 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, __construct) } zephir_memory_observe(&havingClause); if (zephir_array_isset_string_fetch(&havingClause, params, SL("having"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1054, &havingClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1063, &havingClause); } zephir_memory_observe(&orderClause); if (zephir_array_isset_string_fetch(&orderClause, params, SL("order"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1055, &orderClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1064, &orderClause); } zephir_memory_observe(&limitClause); if (zephir_array_isset_string_fetch(&limitClause, params, SL("limit"), 0)) { @@ -400,29 +400,29 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, __construct) zephir_memory_observe(&limit); if (zephir_array_isset_long_fetch(&limit, &limitClause, 0, 0)) { if (Z_TYPE_P(&limit) == IS_LONG) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1056, &limit); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1065, &limit); } zephir_memory_observe(&offset); if (zephir_array_isset_long_fetch(&offset, &limitClause, 1, 0)) { if (Z_TYPE_P(&offset) == IS_LONG) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 1057, &offset); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 1066, &offset); } } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1056, &limitClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1065, &limitClause); } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1056, &limitClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1065, &limitClause); } } if (zephir_array_isset_string_fetch(&offsetClause, params, SL("offset"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 1057, &offsetClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 1066, &offsetClause); } if (zephir_array_isset_string_fetch(&forUpdate, params, SL("for_update"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 1058, &forUpdate); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 1067, &forUpdate); } if (zephir_array_isset_string_fetch(&sharedLock, params, SL("shared_lock"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_12, 1059, &sharedLock); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_12, 1068, &sharedLock); } } else { _8$$38 = Z_TYPE_P(params) == IS_STRING; @@ -430,10 +430,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, __construct) _8$$38 = !ZEPHIR_IS_STRING_IDENTICAL(params, ""); } if (_8$$38) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1047, params); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1056, params); } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 1060, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 1069, container); ZEPHIR_MM_RESTORE(); } @@ -488,7 +488,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, addFrom) zephir_memory_observe(&alias_zv); ZVAL_STR_COPY(&alias_zv, alias); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1051, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1060, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&models, &_0); if (Z_TYPE_P(&models) != IS_ARRAY) { if (Z_TYPE_P(&models) != IS_NULL) { @@ -511,7 +511,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, addFrom) } else { zephir_array_append(&models, &model_zv, PH_SEPARATE, "phalcon/Mvc/Model/Query/Builder.zep", 354); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1051, &models); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1060, &models); RETURN_THIS(); } @@ -571,7 +571,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, andHaving) zephir_get_arrval(&bindTypes, bindTypes_param); } zephir_memory_observe(¤tConditions); - zephir_read_property_cached(¤tConditions, this_ptr, _zephir_prop_0, 1054, PH_NOISY_CC); + zephir_read_property_cached(¤tConditions, this_ptr, _zephir_prop_0, 1063, PH_NOISY_CC); if (zephir_is_true(¤tConditions)) { ZEPHIR_INIT_VAR(&_0$$3); ZEPHIR_CONCAT_SVSVS(&_0$$3, "(", ¤tConditions, ") AND (", &conditions, ")"); @@ -639,7 +639,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, andWhere) zephir_get_arrval(&bindTypes, bindTypes_param); } zephir_memory_observe(¤tConditions); - zephir_read_property_cached(¤tConditions, this_ptr, _zephir_prop_0, 1047, PH_NOISY_CC); + zephir_read_property_cached(¤tConditions, this_ptr, _zephir_prop_0, 1056, PH_NOISY_CC); if (zephir_is_true(¤tConditions)) { ZEPHIR_INIT_VAR(&_0$$3); ZEPHIR_CONCAT_SVSVS(&_0$$3, "(", ¤tConditions, ") AND (", &conditions, ")"); @@ -845,7 +845,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, columns) Z_PARAM_ZVAL(columns) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &columns); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1052, columns); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1061, columns); RETURN_THISW(); } @@ -872,7 +872,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, distinct) Z_PARAM_ZVAL(distinct) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &distinct); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1050, distinct); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1059, distinct); RETURN_THISW(); } @@ -901,9 +901,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, forUpdate) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &forUpdate_param); if (forUpdate) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1058, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1067, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1058, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1067, &__$false); } RETURN_THISW(); } @@ -946,7 +946,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, from) Z_PARAM_ZVAL(models) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &models); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1051, models); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1060, models); RETURN_THISW(); } @@ -1066,7 +1066,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getModels) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1051, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1060, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&models, &_0); _1 = Z_TYPE_P(&models) == IS_ARRAY; if (_1) { @@ -1309,14 +1309,14 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1060, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1069, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (Z_TYPE_P(&container) != IS_OBJECT) { ZEPHIR_CALL_CE_STATIC(&container, phalcon_di_di_ce, "getdefault", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1060, &container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1069, &container); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1051, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1060, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&models, &_0); if (Z_TYPE_P(&models) == IS_ARRAY) { if (UNEXPECTED(!(zephir_fast_count_int(&models)))) { @@ -1339,7 +1339,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) return; } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1047, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1056, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&conditions, &_0); if (zephir_is_numeric(&conditions)) { if (Z_TYPE_P(&models) == IS_ARRAY) { @@ -1421,7 +1421,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) return; } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1050, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1059, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&distinct, &_0); if (((Z_TYPE_P(&distinct) == IS_TRUE || Z_TYPE_P(&distinct) == IS_FALSE) == 1)) { ZEPHIR_INIT_VAR(&phql); @@ -1434,7 +1434,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) ZEPHIR_INIT_NVAR(&phql); ZVAL_STRING(&phql, "SELECT "); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1052, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1061, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&columns, &_0); if (Z_TYPE_P(&columns) != IS_NULL) { if (Z_TYPE_P(&columns) == IS_ARRAY) { @@ -1651,7 +1651,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) ZEPHIR_CONCAT_SV(&_46$$49, " FROM ", &_45$$49); zephir_concat_self(&phql, &_46$$49); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 1053, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 1062, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&joins, &_0); if (Z_TYPE_P(&joins) == IS_ARRAY) { zephir_is_iterable(&joins, 0, "phalcon/Mvc/Model/Query/Builder.zep", 920); @@ -1756,7 +1756,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) zephir_concat_self(&phql, &_64$$62); } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 1061, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 1070, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&group, &_0); if (!(ZEPHIR_IS_EMPTY(&group))) { ZEPHIR_INIT_VAR(&groupItems); @@ -1801,7 +1801,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) ZEPHIR_CONCAT_SV(&_71$$63, " GROUP BY ", &_70$$63); zephir_concat_self(&phql, &_71$$63); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_7, 1054, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_7, 1063, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&having, &_0); if (Z_TYPE_P(&having) != IS_NULL) { if (!(ZEPHIR_IS_EMPTY(&having))) { @@ -1810,7 +1810,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) zephir_concat_self(&phql, &_72$$67); } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_8, 1055, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_8, 1064, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&order, &_0); if (Z_TYPE_P(&order) != IS_NULL) { if (Z_TYPE_P(&order) == IS_ARRAY) { @@ -1963,7 +1963,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) zephir_concat_self(&phql, &_104$$82); } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_9, 1056, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_9, 1065, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&limit, &_0); if (Z_TYPE_P(&limit) != IS_NULL) { ZEPHIR_INIT_VAR(&number); @@ -1981,7 +1981,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) } else { if (zephir_is_numeric(&limit)) { ZEPHIR_CPY_WRT(&number, &limit); - zephir_read_property_cached(&_105$$88, this_ptr, _zephir_prop_10, 1057, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_105$$88, this_ptr, _zephir_prop_10, 1066, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&offset, &_105$$88); if (Z_TYPE_P(&offset) != IS_NULL) { if (!(zephir_is_numeric(&offset))) { @@ -2024,7 +2024,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) } } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_11, 1058, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_11, 1067, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&forUpdate, &_0); if (((Z_TYPE_P(&forUpdate) == IS_TRUE || Z_TYPE_P(&forUpdate) == IS_FALSE) == 1)) { if (zephir_is_true(&forUpdate)) { @@ -2084,7 +2084,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getQuery) ZEPHIR_CALL_METHOD(&phql, this_ptr, "getphql", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1060, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1069, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (UNEXPECTED(Z_TYPE_P(&container) != IS_OBJECT)) { ZEPHIR_INIT_VAR(&_1$$3); @@ -2104,32 +2104,32 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getQuery) ZEPHIR_CALL_METHOD(&_2, &container, "get", NULL, 0, &_4, &_3); zephir_check_call_status(); ZEPHIR_CPY_WRT(&query, &_2); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1048, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1057, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&bindParams, &_0); if (Z_TYPE_P(&bindParams) == IS_ARRAY) { ZEPHIR_CALL_METHOD(NULL, &query, "setbindparams", NULL, 0, &bindParams); zephir_check_call_status(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1049, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1058, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&bindTypes, &_0); if (Z_TYPE_P(&bindTypes) == IS_ARRAY) { ZEPHIR_CALL_METHOD(NULL, &query, "setbindtypes", NULL, 0, &bindTypes); zephir_check_call_status(); } zephir_memory_observe(&_5); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_3, 1059, PH_NOISY_CC); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_3, 1068, PH_NOISY_CC); if (((Z_TYPE_P(&_5) == IS_TRUE || Z_TYPE_P(&_5) == IS_FALSE) == 1)) { - zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_3, 1059, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_3, 1068, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &query, "setsharedlock", NULL, 0, &_6$$6); zephir_check_call_status(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1062, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1071, PH_NOISY_CC | PH_READONLY); _7 = !ZEPHIR_IS_STRING(&_0, ""); if (_7) { _7 = (zephir_method_exists_ex(&query, ZEND_STRL("setresultsetrowclass")) == SUCCESS); } if (_7) { - zephir_read_property_cached(&_8$$7, this_ptr, _zephir_prop_4, 1062, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$7, this_ptr, _zephir_prop_4, 1071, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &query, "setresultsetrowclass", NULL, 0, &_8$$7); zephir_check_call_status(); } @@ -2208,7 +2208,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, groupBy) zephir_fast_explode_str(&_3$$3, SL(","), group, LONG_MAX); ZEPHIR_CPY_WRT(group, &_3$$3); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1061, group); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1070, group); RETURN_THIS(); } @@ -2282,24 +2282,24 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, having) } else { zephir_get_arrval(&bindTypes, bindTypes_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1054, &conditions_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1063, &conditions_zv); zephir_memory_observe(¤tBindParams); - zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_1, 1048, PH_NOISY_CC); + zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_1, 1057, PH_NOISY_CC); if (Z_TYPE_P(¤tBindParams) == IS_ARRAY) { ZEPHIR_INIT_VAR(&_0$$3); zephir_add_function(&_0$$3, ¤tBindParams, &bindParams); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1048, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1057, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1048, &bindParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1057, &bindParams); } zephir_memory_observe(¤tBindTypes); - zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_2, 1049, PH_NOISY_CC); + zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_2, 1058, PH_NOISY_CC); if (Z_TYPE_P(¤tBindTypes) == IS_ARRAY) { ZEPHIR_INIT_VAR(&_1$$5); zephir_add_function(&_1$$5, ¤tBindTypes, &bindTypes); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1049, &_1$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1058, &_1$$5); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1049, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1058, &bindTypes); } RETURN_THIS(); } @@ -2672,12 +2672,12 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, limit) } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, limit); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1056, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1065, &_0); if (zephir_is_numeric(offset)) { ZVAL_LONG(&_2$$4, zephir_get_intval(offset)); ZEPHIR_CALL_FUNCTION(&_3$$4, "abs", NULL, 0, &_2$$4); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1057, &_3$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1066, &_3$$4); } RETURN_THIS(); } @@ -2905,7 +2905,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, offset) zephir_fetch_params_without_memory_grow(1, 0, &offset_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, offset); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1057, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1066, &_0); RETURN_THISW(); } @@ -2965,7 +2965,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, orHaving) zephir_get_arrval(&bindTypes, bindTypes_param); } zephir_memory_observe(¤tConditions); - zephir_read_property_cached(¤tConditions, this_ptr, _zephir_prop_0, 1054, PH_NOISY_CC); + zephir_read_property_cached(¤tConditions, this_ptr, _zephir_prop_0, 1063, PH_NOISY_CC); if (zephir_is_true(¤tConditions)) { ZEPHIR_INIT_VAR(&_0$$3); ZEPHIR_CONCAT_SVSVS(&_0$$3, "(", ¤tConditions, ") OR (", &conditions, ")"); @@ -3033,7 +3033,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, orWhere) zephir_get_arrval(&bindTypes, bindTypes_param); } zephir_memory_observe(¤tConditions); - zephir_read_property_cached(¤tConditions, this_ptr, _zephir_prop_0, 1047, PH_NOISY_CC); + zephir_read_property_cached(¤tConditions, this_ptr, _zephir_prop_0, 1056, PH_NOISY_CC); if (zephir_is_true(¤tConditions)) { ZEPHIR_INIT_VAR(&_0$$3); ZEPHIR_CONCAT_SVSVS(&_0$$3, "(", ¤tConditions, ") OR (", &conditions, ")"); @@ -3070,7 +3070,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, orderBy) Z_PARAM_ZVAL(orderBy) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &orderBy); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1055, orderBy); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1064, orderBy); RETURN_THISW(); } @@ -3167,16 +3167,16 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, setBindParams) } if (merge) { zephir_memory_observe(¤tBindParams); - zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_0, 1048, PH_NOISY_CC); + zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_0, 1057, PH_NOISY_CC); if (Z_TYPE_P(¤tBindParams) == IS_ARRAY) { ZEPHIR_INIT_VAR(&_0$$4); zephir_add_function(&_0$$4, ¤tBindParams, &bindParams); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1048, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1057, &_0$$4); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1048, &bindParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1057, &bindParams); } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1048, &bindParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1057, &bindParams); } RETURN_THIS(); } @@ -3215,16 +3215,16 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, setBindTypes) } if (UNEXPECTED(merge)) { zephir_memory_observe(¤tBindTypes); - zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_0, 1049, PH_NOISY_CC); + zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_0, 1058, PH_NOISY_CC); if (Z_TYPE_P(¤tBindTypes) == IS_ARRAY) { ZEPHIR_INIT_VAR(&_0$$4); zephir_add_function(&_0$$4, ¤tBindTypes, &bindTypes); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1049, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1058, &_0$$4); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1049, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1058, &bindTypes); } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1049, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1058, &bindTypes); } RETURN_THIS(); } @@ -3247,7 +3247,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, setDI) Z_PARAM_OBJECT_OF_CLASS(container, phalcon_di_diinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &container); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1060, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1069, container); } /** @@ -3272,7 +3272,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, setResultsetRowClass) Z_PARAM_STR(resultsetRowClass) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&resultsetRowClass_zv, resultsetRowClass); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1062, &resultsetRowClass_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1071, &resultsetRowClass_zv); RETURN_THISW(); } @@ -3349,26 +3349,26 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, where) } else { zephir_get_arrval(&bindTypes, bindTypes_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1047, &conditions_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1056, &conditions_zv); if (zephir_fast_count_int(&bindParams) > 0) { zephir_memory_observe(¤tBindParams); - zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_1, 1048, PH_NOISY_CC); + zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_1, 1057, PH_NOISY_CC); if (Z_TYPE_P(¤tBindParams) == IS_ARRAY) { ZEPHIR_INIT_VAR(&_0$$4); zephir_add_function(&_0$$4, ¤tBindParams, &bindParams); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1048, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1057, &_0$$4); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1048, &bindParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1057, &bindParams); } } if (zephir_fast_count_int(&bindTypes) > 0) { - zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_2, 1049, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_2, 1058, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(¤tBindTypes) == IS_ARRAY) { ZEPHIR_INIT_VAR(&_1$$7); zephir_add_function(&_1$$7, ¤tBindTypes, &bindTypes); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1049, &_1$$7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1058, &_1$$7); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1049, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1058, &bindTypes); } } RETURN_THIS(); @@ -3441,7 +3441,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, conditionBetween) ZEPHIR_CONCAT_VV(&_2, &operator_zv, &clause_zv); ZEPHIR_CPY_WRT(&operatorMethod, &_2); zephir_memory_observe(&hiddenParam); - zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 1063, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 1072, PH_NOISY_CC); ZEPHIR_INIT_VAR(&nextHiddenParam); ZVAL_LONG(&nextHiddenParam, (zephir_get_numberval(&hiddenParam) + 1)); ZEPHIR_INIT_VAR(&minimumKey); @@ -3458,7 +3458,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, conditionBetween) zephir_check_call_status(); SEPARATE_ZVAL(&nextHiddenParam); zephir_increment(&nextHiddenParam); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1063, &nextHiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1072, &nextHiddenParam); RETURN_THIS(); } @@ -3543,7 +3543,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, conditionIn) RETURN_THIS(); } zephir_memory_observe(&_4); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 1063, PH_NOISY_CC); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 1072, PH_NOISY_CC); hiddenParam = zephir_get_intval(&_4); ZEPHIR_INIT_VAR(&bindParams); array_init(&bindParams); @@ -3605,7 +3605,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, conditionIn) zephir_check_call_status(); ZVAL_UNDEF(&_14); ZVAL_LONG(&_14, hiddenParam); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1063, &_14); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1072, &_14); RETURN_THIS(); } @@ -3676,7 +3676,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, conditionNotBetween) ZEPHIR_CONCAT_VV(&_2, &operator_zv, &clause_zv); ZEPHIR_CPY_WRT(&operatorMethod, &_2); zephir_memory_observe(&hiddenParam); - zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 1063, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 1072, PH_NOISY_CC); ZEPHIR_INIT_VAR(&nextHiddenParam); ZVAL_LONG(&nextHiddenParam, (zephir_get_numberval(&hiddenParam) + 1)); ZEPHIR_INIT_VAR(&minimumKey); @@ -3693,7 +3693,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, conditionNotBetween) zephir_check_call_status(); SEPARATE_ZVAL(&nextHiddenParam); zephir_increment(&nextHiddenParam); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1063, &nextHiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1072, &nextHiddenParam); RETURN_THIS(); } @@ -3778,7 +3778,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, conditionNotIn) RETURN_THIS(); } zephir_memory_observe(&_4); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 1063, PH_NOISY_CC); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 1072, PH_NOISY_CC); hiddenParam = zephir_get_intval(&_4); ZEPHIR_INIT_VAR(&bindParams); array_init(&bindParams); @@ -3840,7 +3840,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, conditionNotIn) zephir_check_call_status(); ZVAL_UNDEF(&_14); ZVAL_LONG(&_14, hiddenParam); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1063, &_14); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1072, &_14); RETURN_THIS(); } diff --git a/ext/phalcon/mvc/model/query/status.zep.c b/ext/phalcon/mvc/model/query/status.zep.c index d7eda0db2e..def0e3759d 100644 --- a/ext/phalcon/mvc/model/query/status.zep.c +++ b/ext/phalcon/mvc/model/query/status.zep.c @@ -101,11 +101,11 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Status, __construct) model = &__$null; } if (success) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1064, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1073, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1064, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1073, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1065, model); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1074, model); } /** @@ -127,7 +127,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Status, getMessages) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1065, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1074, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&model, &_0); if (Z_TYPE_P(&model) != IS_OBJECT) { array_init(return_value); diff --git a/ext/phalcon/mvc/model/relation.zep.c b/ext/phalcon/mvc/model/relation.zep.c index 11e9d37e9a..7f097fa1f0 100644 --- a/ext/phalcon/mvc/model/relation.zep.c +++ b/ext/phalcon/mvc/model/relation.zep.c @@ -182,11 +182,11 @@ PHP_METHOD(Phalcon_Mvc_Model_Relation, __construct) } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, type); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1066, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1067, &referencedModel_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1068, fields); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1069, referencedFields); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1070, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1075, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1076, &referencedModel_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1077, fields); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1078, referencedFields); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1079, &options); ZEPHIR_MM_RESTORE(); } @@ -222,7 +222,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Relation, getForeignKey) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1070, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1079, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); zephir_memory_observe(&foreignKey); if (zephir_array_isset_string_fetch(&foreignKey, &options, SL("foreignKey"), 0)) { @@ -291,7 +291,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Relation, getOption) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); zephir_memory_observe(&option); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1070, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1079, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&option, &_0, &name_zv, 0))) { RETURN_MM_NULL(); } @@ -329,7 +329,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Relation, getParams) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1070, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1079, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); zephir_memory_observe(¶ms); if (zephir_array_isset_string_fetch(¶ms, &options, SL("params"), 0)) { @@ -393,7 +393,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Relation, isForeignKey) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&foreignKey); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1070, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1079, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_string_fetch(&foreignKey, &_0, SL("foreignKey"), 0))) { RETURN_MM_BOOL(0); } @@ -419,7 +419,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Relation, isThrough) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1066, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1075, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&type, &_0); _1 = ZEPHIR_IS_LONG(&type, 3); if (!(_1)) { @@ -447,7 +447,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Relation, isReusable) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1070, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1079, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); zephir_memory_observe(&reusable); if (!(zephir_array_isset_string_fetch(&reusable, &options, SL("reusable"), 0))) { @@ -493,9 +493,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Relation, setIntermediateRelation) intermediateFields = ZEND_CALL_ARG(execute_data, 1); intermediateReferencedFields = ZEND_CALL_ARG(execute_data, 3); ZVAL_STR(&intermediateModel_zv, intermediateModel); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1071, intermediateFields); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1072, &intermediateModel_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1073, intermediateReferencedFields); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1080, intermediateFields); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1081, &intermediateModel_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1082, intermediateReferencedFields); } zend_object *zephir_init_properties_Phalcon_Mvc_Model_Relation(zend_class_entry *class_type) diff --git a/ext/phalcon/mvc/model/resultset/complex.zep.c b/ext/phalcon/mvc/model/resultset/complex.zep.c index dfb0205d8c..d20b4dfb64 100644 --- a/ext/phalcon/mvc/model/resultset/complex.zep.c +++ b/ext/phalcon/mvc/model/resultset/complex.zep.c @@ -124,8 +124,8 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, __construct) zephir_memory_observe(&resultsetRowClass_zv); ZVAL_STR_COPY(&resultsetRowClass_zv, resultsetRowClass); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1074, columnTypes); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1075, &resultsetRowClass_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1083, columnTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1084, &resultsetRowClass_zv); ZEPHIR_CALL_PARENT(NULL, phalcon_mvc_model_resultset_complex_ce, getThis(), "__construct", NULL, 0, result, cache); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -160,11 +160,11 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, __serialize) ZEPHIR_CALL_METHOD(&records, this_ptr, "toarray", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1076, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1085, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cache, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1074, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1083, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&columnTypes, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1077, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1086, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&hydrateMode, &_0); zephir_create_array(return_value, 4, 0); zephir_array_update_string(return_value, SL("cache"), &cache, PH_COPY | PH_SEPARATE); @@ -223,22 +223,22 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, __unserialize) zephir_fetch_params(1, 1, 0, &data_param); zephir_get_arrval(&data, data_param); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1078, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1087, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1078, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1087, &__$false); } zephir_array_fetch_string(&_0, &data, SL("rows"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Complex.zep", 111); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1079, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1088, &_0); zephir_array_fetch_string(&_1, &data, SL("rows"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Complex.zep", 112); ZVAL_UNDEF(&_2); ZVAL_LONG(&_2, zephir_fast_count_int(&_1)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1080, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1089, &_2); zephir_array_fetch_string(&_3, &data, SL("cache"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Complex.zep", 113); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1076, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1085, &_3); zephir_array_fetch_string(&_4, &data, SL("columnTypes"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Complex.zep", 114); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1074, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1083, &_4); zephir_array_fetch_string(&_5, &data, SL("hydrateMode"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Complex.zep", 115); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1077, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1086, &_5); ZEPHIR_MM_RESTORE(); } @@ -340,33 +340,33 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, current) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1081, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1090, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&activeRow, &_0); if (Z_TYPE_P(&activeRow) != IS_NULL) { RETURN_CCTOR(&activeRow); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1082, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1091, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&row, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1078, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1087, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1081, &row); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1090, &row); RETURN_CCTOR(&row); } if (Z_TYPE_P(&row) != IS_ARRAY) { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1081, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1090, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1081, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1090, &__$false); } RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1077, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1086, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&hydrateMode, &_1); do { if (ZEPHIR_IS_LONG(&hydrateMode, 0)) { - zephir_read_property_cached(&_2$$6, this_ptr, _zephir_prop_4, 1075, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$6, this_ptr, _zephir_prop_4, 1084, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_STRING_IDENTICAL(&_2$$6, "")) { - zephir_read_property_cached(&_3$$7, this_ptr, _zephir_prop_4, 1075, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$7, this_ptr, _zephir_prop_4, 1084, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&activeRow); ZEPHIR_LAST_CALL_STATUS = zephir_create_instance(&activeRow, &_3$$7); zephir_check_call_status(); @@ -392,7 +392,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, current) } while(0); dirtyState = 0; - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_5, 1074, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_5, 1083, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_1, 0, "phalcon/Mvc/Model/Resultset/Complex.zep", 337); if (Z_TYPE_P(&_1) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_1), _5, _6, _4) @@ -743,7 +743,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, current) } ZEPHIR_INIT_NVAR(&column); ZEPHIR_INIT_NVAR(&alias); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1081, &activeRow); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1090, &activeRow); RETURN_CCTOR(&activeRow); } @@ -797,16 +797,16 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, serialize) ZEPHIR_INIT_VAR(&data); zephir_create_array(&data, 4, 0); zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1076, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1085, PH_NOISY_CC); zephir_array_update_string(&data, SL("cache"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(&_2, this_ptr, "toarray", NULL, 0); zephir_check_call_status(); zephir_array_update_string(&data, SL("rows"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1074, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1083, PH_NOISY_CC); zephir_array_update_string(&data, SL("columnTypes"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1077, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1086, PH_NOISY_CC); zephir_array_update_string(&data, SL("hydrateMode"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_VAR(&_3); ZVAL_STRING(&_3, "serializer"); @@ -927,9 +927,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, unserialize) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &data); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1078, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1087, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1078, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1087, &__$false); } ZEPHIR_CALL_CE_STATIC(&container, phalcon_di_di_ce, "getdefault", NULL, 0); zephir_check_call_status(); @@ -970,17 +970,17 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, unserialize) return; } zephir_array_fetch_string(&_6, &resultset, SL("rows"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Complex.zep", 426); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1079, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1088, &_6); zephir_array_fetch_string(&_7, &resultset, SL("rows"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Complex.zep", 427); ZVAL_UNDEF(&_8); ZVAL_LONG(&_8, zephir_fast_count_int(&_7)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1080, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1089, &_8); zephir_array_fetch_string(&_9, &resultset, SL("cache"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Complex.zep", 428); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1076, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1085, &_9); zephir_array_fetch_string(&_10, &resultset, SL("columnTypes"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Complex.zep", 429); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1074, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1083, &_10); zephir_array_fetch_string(&_11, &resultset, SL("hydrateMode"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Complex.zep", 430); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1077, &_11); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1086, &_11); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/mvc/model/resultset/simple.zep.c b/ext/phalcon/mvc/model/resultset/simple.zep.c index e8d73adb2e..43c280b621 100644 --- a/ext/phalcon/mvc/model/resultset/simple.zep.c +++ b/ext/phalcon/mvc/model/resultset/simple.zep.c @@ -113,12 +113,12 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, __construct) keepSnapshots = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1083, model); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1084, columnMap); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1092, model); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1093, columnMap); if (keepSnapshots) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1085, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1094, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1085, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1094, &__$false); } ZEPHIR_CALL_PARENT(NULL, phalcon_mvc_model_resultset_simple_ce, getThis(), "__construct", NULL, 0, result, cache); zephir_check_call_status(); @@ -160,23 +160,23 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, __serialize) zephir_create_array(return_value, 6, 0); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1083, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1092, PH_NOISY_CC); zephir_array_update_string(return_value, SL("model"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1086, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1095, PH_NOISY_CC); zephir_array_update_string(return_value, SL("cache"), &_0, PH_COPY | PH_SEPARATE); ZVAL_BOOL(&_2, 0); ZEPHIR_CALL_METHOD(&_1, this_ptr, "toarray", NULL, 0, &_2); zephir_check_call_status(); zephir_array_update_string(return_value, SL("rows"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1084, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1093, PH_NOISY_CC); zephir_array_update_string(return_value, SL("columnMap"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1087, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1096, PH_NOISY_CC); zephir_array_update_string(return_value, SL("hydrateMode"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1085, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1094, PH_NOISY_CC); zephir_array_update_string(return_value, SL("keepSnapshots"), &_0, PH_COPY | PH_SEPARATE); RETURN_MM(); } @@ -234,21 +234,21 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, __unserialize) zephir_fetch_params(1, 1, 0, &data_param); zephir_get_arrval(&data, data_param); zephir_array_fetch_string(&_0, &data, SL("model"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Simple.zep", 95); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1083, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1092, &_0); zephir_array_fetch_string(&_1, &data, SL("rows"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Simple.zep", 96); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1088, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1097, &_1); zephir_array_fetch_string(&_2, &data, SL("rows"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Simple.zep", 97); ZVAL_UNDEF(&_3); ZVAL_LONG(&_3, zephir_fast_count_int(&_2)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1089, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1098, &_3); zephir_array_fetch_string(&_4, &data, SL("cache"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Simple.zep", 98); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1086, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1095, &_4); zephir_array_fetch_string(&_5, &data, SL("columnMap"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Simple.zep", 99); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1084, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1093, &_5); zephir_array_fetch_string(&_6, &data, SL("hydrateMode"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Simple.zep", 100); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1087, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1096, &_6); if (zephir_array_isset_string_fetch(&keepSnapshots, &data, SL("keepSnapshots"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1085, &keepSnapshots); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1094, &keepSnapshots); } ZEPHIR_MM_RESTORE(); } @@ -310,24 +310,24 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, current) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1090, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1099, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&activeRow, &_0); if (Z_TYPE_P(&activeRow) != IS_NULL) { RETURN_CCTOR(&activeRow); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1091, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1100, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&row, &_0); if (Z_TYPE_P(&row) != IS_ARRAY) { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1090, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1099, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1090, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1099, &__$false); } RETURN_MM_NULL(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1087, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1096, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&hydrateMode, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1084, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1093, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&columnMap, &_0); do { if (ZEPHIR_IS_LONG(&hydrateMode, 0)) { @@ -337,24 +337,24 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, current) zephir_check_call_status(); if (zephir_is_true(&_1$$5)) { zephir_memory_observe(&_3$$6); - zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_4, 1083, PH_NOISY_CC); + zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_4, 1092, PH_NOISY_CC); if (zephir_instance_of_ev(&_3$$6, phalcon_mvc_model_ce)) { - zephir_read_property_cached(&_4$$7, this_ptr, _zephir_prop_4, 1083, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$7, this_ptr, _zephir_prop_4, 1092, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&modelName); zephir_get_class(&modelName, &_4$$7, 0); } else { ZEPHIR_INIT_NVAR(&modelName); ZVAL_STRING(&modelName, "Phalcon\\Mvc\\Model"); } - zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_4, 1083, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_5, 1085, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_4, 1092, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_5, 1094, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_7$$6, 0); _8$$6 = zephir_fetch_class(&modelName); ZEPHIR_CALL_CE_STATIC(&activeRow, _8$$6, "cloneresultmap", NULL, 0, &_5$$6, &row, &columnMap, &_7$$6, &_6$$6); zephir_check_call_status(); } else { - zephir_read_property_cached(&_9$$9, this_ptr, _zephir_prop_4, 1083, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_10$$9, this_ptr, _zephir_prop_5, 1085, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$9, this_ptr, _zephir_prop_4, 1092, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$9, this_ptr, _zephir_prop_5, 1094, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_11$$9, 0); ZEPHIR_CALL_CE_STATIC(&activeRow, phalcon_mvc_model_ce, "cloneresultmap", NULL, 0, &_9$$9, &row, &columnMap, &_11$$9, &_10$$9); zephir_check_call_status(); @@ -366,7 +366,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, current) break; } while(0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1090, &activeRow); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1099, &activeRow); RETURN_CCTOR(&activeRow); } @@ -428,23 +428,23 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, serialize) ZEPHIR_INIT_VAR(&data); zephir_create_array(&data, 6, 0); zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1083, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1092, PH_NOISY_CC); zephir_array_update_string(&data, SL("model"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1086, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1095, PH_NOISY_CC); zephir_array_update_string(&data, SL("cache"), &_1, PH_COPY | PH_SEPARATE); ZVAL_BOOL(&_3, 0); ZEPHIR_CALL_METHOD(&_2, this_ptr, "toarray", NULL, 0, &_3); zephir_check_call_status(); zephir_array_update_string(&data, SL("rows"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1084, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1093, PH_NOISY_CC); zephir_array_update_string(&data, SL("columnMap"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1087, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1096, PH_NOISY_CC); zephir_array_update_string(&data, SL("hydrateMode"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_4, 1085, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_4, 1094, PH_NOISY_CC); zephir_array_update_string(&data, SL("keepSnapshots"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_VAR(&_4); ZVAL_STRING(&_4, "serializer"); @@ -542,28 +542,28 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, toArray) } else { } zephir_memory_observe(&records); - zephir_read_property_cached(&records, this_ptr, _zephir_prop_0, 1088, PH_NOISY_CC); + zephir_read_property_cached(&records, this_ptr, _zephir_prop_0, 1097, PH_NOISY_CC); if (Z_TYPE_P(&records) != IS_ARRAY) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_1, 1092, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_1, 1101, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&result, &_0$$3); - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_2, 1091, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_2, 1100, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0$$3) != IS_NULL) { ZEPHIR_CALL_METHOD(NULL, &result, "execute", NULL, 0); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(&records, &result, "fetchall", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1091, &__$null); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1088, &records); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1100, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1097, &records); } _1 = renameColumns; if (_1) { zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_3, 1083, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_3, 1092, PH_NOISY_CC); _1 = !(zephir_instance_of_ev(&_2, phalcon_mvc_model_row_ce)); } if (_1) { - zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_4, 1084, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_4, 1093, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&columnMap, &_3$$5); if (Z_TYPE_P(&columnMap) != IS_ARRAY) { RETURN_CCTOR(&records); @@ -888,21 +888,21 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, unserialize) return; } zephir_array_fetch_string(&_6, &resultset, SL("model"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Simple.zep", 343); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1083, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1092, &_6); zephir_array_fetch_string(&_7, &resultset, SL("rows"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Simple.zep", 344); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1088, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1097, &_7); zephir_array_fetch_string(&_8, &resultset, SL("rows"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Simple.zep", 345); ZVAL_UNDEF(&_9); ZVAL_LONG(&_9, zephir_fast_count_int(&_8)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1089, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1098, &_9); zephir_array_fetch_string(&_10, &resultset, SL("cache"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Simple.zep", 346); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1086, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1095, &_10); zephir_array_fetch_string(&_11, &resultset, SL("columnMap"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Simple.zep", 347); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1084, &_11); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1093, &_11); zephir_array_fetch_string(&_12, &resultset, SL("hydrateMode"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Simple.zep", 348); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1087, &_12); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1096, &_12); if (zephir_array_isset_string_fetch(&keepSnapshots, &resultset, SL("keepSnapshots"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1085, &keepSnapshots); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1094, &keepSnapshots); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/mvc/model/row.zep.c b/ext/phalcon/mvc/model/row.zep.c index a676368398..60b4997965 100644 --- a/ext/phalcon/mvc/model/row.zep.c +++ b/ext/phalcon/mvc/model/row.zep.c @@ -247,7 +247,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Row, toArray) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - ZEPHIR_RETURN_CALL_FUNCTION("get_object_vars", NULL, 313, this_ptr); + ZEPHIR_RETURN_CALL_FUNCTION("get_object_vars", NULL, 325, this_ptr); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/mvc/model/transaction.zep.c b/ext/phalcon/mvc/model/transaction.zep.c index 1682c12b07..a5e9d35edd 100644 --- a/ext/phalcon/mvc/model/transaction.zep.c +++ b/ext/phalcon/mvc/model/transaction.zep.c @@ -161,7 +161,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction, __construct) } ZEPHIR_CALL_METHOD(&connection, container, "get", NULL, 0, &service_zv); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1093, &connection); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1102, &connection); if (autoBegin) { ZEPHIR_CALL_METHOD(NULL, &connection, "begin", NULL, 0); zephir_check_call_status(); @@ -187,7 +187,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction, begin) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1093, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1102, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "begin", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -216,13 +216,13 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction, commit) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1094, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1103, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); if (Z_TYPE_P(&manager) == IS_OBJECT) { ZEPHIR_CALL_METHOD(NULL, &manager, "notifycommit", NULL, 0, this_ptr); zephir_check_call_status(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1093, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1102, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "commit", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -248,7 +248,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction, getConnection) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1095, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1104, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_FUNCTION(&_1$$3, "connection_aborted", NULL, 0); zephir_check_call_status(); @@ -289,7 +289,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction, isManaged) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1094, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1103, PH_NOISY_CC); RETURN_MM_BOOL(Z_TYPE_P(&_0) == IS_OBJECT); } @@ -311,7 +311,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction, isValid) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1093, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1102, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "isundertransaction", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -373,13 +373,13 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction, rollback) rollbackRecord = &rollbackRecord_sub; rollbackRecord = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1094, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1103, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); if (Z_TYPE_P(&manager) == IS_OBJECT) { ZEPHIR_CALL_METHOD(NULL, &manager, "notifyrollback", NULL, 0, this_ptr); zephir_check_call_status(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1093, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1102, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&connection, &_0); ZEPHIR_CALL_METHOD(&_1, &connection, "rollback", NULL, 0); zephir_check_call_status(); @@ -389,13 +389,13 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction, rollback) ZVAL_STRING(&rollbackMessage, "Transaction aborted"); } if (Z_TYPE_P(rollbackRecord) == IS_OBJECT) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1096, rollbackRecord); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1105, rollbackRecord); } - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 1097, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 1106, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_2$$4)) { ZEPHIR_INIT_VAR(&_3$$7); object_init_ex(&_3$$7, phalcon_mvc_model_transaction_failed_ce); - zephir_read_property_cached(&_4$$7, this_ptr, _zephir_prop_2, 1096, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$7, this_ptr, _zephir_prop_2, 1105, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_3$$7, "__construct", NULL, 0, &rollbackMessage, &_4$$7); zephir_check_call_status(); zephir_throw_exception_debug(&_3$$7, "phalcon/Mvc/Model/Transaction.zep", 211); @@ -427,9 +427,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction, setIsNewTransaction) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &isNew_param); if (isNew) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1098, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1107, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1098, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1107, &__$false); } } @@ -454,9 +454,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction, setRollbackOnAbort) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &rollbackOnAbort_param); if (rollbackOnAbort) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1095, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1104, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1095, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1104, &__$false); } } @@ -478,7 +478,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction, setRollbackedRecord) Z_PARAM_OBJECT_OF_CLASS(record, phalcon_mvc_modelinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &record); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1096, record); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1105, record); } /** @@ -499,7 +499,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction, setTransactionManager) Z_PARAM_OBJECT_OF_CLASS(manager, phalcon_mvc_model_transaction_managerinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &manager); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1094, manager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1103, manager); } /** @@ -523,9 +523,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction, throwRollbackException) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &status_param); if (status) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1097, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1106, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1097, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1106, &__$false); } RETURN_THISW(); } diff --git a/ext/phalcon/mvc/model/transaction/failed.zep.c b/ext/phalcon/mvc/model/transaction/failed.zep.c index af2beee459..2105db55fa 100644 --- a/ext/phalcon/mvc/model/transaction/failed.zep.c +++ b/ext/phalcon/mvc/model/transaction/failed.zep.c @@ -81,7 +81,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Failed, __construct) record = &record_sub; record = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1099, record); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1108, record); ZEPHIR_CALL_PARENT(NULL, phalcon_mvc_model_transaction_failed_ce, getThis(), "__construct", NULL, 0, &message_zv); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -119,7 +119,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Failed, getRecordMessages) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1099, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1108, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&record, &_0); if (Z_TYPE_P(&record) != IS_NULL) { ZEPHIR_RETURN_CALL_METHOD(&record, "getmessages", NULL, 0); diff --git a/ext/phalcon/mvc/model/transaction/manager.zep.c b/ext/phalcon/mvc/model/transaction/manager.zep.c index 23b4b6249b..381f5af919 100644 --- a/ext/phalcon/mvc/model/transaction/manager.zep.c +++ b/ext/phalcon/mvc/model/transaction/manager.zep.c @@ -146,7 +146,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, __construct) ZEPHIR_CALL_CE_STATIC(container, phalcon_di_di_ce, "getdefault", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1100, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1109, container); if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { ZEPHIR_INIT_VAR(&_0$$4); object_init_ex(&_0$$4, phalcon_mvc_model_exceptions_managerormservicesunavailable_ce); @@ -182,7 +182,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, collectTransactions) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1101, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1110, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&transactions, &_0); ZEPHIR_INIT_VAR(&_1); zephir_is_iterable(&transactions, 0, "phalcon/Mvc/Model/Transaction/Manager.zep", 128); @@ -217,7 +217,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, collectTransactions) ZEPHIR_INIT_NVAR(&_1); ZEPHIR_INIT_VAR(&_5); array_init(&_5); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1101, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1110, &_5); ZEPHIR_MM_RESTORE(); } @@ -247,7 +247,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, commit) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1101, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1110, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&transactions, &_0); zephir_is_iterable(&transactions, 0, "phalcon/Mvc/Model/Transaction/Manager.zep", 149); if (Z_TYPE_P(&transactions) == IS_ARRAY) { @@ -344,9 +344,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, get) autoBegin = 1; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1102, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1111, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1103, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1112, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_1$$3)) { ZEPHIR_INIT_VAR(&_2$$4); zephir_create_array(&_2$$4, 2, 0); @@ -358,9 +358,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, get) zephir_check_call_status(); } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1102, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1111, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1102, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1111, &__$false); } } if (autoBegin) { @@ -445,7 +445,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, getOrCreateTransaction) autoBegin = 1; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1100, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1109, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (UNEXPECTED(Z_TYPE_P(&container) != IS_OBJECT)) { ZEPHIR_INIT_VAR(&_1$$3); @@ -456,9 +456,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, getOrCreateTransaction) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1104, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1113, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 1101, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 1110, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&transactions, &_2$$4); zephir_is_iterable(&transactions, 0, "phalcon/Mvc/Model/Transaction/Manager.zep", 220); if (Z_TYPE_P(&transactions) == IS_ARRAY) { @@ -503,7 +503,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, getOrCreateTransaction) } ZEPHIR_INIT_NVAR(&transaction); object_init_ex(&transaction, phalcon_mvc_model_transaction_ce); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_3, 1105, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_3, 1114, PH_NOISY_CC | PH_READONLY); if (autoBegin) { ZVAL_BOOL(&_9, 1); } else { @@ -541,7 +541,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, has) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("number", 6, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1104, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1113, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(ZEPHIR_GT_LONG(&_0, 0)); } @@ -631,7 +631,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, rollback) collect = 1; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1101, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1110, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&transactions, &_0); zephir_is_iterable(&transactions, 0, "phalcon/Mvc/Model/Transaction/Manager.zep", 291); if (Z_TYPE_P(&transactions) == IS_ARRAY) { @@ -729,7 +729,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, setDbService) Z_PARAM_STR(service) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&service_zv, service); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1105, &service_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1114, &service_zv); RETURN_THISW(); } @@ -753,7 +753,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, setDI) Z_PARAM_OBJECT_OF_CLASS(container, phalcon_di_diinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &container); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1100, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1109, container); } /** @@ -780,9 +780,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, setRollbackPendent) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &rollbackPendent_param); if (rollbackPendent) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1103, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1112, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1103, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1112, &__$false); } RETURN_THISW(); } @@ -819,7 +819,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, collectTransaction) zephir_fetch_params(1, 1, 0, &transaction); ZEPHIR_INIT_VAR(&newTransactions); array_init(&newTransactions); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1101, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1110, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "phalcon/Mvc/Model/Transaction/Manager.zep", 356); if (Z_TYPE_P(&_0) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1) @@ -858,7 +858,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, collectTransaction) } } ZEPHIR_INIT_NVAR(&managedTransaction); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1101, &newTransactions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1110, &newTransactions); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/mvc/model/validationfailed.zep.c b/ext/phalcon/mvc/model/validationfailed.zep.c index 397462adc4..236caec5db 100644 --- a/ext/phalcon/mvc/model/validationfailed.zep.c +++ b/ext/phalcon/mvc/model/validationfailed.zep.c @@ -94,8 +94,8 @@ PHP_METHOD(Phalcon_Mvc_Model_ValidationFailed, __construct) ZEPHIR_INIT_NVAR(&messageStr); ZVAL_STRING(&messageStr, "Validation failed"); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1106, model); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1107, &validationMessages); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1115, model); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1116, &validationMessages); ZEPHIR_CALL_PARENT(NULL, phalcon_mvc_model_validationfailed_ce, getThis(), "__construct", NULL, 0, &messageStr); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/mvc/router.zep.c b/ext/phalcon/mvc/router.zep.c index d18ef9aa93..4591c00faf 100644 --- a/ext/phalcon/mvc/router.zep.c +++ b/ext/phalcon/mvc/router.zep.c @@ -337,7 +337,7 @@ PHP_METHOD(Phalcon_Mvc_Router, __construct) add_assoc_long_ex(&_1$$3, SL("controller"), 1); ZEPHIR_INIT_VAR(&_2$$3); ZVAL_STRING(&_2$$3, "#^/([\\w0-9\\_\\-]+)[/]{0,1}$#u"); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 248, &_2$$3, &_1$$3); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 254, &_2$$3, &_1$$3); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, this_ptr, "attach", NULL, 0, &_0$$3); zephir_check_call_status(); @@ -350,7 +350,7 @@ PHP_METHOD(Phalcon_Mvc_Router, __construct) add_assoc_long_ex(&_3$$3, SL("params"), 3); ZEPHIR_INIT_VAR(&_4$$3); ZVAL_STRING(&_4$$3, "#^/([\\w0-9\\_\\-]+)/([\\w0-9\\.\\_]+)(/.*)?$#u"); - ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 248, &_4$$3, &_3$$3); + ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 254, &_4$$3, &_3$$3); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, this_ptr, "attach", NULL, 0, &_2$$3); zephir_check_call_status(); @@ -441,7 +441,7 @@ PHP_METHOD(Phalcon_Mvc_Router, add) } ZEPHIR_INIT_VAR(&route); object_init_ex(&route, phalcon_mvc_router_route_ce); - ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 248, &pattern_zv, paths, httpMethods); + ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 254, &pattern_zv, paths, httpMethods); zephir_check_call_status(); ZVAL_LONG(&_0, position); ZEPHIR_CALL_METHOD(NULL, this_ptr, "attach", NULL, 0, &route, &_0); @@ -1120,14 +1120,14 @@ PHP_METHOD(Phalcon_Mvc_Router, attach) ZEPHIR_INIT_VAR(&_1$$4); zephir_create_array(&_1$$4, 1, 0); zephir_array_fast_append(&_1$$4, route); - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); zephir_fast_array_merge(&_0$$4, &_1$$4, &_2$$4); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 273, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 274, &_0$$4); break; } ZEPHIR_INIT_VAR(&_3$$5); object_init_ex(&_3$$5, phalcon_mvc_router_exceptions_invalidrouteposition_ce); - ZEPHIR_CALL_METHOD(NULL, &_3$$5, "__construct", NULL, 249); + ZEPHIR_CALL_METHOD(NULL, &_3$$5, "__construct", NULL, 255); zephir_check_call_status(); zephir_throw_exception_debug(&_3$$5, "phalcon/Mvc/Router.zep", 672); ZEPHIR_MM_RESTORE(); @@ -1135,9 +1135,9 @@ PHP_METHOD(Phalcon_Mvc_Router, attach) } while(0); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 274, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 275, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 274, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 275, &__$false); } RETURN_THIS(); } @@ -1217,41 +1217,41 @@ PHP_METHOD(Phalcon_Mvc_Router, clear) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 273, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 274, &_0); ZEPHIR_INIT_VAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 275, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 276, &_1); ZEPHIR_INIT_VAR(&_2); array_init(&_2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 276, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 277, &_2); ZEPHIR_INIT_VAR(&_3); array_init(&_3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 277, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 278, &_3); ZEPHIR_INIT_VAR(&_4); array_init(&_4); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 278, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 279, &_4); ZEPHIR_INIT_VAR(&_5); array_init(&_5); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 279, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 280, &_5); ZEPHIR_INIT_VAR(&_6); array_init(&_6); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 280, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 281, &_6); ZEPHIR_INIT_VAR(&_7); array_init(&_7); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 281, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 282, &_7); ZEPHIR_INIT_VAR(&_8); array_init(&_8); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 282, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 283, &_8); ZEPHIR_INIT_VAR(&_9); array_init(&_9); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 283, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 284, &_9); ZEPHIR_INIT_VAR(&_10); array_init(&_10); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 284, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 285, &_10); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 274, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 275, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 274, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 275, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -1429,7 +1429,7 @@ PHP_METHOD(Phalcon_Mvc_Router, buildDispatcherDump) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 275, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "rebuildmethodindex", NULL, 0); zephir_check_call_status(); @@ -1438,7 +1438,7 @@ PHP_METHOD(Phalcon_Mvc_Router, buildDispatcherDump) array_init(&dumpedRoutes); ZEPHIR_INIT_VAR(&routeToIdx); array_init(&routeToIdx); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 274, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_1, 0, "phalcon/Mvc/Router.zep", 761); if (Z_TYPE_P(&_1) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_1), _3, _4, _2) @@ -1708,7 +1708,7 @@ PHP_METHOD(Phalcon_Mvc_Router, buildDispatcherDump) ZEPHIR_INIT_NVAR(&scalarIdx); ZEPHIR_INIT_VAR(&methodRoutesScalar); array_init(&methodRoutesScalar); - zephir_read_property_cached(&_51, this_ptr, _zephir_prop_2, 275, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_51, this_ptr, _zephir_prop_2, 276, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_51, 0, "phalcon/Mvc/Router.zep", 770); if (Z_TYPE_P(&_51) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_51), _53, _54, _52) @@ -1826,7 +1826,7 @@ PHP_METHOD(Phalcon_Mvc_Router, buildDispatcherDump) ZEPHIR_INIT_NVAR(&innerKey); ZEPHIR_INIT_VAR(&candidatesScalar); array_init(&candidatesScalar); - zephir_read_property_cached(&_71, this_ptr, _zephir_prop_3, 276, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_71, this_ptr, _zephir_prop_3, 277, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_71, 0, "phalcon/Mvc/Router.zep", 779); if (Z_TYPE_P(&_71) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_71), _73, _74, _72) @@ -1944,7 +1944,7 @@ PHP_METHOD(Phalcon_Mvc_Router, buildDispatcherDump) ZEPHIR_INIT_NVAR(&innerKey); ZEPHIR_INIT_VAR(&staticScalar); array_init(&staticScalar); - zephir_read_property_cached(&_91, this_ptr, _zephir_prop_4, 278, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_91, this_ptr, _zephir_prop_4, 279, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_91, 0, "phalcon/Mvc/Router.zep", 791); if (Z_TYPE_P(&_91) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_91), _93, _94, _92) @@ -2225,25 +2225,25 @@ PHP_METHOD(Phalcon_Mvc_Router, buildDispatcherDump) zephir_array_update_string(return_value, SL("candidatesByMethod"), &candidatesScalar, PH_COPY | PH_SEPARATE); zephir_array_update_string(return_value, SL("staticByMethod"), &staticScalar, PH_COPY | PH_SEPARATE); zephir_memory_observe(&_137); - zephir_read_property_cached(&_137, this_ptr, _zephir_prop_5, 279, PH_NOISY_CC); + zephir_read_property_cached(&_137, this_ptr, _zephir_prop_5, 280, PH_NOISY_CC); zephir_array_update_string(return_value, SL("staticShadowedByMethod"), &_137, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_137); - zephir_read_property_cached(&_137, this_ptr, _zephir_prop_6, 280, PH_NOISY_CC); + zephir_read_property_cached(&_137, this_ptr, _zephir_prop_6, 281, PH_NOISY_CC); zephir_array_update_string(return_value, SL("hostnameByMethod"), &_137, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_137); - zephir_read_property_cached(&_137, this_ptr, _zephir_prop_7, 281, PH_NOISY_CC); + zephir_read_property_cached(&_137, this_ptr, _zephir_prop_7, 282, PH_NOISY_CC); zephir_array_update_string(return_value, SL("hostnameLessByMethod"), &_137, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_137); - zephir_read_property_cached(&_137, this_ptr, _zephir_prop_8, 282, PH_NOISY_CC); + zephir_read_property_cached(&_137, this_ptr, _zephir_prop_8, 283, PH_NOISY_CC); zephir_array_update_string(return_value, SL("combinedRegexByMethod"), &_137, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_137); - zephir_read_property_cached(&_137, this_ptr, _zephir_prop_9, 283, PH_NOISY_CC); + zephir_read_property_cached(&_137, this_ptr, _zephir_prop_9, 284, PH_NOISY_CC); zephir_array_update_string(return_value, SL("combinedRegexDisabled"), &_137, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_137); - zephir_read_property_cached(&_137, this_ptr, _zephir_prop_10, 284, PH_NOISY_CC); + zephir_read_property_cached(&_137, this_ptr, _zephir_prop_10, 285, PH_NOISY_CC); zephir_array_update_string(return_value, SL("combinedRegexMarkMap"), &_137, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_137); - zephir_read_property_cached(&_137, this_ptr, _zephir_prop_11, 277, PH_NOISY_CC); + zephir_read_property_cached(&_137, this_ptr, _zephir_prop_11, 278, PH_NOISY_CC); zephir_array_update_string(return_value, SL("routeMeta"), &_137, PH_COPY | PH_SEPARATE); RETURN_MM(); } @@ -2665,7 +2665,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } } ZEPHIR_INIT_NVAR(&routeData); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 273, &rebuiltRoutes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 274, &rebuiltRoutes); ZEPHIR_INIT_VAR(&methodRoutesRehydrated); array_init(&methodRoutesRehydrated); zephir_array_fetch_string(&_42, &dump, SL("methodRoutes"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 872); @@ -2689,7 +2689,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) { ZEPHIR_INIT_NVAR(&scalarIdx); ZVAL_COPY(&scalarIdx, _46$$20); - zephir_read_property_cached(&_47$$21, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_47$$21, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_48$$21, &_47$$21, &scalarIdx, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 875); zephir_array_append(&mostInnerArr, &_48$$21, PH_SEPARATE, "phalcon/Mvc/Router.zep", 875); } ZEND_HASH_FOREACH_END(); @@ -2711,7 +2711,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_CALL_METHOD(&scalarIdx, &innerVal, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_51$$22, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_51$$22, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_52$$22, &_51$$22, &scalarIdx, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 875); zephir_array_append(&mostInnerArr, &_52$$22, PH_SEPARATE, "phalcon/Mvc/Router.zep", 875); } @@ -2747,7 +2747,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) { ZEPHIR_INIT_NVAR(&scalarIdx); ZVAL_COPY(&scalarIdx, _55$$23); - zephir_read_property_cached(&_56$$24, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_56$$24, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_57$$24, &_56$$24, &scalarIdx, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 875); zephir_array_append(&mostInnerArr, &_57$$24, PH_SEPARATE, "phalcon/Mvc/Router.zep", 875); } ZEND_HASH_FOREACH_END(); @@ -2769,7 +2769,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_CALL_METHOD(&scalarIdx, &innerVal, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_60$$25, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_60$$25, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_61$$25, &_60$$25, &scalarIdx, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 875); zephir_array_append(&mostInnerArr, &_61$$25, PH_SEPARATE, "phalcon/Mvc/Router.zep", 875); } @@ -2803,7 +2803,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) { ZEPHIR_INIT_NVAR(&scalarIdx); ZVAL_COPY(&scalarIdx, _66$$26); - zephir_read_property_cached(&_67$$27, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_67$$27, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_68$$27, &_67$$27, &scalarIdx, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 884); zephir_array_append(&mostInnerArr, &_68$$27, PH_SEPARATE, "phalcon/Mvc/Router.zep", 884); } ZEND_HASH_FOREACH_END(); @@ -2825,7 +2825,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_CALL_METHOD(&scalarIdx, &innerVal, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_71$$28, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_71$$28, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_72$$28, &_71$$28, &scalarIdx, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 884); zephir_array_append(&mostInnerArr, &_72$$28, PH_SEPARATE, "phalcon/Mvc/Router.zep", 884); } @@ -2861,7 +2861,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) { ZEPHIR_INIT_NVAR(&scalarIdx); ZVAL_COPY(&scalarIdx, _75$$29); - zephir_read_property_cached(&_76$$30, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_76$$30, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_77$$30, &_76$$30, &scalarIdx, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 884); zephir_array_append(&mostInnerArr, &_77$$30, PH_SEPARATE, "phalcon/Mvc/Router.zep", 884); } ZEND_HASH_FOREACH_END(); @@ -2883,7 +2883,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_CALL_METHOD(&scalarIdx, &innerVal, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_80$$31, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_80$$31, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_81$$31, &_80$$31, &scalarIdx, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 884); zephir_array_append(&mostInnerArr, &_81$$31, PH_SEPARATE, "phalcon/Mvc/Router.zep", 884); } @@ -2932,7 +2932,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) { ZEPHIR_INIT_NVAR(&scalarIdx); ZVAL_COPY(&scalarIdx, _90$$33); - zephir_read_property_cached(&_91$$34, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_91$$34, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_92$$34, &_91$$34, &scalarIdx, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 895); zephir_array_append(&mostInnerArr, &_92$$34, PH_SEPARATE, "phalcon/Mvc/Router.zep", 895); } ZEND_HASH_FOREACH_END(); @@ -2954,7 +2954,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_CALL_METHOD(&scalarIdx, &mostInnerVal, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_95$$35, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_95$$35, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_96$$35, &_95$$35, &scalarIdx, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 895); zephir_array_append(&mostInnerArr, &_96$$35, PH_SEPARATE, "phalcon/Mvc/Router.zep", 895); } @@ -2990,7 +2990,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) { ZEPHIR_INIT_NVAR(&scalarIdx); ZVAL_COPY(&scalarIdx, _99$$36); - zephir_read_property_cached(&_100$$37, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_100$$37, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_101$$37, &_100$$37, &scalarIdx, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 895); zephir_array_append(&mostInnerArr, &_101$$37, PH_SEPARATE, "phalcon/Mvc/Router.zep", 895); } ZEND_HASH_FOREACH_END(); @@ -3012,7 +3012,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_CALL_METHOD(&scalarIdx, &mostInnerVal, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_104$$38, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_104$$38, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_105$$38, &_104$$38, &scalarIdx, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 895); zephir_array_append(&mostInnerArr, &_105$$38, PH_SEPARATE, "phalcon/Mvc/Router.zep", 895); } @@ -3067,7 +3067,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) { ZEPHIR_INIT_NVAR(&scalarIdx); ZVAL_COPY(&scalarIdx, _112$$40); - zephir_read_property_cached(&_113$$41, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_113$$41, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_114$$41, &_113$$41, &scalarIdx, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 895); zephir_array_append(&mostInnerArr, &_114$$41, PH_SEPARATE, "phalcon/Mvc/Router.zep", 895); } ZEND_HASH_FOREACH_END(); @@ -3089,7 +3089,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_CALL_METHOD(&scalarIdx, &mostInnerVal, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_117$$42, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_117$$42, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_118$$42, &_117$$42, &scalarIdx, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 895); zephir_array_append(&mostInnerArr, &_118$$42, PH_SEPARATE, "phalcon/Mvc/Router.zep", 895); } @@ -3125,7 +3125,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) { ZEPHIR_INIT_NVAR(&scalarIdx); ZVAL_COPY(&scalarIdx, _121$$43); - zephir_read_property_cached(&_122$$44, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_122$$44, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_123$$44, &_122$$44, &scalarIdx, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 895); zephir_array_append(&mostInnerArr, &_123$$44, PH_SEPARATE, "phalcon/Mvc/Router.zep", 895); } ZEND_HASH_FOREACH_END(); @@ -3147,7 +3147,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_CALL_METHOD(&scalarIdx, &mostInnerVal, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_126$$45, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_126$$45, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_127$$45, &_126$$45, &scalarIdx, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 895); zephir_array_append(&mostInnerArr, &_127$$45, PH_SEPARATE, "phalcon/Mvc/Router.zep", 895); } @@ -3162,33 +3162,33 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_INIT_NVAR(&innerVal); ZEPHIR_INIT_NVAR(&innerKey); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 275, &methodRoutesRehydrated); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 276, &candidatesRehydrated); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 278, &staticRehydrated); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 276, &methodRoutesRehydrated); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 277, &candidatesRehydrated); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 279, &staticRehydrated); zephir_array_fetch_string(&_128, &dump, SL("staticShadowedByMethod"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 904); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 279, &_128); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 280, &_128); zephir_array_fetch_string(&_129, &dump, SL("hostnameByMethod"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 905); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 280, &_129); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 281, &_129); zephir_array_fetch_string(&_130, &dump, SL("hostnameLessByMethod"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 906); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 281, &_130); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 282, &_130); zephir_array_fetch_string(&_131, &dump, SL("combinedRegexByMethod"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 907); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 282, &_131); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 283, &_131); zephir_array_fetch_string(&_132, &dump, SL("combinedRegexDisabled"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 908); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 283, &_132); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 284, &_132); zephir_array_fetch_string(&_133, &dump, SL("combinedRegexMarkMap"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 909); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 284, &_133); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 285, &_133); zephir_array_fetch_string(&_134, &dump, SL("routeMeta"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 910); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 277, &_134); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 278, &_134); ZEPHIR_INIT_VAR(&_135); array_init(&_135); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 285, &_135); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 286, &_135); ZEPHIR_INIT_VAR(&_136); array_init(&_136); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_12, 286, &_136); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_12, 287, &_136); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 274, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 275, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 274, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 275, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -3237,7 +3237,7 @@ PHP_METHOD(Phalcon_Mvc_Router, dumpDispatcher) zephir_var_export_ex(&_0, &dump); ZEPHIR_INIT_VAR(&php); ZEPHIR_CONCAT_SVS(&php, " 0; } @@ -4254,10 +4254,10 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZEPHIR_CALL_METHOD(¤tHostName, &request, "gethttphost", NULL, 0); zephir_check_call_status(); } else { - zephir_read_property_cached(&_14, this_ptr, _zephir_prop_7, 280, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14, this_ptr, _zephir_prop_7, 281, PH_NOISY_CC | PH_READONLY); _15 = zephir_array_isset_value_string(&_14, SL("*")); if (_15) { - zephir_read_property_cached(&_16, this_ptr, _zephir_prop_7, 280, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16, this_ptr, _zephir_prop_7, 281, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_17, &_16, SL("*"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 1300); _15 = zephir_fast_count_int(&_17) > 0; } @@ -4269,22 +4269,22 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (Z_TYPE_P(&eventsManager) == IS_NULL) { ZEPHIR_INIT_VAR(&staticBucketMethod); ZVAL_NULL(&staticBucketMethod); - zephir_read_property_cached(&_18$$15, this_ptr, _zephir_prop_8, 278, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$15, this_ptr, _zephir_prop_8, 279, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_19$$15, &_18$$15, &requestMethod, PH_READONLY, "phalcon/Mvc/Router.zep", 1313); _20$$15 = zephir_array_isset_value(&_19$$15, &handledUri); if (_20$$15) { - zephir_read_property_cached(&_21$$15, this_ptr, _zephir_prop_9, 279, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$15, this_ptr, _zephir_prop_9, 280, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_22$$15, &_21$$15, &requestMethod, PH_READONLY, "phalcon/Mvc/Router.zep", 1314); _20$$15 = !(zephir_array_isset_value(&_22$$15, &handledUri)); } if (_20$$15) { ZEPHIR_CPY_WRT(&staticBucketMethod, &requestMethod); } else { - zephir_read_property_cached(&_23$$15, this_ptr, _zephir_prop_8, 278, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$15, this_ptr, _zephir_prop_8, 279, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_24$$15, &_23$$15, SL("*"), PH_READONLY, "phalcon/Mvc/Router.zep", 1316); _25$$15 = zephir_array_isset_value(&_24$$15, &handledUri); if (_25$$15) { - zephir_read_property_cached(&_26$$15, this_ptr, _zephir_prop_9, 279, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_26$$15, this_ptr, _zephir_prop_9, 280, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_27$$15, &_26$$15, SL("*"), PH_READONLY, "phalcon/Mvc/Router.zep", 1317); _25$$15 = !(zephir_array_isset_value(&_27$$15, &handledUri)); } @@ -4294,7 +4294,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) } } if (Z_TYPE_P(&staticBucketMethod) != IS_NULL) { - zephir_read_property_cached(&_28$$18, this_ptr, _zephir_prop_8, 278, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$18, this_ptr, _zephir_prop_8, 279, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_29$$18, &_28$$18, &staticBucketMethod, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 1322); zephir_memory_observe(&staticBucket); zephir_array_fetch(&staticBucket, &_29$$18, &handledUri, PH_NOISY, "phalcon/Mvc/Router.zep", 1322); @@ -4334,7 +4334,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (UNEXPECTED(!(zephir_is_callable(&staticBeforeMatch)))) { ZEPHIR_INIT_NVAR(&_33$$27); object_init_ex(&_33$$27, phalcon_mvc_router_exceptions_beforematchnotcallable_ce); - ZEPHIR_CALL_METHOD(NULL, &_33$$27, "__construct", &_34, 253); + ZEPHIR_CALL_METHOD(NULL, &_33$$27, "__construct", &_34, 259); zephir_check_call_status(); zephir_throw_exception_debug(&_33$$27, "phalcon/Mvc/Router.zep", 1353); ZEPHIR_MM_RESTORE(); @@ -4352,7 +4352,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZVAL_NULL(&matches); ZEPHIR_CALL_METHOD(&parts, &staticRoute, "getpaths", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 297, &staticRoute); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 298, &staticRoute); break; } ZEND_HASH_FOREACH_END(); } else { @@ -4403,7 +4403,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (UNEXPECTED(!(zephir_is_callable(&staticBeforeMatch)))) { ZEPHIR_INIT_NVAR(&_39$$37); object_init_ex(&_39$$37, phalcon_mvc_router_exceptions_beforematchnotcallable_ce); - ZEPHIR_CALL_METHOD(NULL, &_39$$37, "__construct", &_34, 253); + ZEPHIR_CALL_METHOD(NULL, &_39$$37, "__construct", &_34, 259); zephir_check_call_status(); zephir_throw_exception_debug(&_39$$37, "phalcon/Mvc/Router.zep", 1353); ZEPHIR_MM_RESTORE(); @@ -4421,7 +4421,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZVAL_NULL(&matches); ZEPHIR_CALL_METHOD(&parts, &staticRoute, "getpaths", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 297, &staticRoute); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 298, &staticRoute); break; } } @@ -4434,17 +4434,17 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) } _41 = _40; if (_41) { - zephir_read_property_cached(&_42, this_ptr, _zephir_prop_10, 283, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_42, this_ptr, _zephir_prop_10, 284, PH_NOISY_CC | PH_READONLY); _41 = !(zephir_array_isset_value(&_42, &requestMethod)); } _43 = _41; if (_43) { zephir_memory_observe(&combinedChunks); - zephir_read_property_cached(&_44, this_ptr, _zephir_prop_11, 282, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_44, this_ptr, _zephir_prop_11, 283, PH_NOISY_CC | PH_READONLY); _43 = zephir_array_isset_fetch(&combinedChunks, &_44, &requestMethod, 0); } if (_43) { - zephir_read_property_cached(&_45$$39, this_ptr, _zephir_prop_12, 284, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_45$$39, this_ptr, _zephir_prop_12, 285, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&combinedMarkMaps); zephir_array_fetch(&combinedMarkMaps, &_45$$39, &requestMethod, PH_NOISY, "phalcon/Mvc/Router.zep", 1389); zephir_is_iterable(&combinedChunks, 0, "phalcon/Mvc/Router.zep", 1454); @@ -4475,7 +4475,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) } ZEPHIR_OBS_NVAR(&combinedRoute); zephir_array_fetch(&combinedRoute, &candidateRoutes, &combinedRouteIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1404); - zephir_read_property_cached(&_51$$40, this_ptr, _zephir_prop_13, 277, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_51$$40, this_ptr, _zephir_prop_13, 278, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&combinedRouteMeta); ZEPHIR_CALL_METHOD(&_52$$40, &combinedRoute, "getrouteid", NULL, 0); zephir_check_call_status(); @@ -4486,7 +4486,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (UNEXPECTED(!(zephir_is_callable(&combinedBeforeMatch)))) { ZEPHIR_INIT_NVAR(&_53$$44); object_init_ex(&_53$$44, phalcon_mvc_router_exceptions_beforematchnotcallable_ce); - ZEPHIR_CALL_METHOD(NULL, &_53$$44, "__construct", &_34, 253); + ZEPHIR_CALL_METHOD(NULL, &_53$$44, "__construct", &_34, 259); zephir_check_call_status(); zephir_throw_exception_debug(&_53$$44, "phalcon/Mvc/Router.zep", 1411); ZEPHIR_MM_RESTORE(); @@ -4504,8 +4504,8 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZEPHIR_CPY_WRT(&matches, &combinedMatchesLocal); ZEPHIR_CALL_METHOD(&combinedConverters, &combinedRoute, "getconverters", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_14, 300, &combinedMatchesLocal); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 297, &combinedRoute); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_14, 301, &combinedMatchesLocal); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 298, &combinedRoute); ZEPHIR_INIT_NVAR(&routeFound); ZVAL_BOOL(&routeFound, 1); zephir_is_iterable(&combinedPaths, 0, "phalcon/Mvc/Router.zep", 1452); @@ -4523,7 +4523,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (UNEXPECTED(Z_TYPE_P(&combinedPart) != IS_STRING)) { ZEPHIR_INIT_NVAR(&_58$$47); object_init_ex(&_58$$47, phalcon_mvc_router_exceptions_wrongpathskey_ce); - ZEPHIR_CALL_METHOD(NULL, &_58$$47, "__construct", &_59, 254, &combinedPart); + ZEPHIR_CALL_METHOD(NULL, &_58$$47, "__construct", &_59, 260, &combinedPart); zephir_check_call_status(); zephir_throw_exception_debug(&_58$$47, "phalcon/Mvc/Router.zep", 1429); ZEPHIR_MM_RESTORE(); @@ -4588,7 +4588,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (UNEXPECTED(Z_TYPE_P(&combinedPart) != IS_STRING)) { ZEPHIR_INIT_NVAR(&_67$$55); object_init_ex(&_67$$55, phalcon_mvc_router_exceptions_wrongpathskey_ce); - ZEPHIR_CALL_METHOD(NULL, &_67$$55, "__construct", &_59, 254, &combinedPart); + ZEPHIR_CALL_METHOD(NULL, &_67$$55, "__construct", &_59, 260, &combinedPart); zephir_check_call_status(); zephir_throw_exception_debug(&_67$$55, "phalcon/Mvc/Router.zep", 1429); ZEPHIR_MM_RESTORE(); @@ -4671,7 +4671,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) } ZEPHIR_OBS_NVAR(&combinedRoute); zephir_array_fetch(&combinedRoute, &candidateRoutes, &combinedRouteIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1404); - zephir_read_property_cached(&_77$$62, this_ptr, _zephir_prop_13, 277, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_77$$62, this_ptr, _zephir_prop_13, 278, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&combinedRouteMeta); ZEPHIR_CALL_METHOD(&_78$$62, &combinedRoute, "getrouteid", NULL, 0); zephir_check_call_status(); @@ -4682,7 +4682,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (UNEXPECTED(!(zephir_is_callable(&combinedBeforeMatch)))) { ZEPHIR_INIT_NVAR(&_79$$66); object_init_ex(&_79$$66, phalcon_mvc_router_exceptions_beforematchnotcallable_ce); - ZEPHIR_CALL_METHOD(NULL, &_79$$66, "__construct", &_34, 253); + ZEPHIR_CALL_METHOD(NULL, &_79$$66, "__construct", &_34, 259); zephir_check_call_status(); zephir_throw_exception_debug(&_79$$66, "phalcon/Mvc/Router.zep", 1411); ZEPHIR_MM_RESTORE(); @@ -4700,8 +4700,8 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZEPHIR_CPY_WRT(&matches, &combinedMatchesLocal); ZEPHIR_CALL_METHOD(&combinedConverters, &combinedRoute, "getconverters", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_14, 300, &combinedMatchesLocal); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 297, &combinedRoute); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_14, 301, &combinedMatchesLocal); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 298, &combinedRoute); ZEPHIR_INIT_NVAR(&routeFound); ZVAL_BOOL(&routeFound, 1); zephir_is_iterable(&combinedPaths, 0, "phalcon/Mvc/Router.zep", 1452); @@ -4719,7 +4719,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (UNEXPECTED(Z_TYPE_P(&combinedPart) != IS_STRING)) { ZEPHIR_INIT_NVAR(&_84$$69); object_init_ex(&_84$$69, phalcon_mvc_router_exceptions_wrongpathskey_ce); - ZEPHIR_CALL_METHOD(NULL, &_84$$69, "__construct", &_59, 254, &combinedPart); + ZEPHIR_CALL_METHOD(NULL, &_84$$69, "__construct", &_59, 260, &combinedPart); zephir_check_call_status(); zephir_throw_exception_debug(&_84$$69, "phalcon/Mvc/Router.zep", 1429); ZEPHIR_MM_RESTORE(); @@ -4784,7 +4784,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (UNEXPECTED(Z_TYPE_P(&combinedPart) != IS_STRING)) { ZEPHIR_INIT_NVAR(&_92$$77); object_init_ex(&_92$$77, phalcon_mvc_router_exceptions_wrongpathskey_ce); - ZEPHIR_CALL_METHOD(NULL, &_92$$77, "__construct", &_59, 254, &combinedPart); + ZEPHIR_CALL_METHOD(NULL, &_92$$77, "__construct", &_59, 260, &combinedPart); zephir_check_call_status(); zephir_throw_exception_debug(&_92$$77, "phalcon/Mvc/Router.zep", 1429); ZEPHIR_MM_RESTORE(); @@ -4836,7 +4836,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZEPHIR_INIT_NVAR(&combinedChunkIdx); } if (!(zephir_is_true(&routeFound))) { - ZEPHIR_CALL_FUNCTION(&_98$$84, "array_reverse", NULL, 255, &candidateRoutes, &__$true); + ZEPHIR_CALL_FUNCTION(&_98$$84, "array_reverse", NULL, 261, &candidateRoutes, &__$true); zephir_check_call_status(); zephir_is_iterable(&_98$$84, 0, "phalcon/Mvc/Router.zep", 1614); if (Z_TYPE_P(&_98$$84) == IS_ARRAY) { @@ -4850,7 +4850,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) } ZEPHIR_INIT_NVAR(&route); ZVAL_COPY(&route, _99$$84); - zephir_read_property_cached(&_102$$85, this_ptr, _zephir_prop_13, 277, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_102$$85, this_ptr, _zephir_prop_13, 278, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_104$$85, &route, "getrouteid", NULL, 0); zephir_check_call_status(); zephir_array_fetch(&_103$$85, &_102$$85, &_104$$85, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 1462); @@ -4912,7 +4912,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (UNEXPECTED(!(zephir_is_callable(&beforeMatch)))) { ZEPHIR_INIT_NVAR(&_111$$98); object_init_ex(&_111$$98, phalcon_mvc_router_exceptions_beforematchnotcallable_ce); - ZEPHIR_CALL_METHOD(NULL, &_111$$98, "__construct", &_34, 253); + ZEPHIR_CALL_METHOD(NULL, &_111$$98, "__construct", &_34, 259); zephir_check_call_status(); zephir_throw_exception_debug(&_111$$98, "phalcon/Mvc/Router.zep", 1531); ZEPHIR_MM_RESTORE(); @@ -4951,7 +4951,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (UNEXPECTED(Z_TYPE_P(&part) != IS_STRING)) { ZEPHIR_INIT_NVAR(&_117$$104); object_init_ex(&_117$$104, phalcon_mvc_router_exceptions_wrongpathskey_ce); - ZEPHIR_CALL_METHOD(NULL, &_117$$104, "__construct", &_59, 254, &part); + ZEPHIR_CALL_METHOD(NULL, &_117$$104, "__construct", &_59, 260, &part); zephir_check_call_status(); zephir_throw_exception_debug(&_117$$104, "phalcon/Mvc/Router.zep", 1564); ZEPHIR_MM_RESTORE(); @@ -5014,7 +5014,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (UNEXPECTED(Z_TYPE_P(&part) != IS_STRING)) { ZEPHIR_INIT_NVAR(&_124$$113); object_init_ex(&_124$$113, phalcon_mvc_router_exceptions_wrongpathskey_ce); - ZEPHIR_CALL_METHOD(NULL, &_124$$113, "__construct", &_59, 254, &part); + ZEPHIR_CALL_METHOD(NULL, &_124$$113, "__construct", &_59, 260, &part); zephir_check_call_status(); zephir_throw_exception_debug(&_124$$113, "phalcon/Mvc/Router.zep", 1564); ZEPHIR_MM_RESTORE(); @@ -5057,9 +5057,9 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) } ZEPHIR_INIT_NVAR(&position); ZEPHIR_INIT_NVAR(&part); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_14, 300, &matches); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_14, 301, &matches); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 297, &route); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 298, &route); break; } } ZEND_HASH_FOREACH_END(); @@ -5083,7 +5083,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&route, &_98$$84, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_131$$121, this_ptr, _zephir_prop_13, 277, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_131$$121, this_ptr, _zephir_prop_13, 278, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_133$$121, &route, "getrouteid", NULL, 0); zephir_check_call_status(); zephir_array_fetch(&_132$$121, &_131$$121, &_133$$121, PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 1462); @@ -5145,7 +5145,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (UNEXPECTED(!(zephir_is_callable(&beforeMatch)))) { ZEPHIR_INIT_NVAR(&_140$$134); object_init_ex(&_140$$134, phalcon_mvc_router_exceptions_beforematchnotcallable_ce); - ZEPHIR_CALL_METHOD(NULL, &_140$$134, "__construct", &_34, 253); + ZEPHIR_CALL_METHOD(NULL, &_140$$134, "__construct", &_34, 259); zephir_check_call_status(); zephir_throw_exception_debug(&_140$$134, "phalcon/Mvc/Router.zep", 1531); ZEPHIR_MM_RESTORE(); @@ -5184,7 +5184,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (UNEXPECTED(Z_TYPE_P(&part) != IS_STRING)) { ZEPHIR_INIT_NVAR(&_146$$140); object_init_ex(&_146$$140, phalcon_mvc_router_exceptions_wrongpathskey_ce); - ZEPHIR_CALL_METHOD(NULL, &_146$$140, "__construct", &_59, 254, &part); + ZEPHIR_CALL_METHOD(NULL, &_146$$140, "__construct", &_59, 260, &part); zephir_check_call_status(); zephir_throw_exception_debug(&_146$$140, "phalcon/Mvc/Router.zep", 1564); ZEPHIR_MM_RESTORE(); @@ -5247,7 +5247,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (UNEXPECTED(Z_TYPE_P(&part) != IS_STRING)) { ZEPHIR_INIT_NVAR(&_153$$149); object_init_ex(&_153$$149, phalcon_mvc_router_exceptions_wrongpathskey_ce); - ZEPHIR_CALL_METHOD(NULL, &_153$$149, "__construct", &_59, 254, &part); + ZEPHIR_CALL_METHOD(NULL, &_153$$149, "__construct", &_59, 260, &part); zephir_check_call_status(); zephir_throw_exception_debug(&_153$$149, "phalcon/Mvc/Router.zep", 1564); ZEPHIR_MM_RESTORE(); @@ -5290,9 +5290,9 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) } ZEPHIR_INIT_NVAR(&position); ZEPHIR_INIT_NVAR(&part); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_14, 300, &matches); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_14, 301, &matches); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 297, &route); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 298, &route); break; } } @@ -5302,19 +5302,19 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) } if (zephir_is_true(&routeFound)) { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 296, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 297, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 296, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 297, &__$false); } } else { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 296, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 297, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 296, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 297, &__$false); } } if (!(zephir_is_true(&routeFound))) { - zephir_read_property_cached(&_158$$159, this_ptr, _zephir_prop_15, 301, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_158$$159, this_ptr, _zephir_prop_15, 302, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(¬FoundPaths, &_158$$159); if (Z_TYPE_P(¬FoundPaths) != IS_NULL) { ZEPHIR_CALL_CE_STATIC(&parts, phalcon_mvc_router_route_ce, "getroutepaths", NULL, 0, ¬FoundPaths); @@ -5323,35 +5323,35 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZVAL_BOOL(&routeFound, 1); } } - zephir_read_property_cached(&_159, this_ptr, _zephir_prop_16, 289, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 302, &_159); - zephir_read_property_cached(&_160, this_ptr, _zephir_prop_18, 290, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 303, &_160); - zephir_read_property_cached(&_161, this_ptr, _zephir_prop_20, 291, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_21, 304, &_161); - zephir_read_property_cached(&_162, this_ptr, _zephir_prop_22, 292, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_23, 305, &_162); - zephir_read_property_cached(&_163, this_ptr, _zephir_prop_24, 293, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_25, 306, &_163); + zephir_read_property_cached(&_159, this_ptr, _zephir_prop_16, 290, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 303, &_159); + zephir_read_property_cached(&_160, this_ptr, _zephir_prop_18, 291, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 304, &_160); + zephir_read_property_cached(&_161, this_ptr, _zephir_prop_20, 292, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_21, 305, &_161); + zephir_read_property_cached(&_162, this_ptr, _zephir_prop_22, 293, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_23, 306, &_162); + zephir_read_property_cached(&_163, this_ptr, _zephir_prop_24, 294, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_25, 307, &_163); if (zephir_is_true(&routeFound)) { zephir_memory_observe(&vnamespace); if (zephir_array_isset_string_fetch(&vnamespace, &parts, SL("namespace"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 302, &vnamespace); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 303, &vnamespace); zephir_array_unset_string(&parts, SL("namespace"), PH_SEPARATE); } zephir_memory_observe(&module); if (zephir_array_isset_string_fetch(&module, &parts, SL("module"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 303, &module); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 304, &module); zephir_array_unset_string(&parts, SL("module"), PH_SEPARATE); } zephir_memory_observe(&controller); if (zephir_array_isset_string_fetch(&controller, &parts, SL("controller"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_21, 304, &controller); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_21, 305, &controller); zephir_array_unset_string(&parts, SL("controller"), PH_SEPARATE); } zephir_memory_observe(&action); if (zephir_array_isset_string_fetch(&action, &parts, SL("action"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_23, 305, &action); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_23, 306, &action); zephir_array_unset_string(&parts, SL("action"), PH_SEPARATE); } zephir_memory_observe(¶msStr); @@ -5371,9 +5371,9 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (zephir_fast_count_int(¶ms)) { ZEPHIR_INIT_VAR(&_165$$169); zephir_fast_array_merge(&_165$$169, ¶ms, &parts); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_25, 306, &_165$$169); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_25, 307, &_165$$169); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_25, 306, &parts); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_25, 307, &parts); } } if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { @@ -5382,19 +5382,19 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZEPHIR_CALL_METHOD(NULL, &eventsManager, "fire", NULL, 0, &_166$$171, this_ptr); zephir_check_call_status(); } - zephir_read_property_cached(&_167, this_ptr, _zephir_prop_26, 287, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_167, this_ptr, _zephir_prop_26, 288, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_167) != IS_NULL) { - zephir_read_property_cached(&_168$$172, this_ptr, _zephir_prop_26, 287, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_169$$172, this_ptr, _zephir_prop_27, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_168$$172, this_ptr, _zephir_prop_26, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_169$$172, this_ptr, _zephir_prop_27, 289, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_170$$172, this_ptr, "builddispatcherdump", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_168$$172, "set", NULL, 0, &_169$$172, &_170$$172); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_26, 287, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_26, 288, &__$null); ZEPHIR_INIT_VAR(&_171$$172); ZEPHIR_INIT_NVAR(&_171$$172); ZVAL_STRING(&_171$$172, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_27, 288, &_171$$172); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_27, 289, &_171$$172); } ZEPHIR_MM_RESTORE(); } @@ -5463,7 +5463,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadFromConfig) if (!(zephir_instance_of_ev(config, phalcon_config_configinterface_ce))) { ZEPHIR_INIT_VAR(&_0$$4); object_init_ex(&_0$$4, phalcon_mvc_router_exceptions_invalidconfigsource_ce); - ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 256); + ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 262); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$4, "phalcon/Mvc/Router.zep", 1751); ZEPHIR_MM_RESTORE(); @@ -5476,7 +5476,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadFromConfig) if (Z_TYPE_P(config) != IS_ARRAY) { ZEPHIR_INIT_VAR(&_2$$5); object_init_ex(&_2$$5, phalcon_mvc_router_exceptions_invalidconfigsource_ce); - ZEPHIR_CALL_METHOD(NULL, &_2$$5, "__construct", NULL, 256); + ZEPHIR_CALL_METHOD(NULL, &_2$$5, "__construct", NULL, 262); zephir_check_call_status(); zephir_throw_exception_debug(&_2$$5, "phalcon/Mvc/Router.zep", 1757); ZEPHIR_MM_RESTORE(); @@ -5624,7 +5624,7 @@ PHP_METHOD(Phalcon_Mvc_Router, mount) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &group); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 298, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 299, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_0); if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_1$$3); @@ -5637,7 +5637,7 @@ PHP_METHOD(Phalcon_Mvc_Router, mount) if (UNEXPECTED(!(zephir_fast_count_int(&groupRoutes)))) { ZEPHIR_INIT_VAR(&_2$$4); object_init_ex(&_2$$4, phalcon_mvc_router_exceptions_emptygroupofroutes_ce); - ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 257); + ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 263); zephir_check_call_status(); zephir_throw_exception_debug(&_2$$4, "phalcon/Mvc/Router.zep", 1818); ZEPHIR_MM_RESTORE(); @@ -5786,13 +5786,13 @@ PHP_METHOD(Phalcon_Mvc_Router, notFound) if (UNEXPECTED(_0)) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_mvc_router_exceptions_invalidnotfoundpaths_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 258); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 264); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Mvc/Router.zep", 1859); ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 301, paths); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 302, paths); RETURN_THIS(); } @@ -5821,9 +5821,9 @@ PHP_METHOD(Phalcon_Mvc_Router, removeExtraSlashes) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &remove_param); if (remove) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 295, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 296, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 295, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 296, &__$false); } RETURN_THISW(); } @@ -5851,7 +5851,7 @@ PHP_METHOD(Phalcon_Mvc_Router, setDefaultAction) Z_PARAM_STR(actionName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&actionName_zv, actionName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 292, &actionName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 293, &actionName_zv); RETURN_THISW(); } @@ -5878,7 +5878,7 @@ PHP_METHOD(Phalcon_Mvc_Router, setDefaultController) Z_PARAM_STR(controllerName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&controllerName_zv, controllerName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 291, &controllerName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 292, &controllerName_zv); RETURN_THISW(); } @@ -5905,7 +5905,7 @@ PHP_METHOD(Phalcon_Mvc_Router, setDefaultModule) Z_PARAM_STR(moduleName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&moduleName_zv, moduleName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 290, &moduleName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 291, &moduleName_zv); RETURN_THISW(); } @@ -5932,7 +5932,7 @@ PHP_METHOD(Phalcon_Mvc_Router, setDefaultNamespace) Z_PARAM_STR(namespaceName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&namespaceName_zv, namespaceName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 289, &namespaceName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 290, &namespaceName_zv); RETURN_THISW(); } @@ -6003,26 +6003,26 @@ PHP_METHOD(Phalcon_Mvc_Router, setDefaults) zephir_memory_observe(&namespaceName); if (zephir_array_isset_string_fetch(&namespaceName, &defaults, SL("namespace"), 0)) { zephir_cast_to_string(&_0$$3, &namespaceName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 289, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 290, &_0$$3); } zephir_memory_observe(&module); if (zephir_array_isset_string_fetch(&module, &defaults, SL("module"), 0)) { zephir_cast_to_string(&_1$$4, &module); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 290, &_1$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 291, &_1$$4); } zephir_memory_observe(&controller); if (zephir_array_isset_string_fetch(&controller, &defaults, SL("controller"), 0)) { zephir_cast_to_string(&_2$$5, &controller); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 291, &_2$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 292, &_2$$5); } zephir_memory_observe(&action); if (zephir_array_isset_string_fetch(&action, &defaults, SL("action"), 0)) { zephir_cast_to_string(&_3$$6, &action); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 292, &_3$$6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 293, &_3$$6); } zephir_memory_observe(¶ms); if (zephir_array_isset_string_fetch(¶ms, &defaults, SL("params"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 293, ¶ms); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 294, ¶ms); } RETURN_THIS(); } @@ -6049,7 +6049,7 @@ PHP_METHOD(Phalcon_Mvc_Router, setEventsManager) Z_PARAM_OBJECT_OF_CLASS(eventsManager, phalcon_events_managerinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &eventsManager); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 298, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 299, eventsManager); } /** @@ -6077,7 +6077,7 @@ PHP_METHOD(Phalcon_Mvc_Router, setKeyRouteIds) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &routeIds_param); zephir_get_arrval(&routeIds, routeIds_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 285, &routeIds); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 286, &routeIds); RETURN_THIS(); } @@ -6106,7 +6106,7 @@ PHP_METHOD(Phalcon_Mvc_Router, setKeyRouteNames) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &routeNames_param); zephir_get_arrval(&routeNames, routeNames_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 286, &routeNames); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 287, &routeNames); RETURN_THIS(); } @@ -6137,7 +6137,7 @@ PHP_METHOD(Phalcon_Mvc_Router, setUriSource) zephir_fetch_params_without_memory_grow(1, 0, &uriSource_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, uriSource); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 294, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 295, &_0); RETURN_THISW(); } @@ -6227,7 +6227,7 @@ PHP_METHOD(Phalcon_Mvc_Router, addRouteFromConfig) } ZEPHIR_INIT_VAR(&_5$$7); object_init_ex(&_5$$7, phalcon_mvc_router_exceptions_unknownhttpmethod_ce); - ZEPHIR_CALL_METHOD(NULL, &_5$$7, "__construct", NULL, 259, &method); + ZEPHIR_CALL_METHOD(NULL, &_5$$7, "__construct", NULL, 265, &method); zephir_check_call_status(); zephir_throw_exception_debug(&_5$$7, "phalcon/Mvc/Router.zep", 2089); ZEPHIR_MM_RESTORE(); @@ -6336,20 +6336,20 @@ PHP_METHOD(Phalcon_Mvc_Router, mountGroupFromConfig) } ZEPHIR_INIT_VAR(&group); object_init_ex(&group, phalcon_mvc_router_group_ce); - ZEPHIR_CALL_METHOD(NULL, &group, "__construct", NULL, 260, &paths); + ZEPHIR_CALL_METHOD(NULL, &group, "__construct", NULL, 266, &paths); zephir_check_call_status(); if (zephir_array_isset_value_string(&groupData, SL("prefix"))) { zephir_memory_observe(&_0$$4); zephir_array_fetch_string(&_0$$4, &groupData, SL("prefix"), PH_NOISY, "phalcon/Mvc/Router.zep", 2129); zephir_cast_to_string(&_1$$4, &_0$$4); - ZEPHIR_CALL_METHOD(NULL, &group, "setprefix", NULL, 261, &_1$$4); + ZEPHIR_CALL_METHOD(NULL, &group, "setprefix", NULL, 267, &_1$$4); zephir_check_call_status(); } if (zephir_array_isset_value_string(&groupData, SL("hostname"))) { zephir_memory_observe(&_2$$5); zephir_array_fetch_string(&_2$$5, &groupData, SL("hostname"), PH_NOISY, "phalcon/Mvc/Router.zep", 2133); zephir_cast_to_string(&_3$$5, &_2$$5); - ZEPHIR_CALL_METHOD(NULL, &group, "sethostname", NULL, 262, &_3$$5); + ZEPHIR_CALL_METHOD(NULL, &group, "sethostname", NULL, 268, &_3$$5); zephir_check_call_status(); } zephir_memory_observe(&routes); @@ -6360,7 +6360,7 @@ PHP_METHOD(Phalcon_Mvc_Router, mountGroupFromConfig) if (Z_TYPE_P(&routes) != IS_ARRAY) { ZEPHIR_INIT_VAR(&_4$$7); object_init_ex(&_4$$7, phalcon_mvc_router_exceptions_grouproutesmustbearray_ce); - ZEPHIR_CALL_METHOD(NULL, &_4$$7, "__construct", NULL, 263); + ZEPHIR_CALL_METHOD(NULL, &_4$$7, "__construct", NULL, 269); zephir_check_call_status(); zephir_throw_exception_debug(&_4$$7, "phalcon/Mvc/Router.zep", 2141); ZEPHIR_MM_RESTORE(); @@ -6408,7 +6408,7 @@ PHP_METHOD(Phalcon_Mvc_Router, mountGroupFromConfig) } ZEPHIR_INIT_NVAR(&_11$$13); object_init_ex(&_11$$13, phalcon_mvc_router_exceptions_unknownhttpmethod_ce); - ZEPHIR_CALL_METHOD(NULL, &_11$$13, "__construct", &_12, 259, &method); + ZEPHIR_CALL_METHOD(NULL, &_11$$13, "__construct", &_12, 265, &method); zephir_check_call_status(); zephir_throw_exception_debug(&_11$$13, "phalcon/Mvc/Router.zep", 2173); ZEPHIR_MM_RESTORE(); @@ -6477,7 +6477,7 @@ PHP_METHOD(Phalcon_Mvc_Router, mountGroupFromConfig) } ZEPHIR_INIT_NVAR(&_22$$20); object_init_ex(&_22$$20, phalcon_mvc_router_exceptions_unknownhttpmethod_ce); - ZEPHIR_CALL_METHOD(NULL, &_22$$20, "__construct", &_12, 259, &method); + ZEPHIR_CALL_METHOD(NULL, &_22$$20, "__construct", &_12, 265, &method); zephir_check_call_status(); zephir_throw_exception_debug(&_22$$20, "phalcon/Mvc/Router.zep", 2173); ZEPHIR_MM_RESTORE(); @@ -6716,20 +6716,20 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 275, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 276, &_0); ZEPHIR_INIT_VAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 276, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 277, &_1); ZEPHIR_INIT_VAR(&_2); array_init(&_2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 277, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 278, &_2); ZEPHIR_INIT_VAR(&_3); array_init(&_3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 278, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 279, &_3); ZEPHIR_INIT_VAR(&_4); array_init(&_4); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 279, &_4); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_5, 273, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 280, &_4); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_5, 274, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_5, 0, "phalcon/Mvc/Router.zep", 2211); if (Z_TYPE_P(&_5) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_5), _6) @@ -6835,12 +6835,12 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) } ZEPHIR_INIT_NVAR(&route); zephir_memory_observe(&starRoutes); - zephir_read_property_cached(&_15, this_ptr, _zephir_prop_0, 275, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15, this_ptr, _zephir_prop_0, 276, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_string_fetch(&starRoutes, &_15, SL("*"), 0))) { ZEPHIR_INIT_NVAR(&starRoutes); array_init(&starRoutes); } - zephir_read_property_cached(&_16, this_ptr, _zephir_prop_0, 275, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16, this_ptr, _zephir_prop_0, 276, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_16, 0, "phalcon/Mvc/Router.zep", 2251); if (Z_TYPE_P(&_16) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_16), _18, _19, _17) @@ -6862,7 +6862,7 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) ZEPHIR_INIT_NVAR(&_21$$16); array_init(&_21$$16); zephir_update_property_array(this_ptr, SL("candidatesByMethod"), &method, &_21$$16); - zephir_read_property_cached(&_22$$16, this_ptr, _zephir_prop_5, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$16, this_ptr, _zephir_prop_5, 274, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_22$$16, 0, "phalcon/Mvc/Router.zep", 2244); if (Z_TYPE_P(&_22$$16) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_22$$16), _23$$16) @@ -6943,7 +6943,7 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) ZEPHIR_INIT_NVAR(&_29$$28); array_init(&_29$$28); zephir_update_property_array(this_ptr, SL("candidatesByMethod"), &method, &_29$$28); - zephir_read_property_cached(&_30$$28, this_ptr, _zephir_prop_5, 273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_30$$28, this_ptr, _zephir_prop_5, 274, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_30$$28, 0, "phalcon/Mvc/Router.zep", 2244); if (Z_TYPE_P(&_30$$28) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_30$$28), _31$$28) @@ -7000,8 +7000,8 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) ZEPHIR_INIT_NVAR(&method); ZEPHIR_INIT_VAR(&_34); array_init(&_34); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 277, &_34); - zephir_read_property_cached(&_35, this_ptr, _zephir_prop_5, 273, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 278, &_34); + zephir_read_property_cached(&_35, this_ptr, _zephir_prop_5, 274, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_35, 0, "phalcon/Mvc/Router.zep", 2277); if (Z_TYPE_P(&_35) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_35), _36) @@ -7078,7 +7078,7 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) } } ZEPHIR_INIT_NVAR(&candidateRoute); - zephir_read_property_cached(&_45, this_ptr, _zephir_prop_1, 276, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_45, this_ptr, _zephir_prop_1, 277, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_45, 0, "phalcon/Mvc/Router.zep", 2300); if (Z_TYPE_P(&_45) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_45), _47, _48, _46) @@ -7103,7 +7103,7 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) zephir_update_property_array_multi(this_ptr, SL("staticByMethod"), &bucketRoute, SL("zza"), 3, &method, &bucketPattern); } else { ZEPHIR_OBS_NVAR(&staticBucket); - zephir_read_property_cached(&_50$$47, this_ptr, _zephir_prop_3, 278, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_50$$47, this_ptr, _zephir_prop_3, 279, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&staticBucket, &_50$$47, &method, 0)) { zephir_is_iterable(&staticBucket, 0, "phalcon/Mvc/Router.zep", 2290); if (Z_TYPE_P(&staticBucket) == IS_ARRAY) { @@ -7181,7 +7181,7 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) zephir_update_property_array_multi(this_ptr, SL("staticByMethod"), &bucketRoute, SL("zza"), 3, &method, &bucketPattern); } else { ZEPHIR_OBS_NVAR(&staticBucket); - zephir_read_property_cached(&_62$$55, this_ptr, _zephir_prop_3, 278, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_62$$55, this_ptr, _zephir_prop_3, 279, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&staticBucket, &_62$$55, &method, 0)) { zephir_is_iterable(&staticBucket, 0, "phalcon/Mvc/Router.zep", 2290); if (Z_TYPE_P(&staticBucket) == IS_ARRAY) { @@ -7270,7 +7270,7 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) zephir_update_property_array_multi(this_ptr, SL("staticByMethod"), &bucketRoute, SL("zza"), 3, &method, &bucketPattern); } else { ZEPHIR_OBS_NVAR(&staticBucket); - zephir_read_property_cached(&_75$$64, this_ptr, _zephir_prop_3, 278, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_75$$64, this_ptr, _zephir_prop_3, 279, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&staticBucket, &_75$$64, &method, 0)) { zephir_is_iterable(&staticBucket, 0, "phalcon/Mvc/Router.zep", 2290); if (Z_TYPE_P(&staticBucket) == IS_ARRAY) { @@ -7348,7 +7348,7 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) zephir_update_property_array_multi(this_ptr, SL("staticByMethod"), &bucketRoute, SL("zza"), 3, &method, &bucketPattern); } else { ZEPHIR_OBS_NVAR(&staticBucket); - zephir_read_property_cached(&_87$$72, this_ptr, _zephir_prop_3, 278, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_87$$72, this_ptr, _zephir_prop_3, 279, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&staticBucket, &_87$$72, &method, 0)) { zephir_is_iterable(&staticBucket, 0, "phalcon/Mvc/Router.zep", 2290); if (Z_TYPE_P(&staticBucket) == IS_ARRAY) { @@ -7410,11 +7410,11 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) ZEPHIR_INIT_NVAR(&method); ZEPHIR_INIT_VAR(&_97); array_init(&_97); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 280, &_97); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 281, &_97); ZEPHIR_INIT_VAR(&_98); array_init(&_98); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 281, &_98); - zephir_read_property_cached(&_99, this_ptr, _zephir_prop_1, 276, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 282, &_98); + zephir_read_property_cached(&_99, this_ptr, _zephir_prop_1, 277, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_99, 0, "phalcon/Mvc/Router.zep", 2327); if (Z_TYPE_P(&_99) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_99), _101, _102, _100) @@ -7568,14 +7568,14 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) ZEPHIR_INIT_NVAR(&method); ZEPHIR_INIT_VAR(&_119); array_init(&_119); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 282, &_119); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 283, &_119); ZEPHIR_INIT_VAR(&_120); array_init(&_120); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 284, &_120); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 285, &_120); ZEPHIR_INIT_VAR(&_121); array_init(&_121); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 283, &_121); - zephir_read_property_cached(&_122, this_ptr, _zephir_prop_1, 276, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 284, &_121); + zephir_read_property_cached(&_122, this_ptr, _zephir_prop_1, 277, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_122, 0, "phalcon/Mvc/Router.zep", 2409); if (Z_TYPE_P(&_122) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_122), _124, _125, _123) @@ -7588,7 +7588,7 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) } ZEPHIR_INIT_NVAR(&candidates); ZVAL_COPY(&candidates, _123); - zephir_read_property_cached(&_126$$92, this_ptr, _zephir_prop_6, 280, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_126$$92, this_ptr, _zephir_prop_6, 281, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&hostnameBucketRef); zephir_array_fetch(&hostnameBucketRef, &_126$$92, &method, PH_NOISY, "phalcon/Mvc/Router.zep", 2335); if (!(ZEPHIR_IS_EMPTY(&hostnameBucketRef))) { @@ -7688,19 +7688,19 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) } ZEPHIR_INIT_NVAR(&bucketRoute); ZEPHIR_INIT_NVAR(&bucketIdx); - zephir_read_property_cached(&_140$$92, this_ptr, _zephir_prop_10, 283, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_140$$92, this_ptr, _zephir_prop_10, 284, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_140$$92, &method)) { continue; } if (ZEPHIR_IS_EMPTY(&combinedAlternatives)) { continue; } - ZEPHIR_CALL_FUNCTION(&_141$$92, "array_reverse", &_142, 255, &combinedAlternatives); + ZEPHIR_CALL_FUNCTION(&_141$$92, "array_reverse", &_142, 261, &combinedAlternatives); zephir_check_call_status(); ZEPHIR_CPY_WRT(&combinedAlternatives, &_141$$92); ZEPHIR_INIT_NVAR(&_143$$92); zephir_array_keys(&_143$$92, &combinedMark); - ZEPHIR_CALL_FUNCTION(&reversedMarkIds$$92, "array_reverse", &_142, 255, &_143$$92); + ZEPHIR_CALL_FUNCTION(&reversedMarkIds$$92, "array_reverse", &_142, 261, &_143$$92); zephir_check_call_status(); ZEPHIR_CPY_WRT(&reversedMarkIds$$92, &reversedMarkIds$$92); ZEPHIR_INIT_NVAR(&chunkedPatterns$$92); @@ -7716,11 +7716,11 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) break; } ZVAL_LONG(&_144$$102, 10); - ZEPHIR_CALL_FUNCTION(&chunkSlice$$92, "array_slice", &_145, 264, &combinedAlternatives, &chunkOffset$$92, &_144$$102); + ZEPHIR_CALL_FUNCTION(&chunkSlice$$92, "array_slice", &_145, 270, &combinedAlternatives, &chunkOffset$$92, &_144$$102); zephir_check_call_status(); ZEPHIR_CPY_WRT(&chunkSlice$$92, &chunkSlice$$92); ZVAL_LONG(&_144$$102, 10); - ZEPHIR_CALL_FUNCTION(&chunkMarkSubset$$92, "array_slice", &_145, 264, &reversedMarkIds$$92, &chunkOffset$$92, &_144$$102); + ZEPHIR_CALL_FUNCTION(&chunkMarkSubset$$92, "array_slice", &_145, 270, &reversedMarkIds$$92, &chunkOffset$$92, &_144$$102); zephir_check_call_status(); ZEPHIR_CPY_WRT(&chunkMarkSubset$$92, &chunkMarkSubset$$92); ZEPHIR_INIT_NVAR(&chunkSliceMap$$92); @@ -7791,7 +7791,7 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&candidates, &_122, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_156$$105, this_ptr, _zephir_prop_6, 280, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_156$$105, this_ptr, _zephir_prop_6, 281, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&hostnameBucketRef); zephir_array_fetch(&hostnameBucketRef, &_156$$105, &method, PH_NOISY, "phalcon/Mvc/Router.zep", 2335); if (!(ZEPHIR_IS_EMPTY(&hostnameBucketRef))) { @@ -7891,19 +7891,19 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) } ZEPHIR_INIT_NVAR(&bucketRoute); ZEPHIR_INIT_NVAR(&bucketIdx); - zephir_read_property_cached(&_170$$105, this_ptr, _zephir_prop_10, 283, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_170$$105, this_ptr, _zephir_prop_10, 284, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_170$$105, &method)) { continue; } if (ZEPHIR_IS_EMPTY(&combinedAlternatives)) { continue; } - ZEPHIR_CALL_FUNCTION(&_171$$105, "array_reverse", &_142, 255, &combinedAlternatives); + ZEPHIR_CALL_FUNCTION(&_171$$105, "array_reverse", &_142, 261, &combinedAlternatives); zephir_check_call_status(); ZEPHIR_CPY_WRT(&combinedAlternatives, &_171$$105); ZEPHIR_INIT_NVAR(&_172$$105); zephir_array_keys(&_172$$105, &combinedMark); - ZEPHIR_CALL_FUNCTION(&reversedMarkIds$$105, "array_reverse", &_142, 255, &_172$$105); + ZEPHIR_CALL_FUNCTION(&reversedMarkIds$$105, "array_reverse", &_142, 261, &_172$$105); zephir_check_call_status(); ZEPHIR_CPY_WRT(&reversedMarkIds$$105, &reversedMarkIds$$105); ZEPHIR_INIT_NVAR(&chunkedPatterns$$105); @@ -7919,11 +7919,11 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) break; } ZVAL_LONG(&_173$$115, 10); - ZEPHIR_CALL_FUNCTION(&chunkSlice$$105, "array_slice", &_145, 264, &combinedAlternatives, &chunkOffset$$105, &_173$$115); + ZEPHIR_CALL_FUNCTION(&chunkSlice$$105, "array_slice", &_145, 270, &combinedAlternatives, &chunkOffset$$105, &_173$$115); zephir_check_call_status(); ZEPHIR_CPY_WRT(&chunkSlice$$105, &chunkSlice$$105); ZVAL_LONG(&_173$$115, 10); - ZEPHIR_CALL_FUNCTION(&chunkMarkSubset$$105, "array_slice", &_145, 264, &reversedMarkIds$$105, &chunkOffset$$105, &_173$$115); + ZEPHIR_CALL_FUNCTION(&chunkMarkSubset$$105, "array_slice", &_145, 270, &reversedMarkIds$$105, &chunkOffset$$105, &_173$$115); zephir_check_call_status(); ZEPHIR_CPY_WRT(&chunkMarkSubset$$105, &chunkMarkSubset$$105); ZEPHIR_INIT_NVAR(&chunkSliceMap$$105); @@ -7978,9 +7978,9 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) ZEPHIR_INIT_NVAR(&candidates); ZEPHIR_INIT_NVAR(&method); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 274, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 275, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 274, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 275, &__$false); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/mvc/router/annotations.zep.c b/ext/phalcon/mvc/router/annotations.zep.c index c3b000218d..299d6882f5 100644 --- a/ext/phalcon/mvc/router/annotations.zep.c +++ b/ext/phalcon/mvc/router/annotations.zep.c @@ -272,7 +272,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Annotations, handle) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&uri_zv); ZVAL_STR_COPY(&uri_zv, uri); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1108, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1117, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (UNEXPECTED(Z_TYPE_P(&container) != IS_OBJECT)) { ZEPHIR_INIT_VAR(&_1$$3); @@ -283,9 +283,9 @@ PHP_METHOD(Phalcon_Mvc_Router_Annotations, handle) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1109, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1118, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&handlers, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1110, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1119, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&controllerSuffix, &_0); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "annotations"); @@ -305,7 +305,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Annotations, handle) if (!(ZEPHIR_IS_EMPTY(&prefix))) { ZEPHIR_INIT_NVAR(&route); object_init_ex(&route, phalcon_mvc_router_route_ce); - ZEPHIR_CALL_METHOD(NULL, &route, "__construct", &_4, 248, &prefix); + ZEPHIR_CALL_METHOD(NULL, &route, "__construct", &_4, 254, &prefix); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_5$$6, &route, "getcompiledpattern", &_6, 0); zephir_check_call_status(); @@ -345,7 +345,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Annotations, handle) ZEPHIR_OBS_NVAR(&namespaceName); zephir_fetch_property(&namespaceName, this_ptr, SL("defaultNamespace"), PH_SILENT_CC); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1111, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1120, &__$null); ZEPHIR_OBS_NVAR(&moduleName); zephir_array_isset_long_fetch(&moduleName, &scope, 2, 0); ZEPHIR_INIT_NVAR(&_14$$4); @@ -553,7 +553,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Annotations, handle) if (!(ZEPHIR_IS_EMPTY(&prefix))) { ZEPHIR_INIT_NVAR(&route); object_init_ex(&route, phalcon_mvc_router_route_ce); - ZEPHIR_CALL_METHOD(NULL, &route, "__construct", &_4, 248, &prefix); + ZEPHIR_CALL_METHOD(NULL, &route, "__construct", &_4, 254, &prefix); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_37$$30, &route, "getcompiledpattern", &_6, 0); zephir_check_call_status(); @@ -593,7 +593,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Annotations, handle) ZEPHIR_OBS_NVAR(&namespaceName); zephir_fetch_property(&namespaceName, this_ptr, SL("defaultNamespace"), PH_SILENT_CC); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1111, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1120, &__$null); ZEPHIR_OBS_NVAR(&moduleName); zephir_array_isset_long_fetch(&moduleName, &scope, 2, 0); ZEPHIR_INIT_NVAR(&_45$$28); @@ -878,16 +878,16 @@ PHP_METHOD(Phalcon_Mvc_Router_Annotations, processActionAnnotation) if (!(isRoute)) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1112, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1121, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, ""); ZEPHIR_INIT_VAR(&proxyActionName); zephir_fast_str_replace(&proxyActionName, &_0, &_1, &action_zv); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1111, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1120, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&routePrefix, &_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1113, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1122, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_2) != IS_NULL) { - zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_2, 1113, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_2, 1122, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_4$$6, "call_user_func", NULL, 80, &_3$$6, &proxyActionName); zephir_check_call_status(); ZEPHIR_CPY_WRT(&proxyActionName, &_4$$6); @@ -1097,7 +1097,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Annotations, processControllerAnnotation) ZVAL_LONG(&_2$$3, 0); ZEPHIR_CALL_METHOD(&_1$$3, annotation, "getargument", NULL, 0, &_2$$3); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1111, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1120, &_1$$3); } ZEPHIR_MM_RESTORE(); } @@ -1121,7 +1121,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Annotations, setActionSuffix) Z_PARAM_STR(actionSuffix) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&actionSuffix_zv, actionSuffix); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1112, &actionSuffix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1121, &actionSuffix_zv); RETURN_THISW(); } @@ -1183,12 +1183,12 @@ PHP_METHOD(Phalcon_Mvc_Router_Annotations, setActionPreformatCallback) callback = &__$null; } if (EXPECTED(zephir_is_callable(callback))) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1113, callback); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1122, callback); } else if (Z_TYPE_P(callback) == IS_NULL) { ZEPHIR_INIT_VAR(&_0$$4); ZEPHIR_INIT_NVAR(&_0$$4); - zephir_create_closure_ex(&_0$$4, NULL, phalcon_89__closure_ce, SL("__invoke")); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1113, &_0$$4); + zephir_create_closure_ex(&_0$$4, NULL, phalcon_91__closure_ce, SL("__invoke")); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1122, &_0$$4); } else { ZEPHIR_INIT_VAR(&_1$$5); object_init_ex(&_1$$5, phalcon_mvc_router_exceptions_invalidcallbackparameter_ce); @@ -1229,7 +1229,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Annotations, setControllerSuffix) Z_PARAM_STR(controllerSuffix) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&controllerSuffix_zv, controllerSuffix); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1110, &controllerSuffix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1119, &controllerSuffix_zv); RETURN_THISW(); } diff --git a/ext/phalcon/mvc/router/group.zep.c b/ext/phalcon/mvc/router/group.zep.c index bf3181ddc6..29a7722127 100644 --- a/ext/phalcon/mvc/router/group.zep.c +++ b/ext/phalcon/mvc/router/group.zep.c @@ -141,7 +141,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Group, __construct) _0 = Z_TYPE_P(paths) == IS_STRING; } if (_0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1114, paths); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1123, paths); } if ((zephir_method_exists_ex(this_ptr, ZEND_STRL("initialize")) == SUCCESS)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0, paths); @@ -724,7 +724,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Group, beforeMatch) Z_PARAM_ZVAL(beforeMatch) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &beforeMatch); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1115, beforeMatch); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1124, beforeMatch); RETURN_THISW(); } @@ -747,7 +747,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Group, clear) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1116, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1125, &_0); ZEPHIR_MM_RESTORE(); } @@ -819,7 +819,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Group, setHostname) Z_PARAM_STR(hostname) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&hostname_zv, hostname); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1117, &hostname_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1126, &hostname_zv); RETURN_THISW(); } @@ -845,7 +845,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Group, setPaths) Z_PARAM_ZVAL(paths) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &paths); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1114, paths); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1123, paths); RETURN_THISW(); } @@ -872,7 +872,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Group, setPrefix) Z_PARAM_STR(prefix) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&prefix_zv, prefix); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1118, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1127, &prefix_zv); RETURN_THISW(); } @@ -943,7 +943,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Group, addRoute) httpMethods = &__$null; } zephir_memory_observe(&defaultPaths); - zephir_read_property_cached(&defaultPaths, this_ptr, _zephir_prop_0, 1114, PH_NOISY_CC); + zephir_read_property_cached(&defaultPaths, this_ptr, _zephir_prop_0, 1123, PH_NOISY_CC); if (Z_TYPE_P(&defaultPaths) == IS_ARRAY) { if (Z_TYPE_P(paths) == IS_STRING) { ZEPHIR_CALL_CE_STATIC(&processedPaths, phalcon_mvc_router_route_ce, "getroutepaths", NULL, 0, paths); @@ -962,10 +962,10 @@ PHP_METHOD(Phalcon_Mvc_Router_Group, addRoute) } ZEPHIR_INIT_VAR(&route); object_init_ex(&route, phalcon_mvc_router_route_ce); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1118, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1127, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZEPHIR_CONCAT_VV(&_1, &_0, &pattern_zv); - ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 248, &_1, &mergedPaths, httpMethods); + ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 254, &_1, &mergedPaths, httpMethods); zephir_check_call_status(); zephir_update_property_array_append(this_ptr, SL("routes"), &route); ZEPHIR_CALL_METHOD(NULL, &route, "setgroup", NULL, 0, this_ptr); diff --git a/ext/phalcon/mvc/router/route.zep.c b/ext/phalcon/mvc/router/route.zep.c index ef6c3cd1f5..09fd60d998 100644 --- a/ext/phalcon/mvc/router/route.zep.c +++ b/ext/phalcon/mvc/router/route.zep.c @@ -156,7 +156,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Route, __construct) zephir_read_static_property_ce(&_0, phalcon_mvc_router_route_ce, SL("uniqueId"), PH_NOISY_CC); ZEPHIR_CPY_WRT(&uniqueId, &_0); zephir_cast_to_string(&_1, &uniqueId); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1119, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1128, &_1); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, (zephir_get_numberval(&uniqueId) + 1)); zephir_update_static_property_ce(phalcon_mvc_router_route_ce, ZEND_STRL("uniqueId"), &_0); @@ -202,7 +202,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Route, beforeMatch) Z_PARAM_ZVAL(callback) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &callback); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1120, callback); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1129, callback); RETURN_THISW(); } @@ -606,18 +606,18 @@ PHP_METHOD(Phalcon_Mvc_Router_Route, getCompiledHostName) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1121, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1130, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_FALSE_IDENTICAL(&_0)) { RETURN_MM_MEMBER(getThis(), "compiledHostName"); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1122, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1131, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&hostname, &_1); if (Z_TYPE_P(&hostname) == IS_NULL) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1121, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1130, &__$null); RETURN_MM_NULL(); } if (!(zephir_memnstr_str(&hostname, SL("("), "phalcon/Mvc/Router/Route.zep", 375))) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1121, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1130, &__$null); RETURN_MM_NULL(); } if (!(zephir_memnstr_str(&hostname, SL("#"), "phalcon/Mvc/Router/Route.zep", 380))) { @@ -630,7 +630,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Route, getCompiledHostName) } else { ZEPHIR_CPY_WRT(®exHostName, &hostname); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1121, ®exHostName); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1130, ®exHostName); RETURN_CCTOR(®exHostName); } @@ -733,8 +733,8 @@ PHP_METHOD(Phalcon_Mvc_Router_Route, getReversedPaths) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1123, PH_NOISY_CC | PH_READONLY); - ZEPHIR_RETURN_CALL_FUNCTION("array_flip", NULL, 247, &_0); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1132, PH_NOISY_CC | PH_READONLY); + ZEPHIR_RETURN_CALL_FUNCTION("array_flip", NULL, 253, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -885,7 +885,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Route, match) Z_PARAM_ZVAL(callback) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &callback); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1124, callback); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1133, callback); RETURN_THISW(); } @@ -959,9 +959,9 @@ PHP_METHOD(Phalcon_Mvc_Router_Route, reConfigure) } else { ZEPHIR_CPY_WRT(&compiledPattern, &pattern_zv); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1125, &pattern_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1126, &compiledPattern); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1123, &routePaths); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1134, &pattern_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1135, &compiledPattern); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1132, &routePaths); ZEPHIR_MM_RESTORE(); } @@ -996,7 +996,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Route, setGroup) Z_PARAM_OBJECT_OF_CLASS(group, phalcon_mvc_router_groupinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &group); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1127, group); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1136, group); RETURN_THISW(); } @@ -1029,11 +1029,11 @@ PHP_METHOD(Phalcon_Mvc_Router_Route, setHostname) Z_PARAM_STR(hostname) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&hostname_zv, hostname); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1122, &hostname_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1131, &hostname_zv); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1121, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1130, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1121, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1130, &__$false); } RETURN_THISW(); } @@ -1099,7 +1099,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Route, setName) Z_PARAM_STR(name) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&name_zv, name); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1128, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1137, &name_zv); RETURN_THISW(); } @@ -1124,7 +1124,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Route, setRouteId) Z_PARAM_STR(routeId) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&routeId_zv, routeId); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1119, &routeId_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1128, &routeId_zv); RETURN_THISW(); } @@ -1157,7 +1157,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Route, via) Z_PARAM_ZVAL(httpMethods) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &httpMethods); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1129, httpMethods); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1138, httpMethods); RETURN_THISW(); } diff --git a/ext/phalcon/mvc/url.zep.c b/ext/phalcon/mvc/url.zep.c index 6c723cd45c..70118bcbe8 100644 --- a/ext/phalcon/mvc/url.zep.c +++ b/ext/phalcon/mvc/url.zep.c @@ -94,7 +94,7 @@ PHP_METHOD(Phalcon_Mvc_Url, __construct) router = &router_sub; router = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1130, router); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1139, router); } /** @@ -290,10 +290,10 @@ PHP_METHOD(Phalcon_Mvc_Url, get) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_7$$9, this_ptr, _zephir_prop_0, 1130, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$9, this_ptr, _zephir_prop_0, 1139, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&router, &_7$$9); if (UNEXPECTED(!zephir_is_true(&router))) { - zephir_read_property_cached(&_8$$11, this_ptr, _zephir_prop_1, 1131, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$11, this_ptr, _zephir_prop_1, 1140, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_8$$11); if (UNEXPECTED(Z_TYPE_P(&container) != IS_OBJECT)) { ZEPHIR_INIT_VAR(&_9$$12); @@ -322,7 +322,7 @@ PHP_METHOD(Phalcon_Mvc_Url, get) ZEPHIR_CALL_METHOD(&_13$$11, &container, "getshared", NULL, 0, &_11$$11); zephir_check_call_status(); ZEPHIR_CPY_WRT(&router, &_13$$11); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1130, &router); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1139, &router); } ZEPHIR_CALL_METHOD(&_14$$9, &router, "getroutebyname", NULL, 0, &routeName); zephir_check_call_status(); @@ -465,7 +465,7 @@ PHP_METHOD(Phalcon_Mvc_Url, getBaseUri) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_get_global(&_SERVER, SL("_SERVER")); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1132, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1141, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&baseUri, &_0); if (Z_TYPE_P(&baseUri) == IS_NULL) { zephir_memory_observe(&phpSelf); @@ -482,7 +482,7 @@ PHP_METHOD(Phalcon_Mvc_Url, getBaseUri) } else { ZEPHIR_CONCAT_SVS(&baseUri, "/", &uri, "/"); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1132, &baseUri); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1141, &baseUri); } RETURN_CCTOR(&baseUri); } @@ -557,7 +557,7 @@ PHP_METHOD(Phalcon_Mvc_Url, getStaticBaseUri) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1133, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1142, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { RETURN_MM_MEMBER_TYPED(getThis(), "staticBaseUri", IS_STRING); } @@ -596,7 +596,7 @@ PHP_METHOD(Phalcon_Mvc_Url, path) zephir_memory_observe(&path_zv); ZVAL_STR_COPY(&path_zv, path); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1134, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1143, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_VV(return_value, &_0, &path_zv); RETURN_MM(); } @@ -624,7 +624,7 @@ PHP_METHOD(Phalcon_Mvc_Url, setBasePath) Z_PARAM_STR(basePath) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&basePath_zv, basePath); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1134, &basePath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1143, &basePath_zv); RETURN_THISW(); } @@ -658,10 +658,10 @@ PHP_METHOD(Phalcon_Mvc_Url, setBaseUri) Z_PARAM_STR(baseUri) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&baseUri_zv, baseUri); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1132, &baseUri_zv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1133, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1141, &baseUri_zv); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1142, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1133, &baseUri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1142, &baseUri_zv); } RETURN_THISW(); } @@ -689,7 +689,7 @@ PHP_METHOD(Phalcon_Mvc_Url, setStaticBaseUri) Z_PARAM_STR(staticBaseUri) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&staticBaseUri_zv, staticBaseUri); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1133, &staticBaseUri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1142, &staticBaseUri_zv); RETURN_THISW(); } diff --git a/ext/phalcon/mvc/view.zep.c b/ext/phalcon/mvc/view.zep.c index 7560275e3f..21422b804f 100644 --- a/ext/phalcon/mvc/view.zep.c +++ b/ext/phalcon/mvc/view.zep.c @@ -243,13 +243,13 @@ PHP_METHOD(Phalcon_Mvc_View, __construct) } else { zephir_get_arrval(&options, options_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1135, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1144, &options); ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1136, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1145, &_0); ZEPHIR_INIT_VAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1137, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1146, &_1); ZEPHIR_MM_RESTORE(); } @@ -305,7 +305,7 @@ PHP_METHOD(Phalcon_Mvc_View, __isset) Z_PARAM_STR(key) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&key_zv, key); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1137, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1146, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &key_zv)); } @@ -359,7 +359,7 @@ PHP_METHOD(Phalcon_Mvc_View, cleanTemplateAfter) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1138, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1147, &_0); RETURN_THIS(); } @@ -382,7 +382,7 @@ PHP_METHOD(Phalcon_Mvc_View, cleanTemplateBefore) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1139, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1148, &_0); RETURN_THIS(); } @@ -401,9 +401,9 @@ PHP_METHOD(Phalcon_Mvc_View, disable) _zephir_prop_0 = zend_string_init("disabled", 8, 1); } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1140, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1149, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1140, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1149, &__$false); } RETURN_THISW(); } @@ -435,7 +435,7 @@ PHP_METHOD(Phalcon_Mvc_View, disableLevel) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &level); if (Z_TYPE_P(level) == IS_ARRAY) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1141, level); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1150, level); } else { zephir_update_property_array(this_ptr, SL("disabledLevels"), level, &__$true); } @@ -457,9 +457,9 @@ PHP_METHOD(Phalcon_Mvc_View, enable) _zephir_prop_0 = zend_string_init("disabled", 8, 1); } if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1140, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1149, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1140, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1149, &__$false); } RETURN_THISW(); } @@ -533,7 +533,7 @@ PHP_METHOD(Phalcon_Mvc_View, getActiveRenderPath) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&activeRenderPath); - zephir_read_property_cached(&activeRenderPath, this_ptr, _zephir_prop_0, 1142, PH_NOISY_CC); + zephir_read_property_cached(&activeRenderPath, this_ptr, _zephir_prop_0, 1151, PH_NOISY_CC); if (Z_TYPE_P(&activeRenderPath) == IS_ARRAY) { if (zephir_fast_count_int(&activeRenderPath) == 1) { zephir_array_fetch_long(&_0$$4, &activeRenderPath, 0, PH_NOISY | PH_READONLY, "phalcon/Mvc/View.zep", 346); @@ -835,10 +835,10 @@ PHP_METHOD(Phalcon_Mvc_View, has) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&view_zv); ZVAL_STR_COPY(&view_zv, view); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1143, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1152, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&basePath, &_0); zephir_memory_observe(&engines); - zephir_read_property_cached(&engines, this_ptr, _zephir_prop_1, 1136, PH_NOISY_CC); + zephir_read_property_cached(&engines, this_ptr, _zephir_prop_1, 1145, PH_NOISY_CC); if (ZEPHIR_IS_EMPTY(&engines)) { ZEPHIR_INIT_VAR(&_1$$3); zephir_create_array(&_1$$3, 1, 0); @@ -1058,18 +1058,18 @@ PHP_METHOD(Phalcon_Mvc_View, partial) params = &__$null; } if (Z_TYPE_P(params) == IS_ARRAY) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1137, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1146, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&viewParams, &_0$$3); ZEPHIR_INIT_VAR(&_1$$3); zephir_fast_array_merge(&_1$$3, &viewParams, params); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1137, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1146, &_1$$3); ZEPHIR_INIT_VAR(&_2$$3); ZEPHIR_CREATE_SYMBOL_TABLE(); } ZEPHIR_CALL_METHOD(&_3, this_ptr, "loadtemplateengines", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1144, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1153, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_5); ZEPHIR_CONCAT_VV(&_5, &_4, &partialPath_zv); ZVAL_BOOL(&_6, 0); @@ -1077,7 +1077,7 @@ PHP_METHOD(Phalcon_Mvc_View, partial) ZEPHIR_CALL_METHOD(NULL, this_ptr, "enginerender", NULL, 0, &_3, &_5, &_6, &_7); zephir_check_call_status(); if (Z_TYPE_P(params) == IS_ARRAY) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1137, &viewParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1146, &viewParams); } ZEPHIR_MM_RESTORE(); } @@ -1141,7 +1141,7 @@ PHP_METHOD(Phalcon_Mvc_View, pick) zephir_array_append(&pickView, &layout, PH_SEPARATE, "phalcon/Mvc/View.zep", 666); } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1145, &pickView); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1154, &pickView); RETURN_THIS(); } @@ -1291,25 +1291,25 @@ PHP_METHOD(Phalcon_Mvc_View, processRender) } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1146, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1140, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1155, &_0); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1149, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_FALSE_IDENTICAL(&_0)) { ZEPHIR_CALL_FUNCTION(&_1$$3, "ob_get_contents", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1147, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1156, &_1$$3); RETURN_MM_BOOL(0); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1148, &controllerName_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1149, &actionName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1157, &controllerName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1158, &actionName_zv); ZEPHIR_CALL_METHOD(NULL, this_ptr, "setvars", NULL, 0, ¶ms); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_5, 1150, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_5, 1159, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&layoutsDir, &_2); if (!(zephir_is_true(&layoutsDir))) { ZEPHIR_INIT_NVAR(&layoutsDir); ZVAL_STRING(&layoutsDir, "layouts/"); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_6, 1151, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_6, 1160, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&layout, &_2); if (zephir_is_true(&layout)) { ZEPHIR_CPY_WRT(&layoutName, &layout); @@ -1318,7 +1318,7 @@ PHP_METHOD(Phalcon_Mvc_View, processRender) } ZEPHIR_CALL_METHOD(&engines, this_ptr, "loadtemplateengines", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_7, 1145, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_7, 1154, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&pickView, &_2); if (Z_TYPE_P(&pickView) == IS_NULL) { ZEPHIR_INIT_VAR(&_3$$7); @@ -1334,7 +1334,7 @@ PHP_METHOD(Phalcon_Mvc_View, processRender) } } } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_8, 1152, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_8, 1161, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_2); ZEPHIR_INIT_VAR(&_4); ZEPHIR_CREATE_SYMBOL_TABLE(); @@ -1354,19 +1354,19 @@ PHP_METHOD(Phalcon_Mvc_View, processRender) } ZEPHIR_CALL_FUNCTION(&_8, "ob_get_contents", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1147, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1156, &_8); silence = 1; - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_9, 1141, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_9, 1150, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&disabledLevels, &_2); zephir_memory_observe(&_9); - zephir_read_property_cached(&_9, this_ptr, _zephir_prop_10, 1153, PH_NOISY_CC); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_10, 1162, PH_NOISY_CC); renderLevel = zephir_get_intval(&_9); if (renderLevel) { if (renderLevel >= 1) { if (!(zephir_array_isset_value_long(&disabledLevels, 1))) { ZVAL_UNDEF(&_10$$15); ZVAL_LONG(&_10$$15, 1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1146, &_10$$15); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1155, &_10$$15); if (silence) { ZVAL_BOOL(&_10$$15, 1); } else { @@ -1380,8 +1380,8 @@ PHP_METHOD(Phalcon_Mvc_View, processRender) if (!(zephir_array_isset_value_long(&disabledLevels, 2))) { ZVAL_UNDEF(&_11$$17); ZVAL_LONG(&_11$$17, 2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1146, &_11$$17); - zephir_read_property_cached(&_11$$17, this_ptr, _zephir_prop_11, 1139, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1155, &_11$$17); + zephir_read_property_cached(&_11$$17, this_ptr, _zephir_prop_11, 1148, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&templatesBefore, &_11$$17); silence = 0; zephir_is_iterable(&templatesBefore, 0, "phalcon/Mvc/View.zep", 821); @@ -1437,7 +1437,7 @@ PHP_METHOD(Phalcon_Mvc_View, processRender) if (!(zephir_array_isset_value_long(&disabledLevels, 3))) { ZVAL_UNDEF(&_19$$21); ZVAL_LONG(&_19$$21, 3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1146, &_19$$21); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1155, &_19$$21); ZEPHIR_INIT_VAR(&_20$$21); ZEPHIR_CONCAT_VV(&_20$$21, &layoutsDir, &layoutName); if (silence) { @@ -1453,8 +1453,8 @@ PHP_METHOD(Phalcon_Mvc_View, processRender) if (!(zephir_array_isset_value_long(&disabledLevels, 4))) { ZVAL_UNDEF(&_21$$23); ZVAL_LONG(&_21$$23, 4); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1146, &_21$$23); - zephir_read_property_cached(&_21$$23, this_ptr, _zephir_prop_12, 1138, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1155, &_21$$23); + zephir_read_property_cached(&_21$$23, this_ptr, _zephir_prop_12, 1147, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&templatesAfter, &_21$$23); silence = 0; zephir_is_iterable(&templatesAfter, 0, "phalcon/Mvc/View.zep", 857); @@ -1510,8 +1510,8 @@ PHP_METHOD(Phalcon_Mvc_View, processRender) if (!(zephir_array_isset_value_long(&disabledLevels, 5))) { ZVAL_UNDEF(&_29$$27); ZVAL_LONG(&_29$$27, 5); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1146, &_29$$27); - zephir_read_property_cached(&_29$$27, this_ptr, _zephir_prop_13, 1154, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1155, &_29$$27); + zephir_read_property_cached(&_29$$27, this_ptr, _zephir_prop_13, 1163, PH_NOISY_CC | PH_READONLY); if (silence) { ZVAL_BOOL(&_30$$27, 1); } else { @@ -1523,7 +1523,7 @@ PHP_METHOD(Phalcon_Mvc_View, processRender) } ZVAL_UNDEF(&_31$$13); ZVAL_LONG(&_31$$13, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1146, &_31$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1155, &_31$$13); } _32 = fireEvents; if (_32) { @@ -1571,7 +1571,7 @@ PHP_METHOD(Phalcon_Mvc_View, registerEngines) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &engines_param); zephir_get_arrval(&engines, engines_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1136, &engines); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1145, &engines); RETURN_THIS(); } @@ -1667,28 +1667,28 @@ PHP_METHOD(Phalcon_Mvc_View, reset) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1140, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1149, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1140, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1149, &__$false); } if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1155, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1164, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1155, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1164, &__$false); } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 5); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1153, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1162, &_0); ZEPHIR_INIT_VAR(&_1); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1147, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1156, &_1); ZEPHIR_INIT_NVAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1139, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1148, &_1); ZEPHIR_INIT_VAR(&_2); array_init(&_2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1138, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1147, &_2); RETURN_THIS(); } @@ -1716,7 +1716,7 @@ PHP_METHOD(Phalcon_Mvc_View, setBasePath) Z_PARAM_STR(basePath) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&basePath_zv, basePath); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1143, &basePath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1152, &basePath_zv); RETURN_THISW(); } @@ -1738,7 +1738,7 @@ PHP_METHOD(Phalcon_Mvc_View, setEventsManager) Z_PARAM_OBJECT_OF_CLASS(eventsManager, phalcon_events_managerinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &eventsManager); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1152, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1161, eventsManager); } /** @@ -1765,7 +1765,7 @@ PHP_METHOD(Phalcon_Mvc_View, setLayout) Z_PARAM_STR(layout) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&layout_zv, layout); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1151, &layout_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1160, &layout_zv); RETURN_THISW(); } @@ -1794,7 +1794,7 @@ PHP_METHOD(Phalcon_Mvc_View, setLayoutsDir) Z_PARAM_STR(layoutsDir) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&layoutsDir_zv, layoutsDir); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1150, &layoutsDir_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1159, &layoutsDir_zv); RETURN_THISW(); } @@ -1823,7 +1823,7 @@ PHP_METHOD(Phalcon_Mvc_View, setMainView) Z_PARAM_STR(viewPath) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&viewPath_zv, viewPath); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1154, &viewPath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1163, &viewPath_zv); RETURN_THISW(); } @@ -1877,7 +1877,7 @@ PHP_METHOD(Phalcon_Mvc_View, setPartialsDir) Z_PARAM_STR(partialsDir) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&partialsDir_zv, partialsDir); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1144, &partialsDir_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1153, &partialsDir_zv); RETURN_THISW(); } @@ -1909,7 +1909,7 @@ PHP_METHOD(Phalcon_Mvc_View, setRenderLevel) zephir_fetch_params_without_memory_grow(1, 0, &level_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, level); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1153, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1162, &_0); RETURN_THISW(); } @@ -1940,9 +1940,9 @@ PHP_METHOD(Phalcon_Mvc_View, setTemplateAfter) ZEPHIR_INIT_VAR(&_0$$3); zephir_create_array(&_0$$3, 1, 0); zephir_array_fast_append(&_0$$3, templateAfter); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1138, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1147, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1138, templateAfter); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1147, templateAfter); } RETURN_THIS(); } @@ -1974,9 +1974,9 @@ PHP_METHOD(Phalcon_Mvc_View, setTemplateBefore) ZEPHIR_INIT_VAR(&_0$$3); zephir_create_array(&_0$$3, 1, 0); zephir_array_fast_append(&_0$$3, templateBefore); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1139, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1148, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1139, templateBefore); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1148, templateBefore); } RETURN_THIS(); } @@ -2023,11 +2023,11 @@ PHP_METHOD(Phalcon_Mvc_View, setVars) } if (merge) { ZEPHIR_INIT_VAR(&_0$$3); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1137, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1146, PH_NOISY_CC | PH_READONLY); zephir_fast_array_merge(&_0$$3, &_1$$3, ¶ms); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1137, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1146, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1137, ¶ms); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1146, ¶ms); } RETURN_THIS(); } @@ -2085,7 +2085,7 @@ PHP_METHOD(Phalcon_Mvc_View, setViewsDir) if (Z_TYPE_P(viewsDir) == IS_STRING) { ZEPHIR_CALL_METHOD(&_2$$4, this_ptr, "todirseparator", NULL, 0, viewsDir); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1156, &_2$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1165, &_2$$4); } else { ZEPHIR_INIT_VAR(&newViewsDir); array_init(&newViewsDir); @@ -2150,7 +2150,7 @@ PHP_METHOD(Phalcon_Mvc_View, setViewsDir) } ZEPHIR_INIT_NVAR(&directory); ZEPHIR_INIT_NVAR(&position); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1156, &newViewsDir); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1165, &newViewsDir); } RETURN_THIS(); } @@ -2178,7 +2178,7 @@ PHP_METHOD(Phalcon_Mvc_View, start) ZEPHIR_INIT_VAR(&_0); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1147, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1156, &_0); RETURN_THIS(); } @@ -2332,11 +2332,11 @@ PHP_METHOD(Phalcon_Mvc_View, engineRender) mustClean = 1; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1143, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1152, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&basePath, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1137, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1146, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&viewParams, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1152, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1161, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_0); ZEPHIR_INIT_VAR(&viewEnginePaths); array_init(&viewEnginePaths); @@ -2377,7 +2377,7 @@ PHP_METHOD(Phalcon_Mvc_View, engineRender) ZEPHIR_INIT_NVAR(&_10$$8); zephir_create_array(&_10$$8, 1, 0); zephir_array_fast_append(&_10$$8, &viewEnginePath); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1142, &_10$$8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1151, &_10$$8); ZEPHIR_INIT_NVAR(&_12$$8); ZVAL_STRING(&_12$$8, "view:beforeRenderView"); ZEPHIR_CALL_METHOD(&_11$$8, &eventsManager, "fire", &_13, 0, &_12$$8, this_ptr, &viewEnginePath); @@ -2432,7 +2432,7 @@ PHP_METHOD(Phalcon_Mvc_View, engineRender) ZEPHIR_INIT_NVAR(&_20$$13); zephir_create_array(&_20$$13, 1, 0); zephir_array_fast_append(&_20$$13, &viewEnginePath); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1142, &_20$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1151, &_20$$13); ZEPHIR_INIT_NVAR(&_22$$13); ZVAL_STRING(&_22$$13, "view:beforeRenderView"); ZEPHIR_CALL_METHOD(&_21$$13, &eventsManager, "fire", &_23, 0, &_22$$13, this_ptr, &viewEnginePath); @@ -2509,7 +2509,7 @@ PHP_METHOD(Phalcon_Mvc_View, engineRender) ZEPHIR_INIT_NVAR(&_34$$21); zephir_create_array(&_34$$21, 1, 0); zephir_array_fast_append(&_34$$21, &viewEnginePath); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1142, &_34$$21); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1151, &_34$$21); ZEPHIR_INIT_NVAR(&_36$$21); ZVAL_STRING(&_36$$21, "view:beforeRenderView"); ZEPHIR_CALL_METHOD(&_35$$21, &eventsManager, "fire", &_37, 0, &_36$$21, this_ptr, &viewEnginePath); @@ -2564,7 +2564,7 @@ PHP_METHOD(Phalcon_Mvc_View, engineRender) ZEPHIR_INIT_NVAR(&_44$$26); zephir_create_array(&_44$$26, 1, 0); zephir_array_fast_append(&_44$$26, &viewEnginePath); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1142, &_44$$26); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1151, &_44$$26); ZEPHIR_INIT_NVAR(&_46$$26); ZVAL_STRING(&_46$$26, "view:beforeRenderView"); ZEPHIR_CALL_METHOD(&_45$$26, &eventsManager, "fire", &_47, 0, &_46$$26, this_ptr, &viewEnginePath); @@ -2597,7 +2597,7 @@ PHP_METHOD(Phalcon_Mvc_View, engineRender) } ZEPHIR_INIT_NVAR(&viewsDir); if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1142, &viewEnginePaths); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1151, &viewEnginePaths); ZEPHIR_INIT_VAR(&_51$$29); ZVAL_STRING(&_51$$29, "view:notFoundView"); ZEPHIR_CALL_METHOD(NULL, &eventsManager, "fire", NULL, 0, &_51$$29, this_ptr, &viewEnginePath); @@ -2634,11 +2634,11 @@ PHP_METHOD(Phalcon_Mvc_View, getViewsDirs) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1156, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1165, PH_NOISY_CC); if (Z_TYPE_P(&_0) == IS_STRING) { zephir_create_array(return_value, 1, 0); zephir_memory_observe(&_1$$3); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1156, PH_NOISY_CC); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1165, PH_NOISY_CC); zephir_array_fast_append(return_value, &_1$$3); RETURN_MM(); } @@ -2738,14 +2738,14 @@ PHP_METHOD(Phalcon_Mvc_View, loadTemplateEngines) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1155, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1164, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&engines, &_0); if (ZEPHIR_IS_FALSE_IDENTICAL(&engines)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1157, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1166, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&di, &_1$$3); ZEPHIR_INIT_NVAR(&engines); array_init(&engines); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 1136, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 1145, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(®isteredEngines, &_1$$3); if (ZEPHIR_IS_EMPTY(®isteredEngines)) { ZEPHIR_INIT_VAR(&_2$$4); @@ -2859,7 +2859,7 @@ PHP_METHOD(Phalcon_Mvc_View, loadTemplateEngines) ZEPHIR_INIT_NVAR(&engineService); ZEPHIR_INIT_NVAR(&extension); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1155, &engines); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1164, &engines); } RETURN_CCTOR(&engines); } @@ -3366,7 +3366,7 @@ PHP_METHOD(Phalcon_Mvc_View, getParamsToView) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1137, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1146, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } @@ -3391,7 +3391,7 @@ PHP_METHOD(Phalcon_Mvc_View, getRegisteredEngines) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1136, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1145, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } @@ -3424,7 +3424,7 @@ PHP_METHOD(Phalcon_Mvc_View, getVar) zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); zephir_memory_observe(&value); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1137, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1146, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&value, &_0, &key_zv, 0))) { RETURN_MM_NULL(); } @@ -3456,7 +3456,7 @@ PHP_METHOD(Phalcon_Mvc_View, setContent) Z_PARAM_STR(content) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&content_zv, content); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1147, &content_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1156, &content_zv); RETURN_THISW(); } diff --git a/ext/phalcon/mvc/view/engine/php.zep.c b/ext/phalcon/mvc/view/engine/php.zep.c index e6235c128c..1c91fdaa3e 100644 --- a/ext/phalcon/mvc/view/engine/php.zep.c +++ b/ext/phalcon/mvc/view/engine/php.zep.c @@ -137,7 +137,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Php, render) RETURN_MM_NULL(); } if (mustClean) { - zephir_read_property_cached(&_7$$7, this_ptr, _zephir_prop_0, 1158, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$7, this_ptr, _zephir_prop_0, 1167, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_8$$7, "ob_get_contents", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_7$$7, "setcontent", NULL, 0, &_8$$7); diff --git a/ext/phalcon/mvc/view/engine/volt.zep.c b/ext/phalcon/mvc/view/engine/volt.zep.c index 54ef33f20e..72d012e118 100644 --- a/ext/phalcon/mvc/view/engine/volt.zep.c +++ b/ext/phalcon/mvc/view/engine/volt.zep.c @@ -106,7 +106,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, callMacro) zephir_get_arrval(&arguments, arguments_param); } zephir_memory_observe(¯o); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1159, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1168, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(!(zephir_array_isset_fetch(¯o, &_0, &name_zv, 0)))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_mvc_view_engine_volt_exceptions_macronotfound_ce); @@ -208,27 +208,27 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, getCompiler) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1160, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1169, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&compiler, &_0); if (Z_TYPE_P(&compiler) != IS_OBJECT) { ZEPHIR_INIT_NVAR(&compiler); object_init_ex(&compiler, phalcon_mvc_view_engine_volt_compiler_ce); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1161, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1170, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &compiler, "__construct", NULL, 0, &_1$$3); zephir_check_call_status(); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 1162, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 1171, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_2$$3); if (Z_TYPE_P(&container) == IS_OBJECT) { ZEPHIR_CALL_METHOD(NULL, &compiler, "setdi", NULL, 0, &container); zephir_check_call_status(); } - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_3, 1163, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_3, 1172, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_2$$3); if (Z_TYPE_P(&options) == IS_ARRAY) { ZEPHIR_CALL_METHOD(NULL, &compiler, "setoptions", NULL, 0, &options); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1160, &compiler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1169, &compiler); } RETURN_CCTOR(&compiler); } @@ -416,7 +416,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, preload) } zephir_memory_observe(&href); zephir_array_isset_long_fetch(&href, ¶ms, 0, 0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1162, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1171, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_1); ZEPHIR_INIT_VAR(&_3); ZVAL_STRING(&_3, "response"); @@ -537,7 +537,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, render) } ZEPHIR_CALL_METHOD(&compiler, this_ptr, "getcompiler", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1164, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1173, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_0); if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_2$$4); @@ -612,7 +612,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, render) RETURN_MM_NULL(); } if (mustClean) { - zephir_read_property_cached(&_12$$11, this_ptr, _zephir_prop_1, 1161, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$11, this_ptr, _zephir_prop_1, 1170, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_13$$11, "ob_get_contents", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_12$$11, "setcontent", NULL, 0, &_13$$11); @@ -643,7 +643,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, setEventsManager) Z_PARAM_OBJECT_OF_CLASS(eventsManager, phalcon_events_managerinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &eventsManager); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1164, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1173, eventsManager); } /** @@ -673,7 +673,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, setOptions) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &options_param); zephir_get_arrval(&options, options_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1163, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1172, &options); ZEPHIR_MM_RESTORE(); } @@ -763,7 +763,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, slice) } if (Z_TYPE_P(value) == IS_ARRAY) { ZVAL_LONG(&_5$$9, start); - ZEPHIR_RETURN_CALL_FUNCTION("array_slice", NULL, 264, value, &_5$$9, &length); + ZEPHIR_RETURN_CALL_FUNCTION("array_slice", NULL, 270, value, &_5$$9, &length); zephir_check_call_status(); RETURN_MM(); } @@ -774,12 +774,12 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, slice) if (zephir_is_true(&_6)) { if (Z_TYPE_P(&length) != IS_NULL) { ZVAL_LONG(&_8$$11, start); - ZEPHIR_RETURN_CALL_FUNCTION("mb_substr", NULL, 290, value, &_8$$11, &length); + ZEPHIR_RETURN_CALL_FUNCTION("mb_substr", NULL, 296, value, &_8$$11, &length); zephir_check_call_status(); RETURN_MM(); } ZVAL_LONG(&_9$$10, start); - ZEPHIR_RETURN_CALL_FUNCTION("mb_substr", NULL, 290, value, &_9$$10); + ZEPHIR_RETURN_CALL_FUNCTION("mb_substr", NULL, 296, value, &_9$$10); zephir_check_call_status(); RETURN_MM(); } @@ -842,7 +842,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, phpExtensionLoaded) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 431, &name_zv); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/mvc/view/engine/volt/compiler.zep.c b/ext/phalcon/mvc/view/engine/volt/compiler.zep.c index 645f1caaa2..12eab40c2b 100644 --- a/ext/phalcon/mvc/view/engine/volt/compiler.zep.c +++ b/ext/phalcon/mvc/view/engine/volt/compiler.zep.c @@ -170,7 +170,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, __construct) view = &view_sub; view = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1165, view); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1174, view); } /** @@ -326,7 +326,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, attributeReader) zephir_array_fetch_string(&variable, &left, SL("value"), PH_NOISY, "phalcon/Mvc/View/Engine/Volt/Compiler.zep", 246); if (ZEPHIR_IS_STRING(&variable, "loop")) { zephir_memory_observe(&level); - zephir_read_property_cached(&level, this_ptr, _zephir_prop_0, 1166, PH_NOISY_CC); + zephir_read_property_cached(&level, this_ptr, _zephir_prop_0, 1175, PH_NOISY_CC); ZEPHIR_CALL_METHOD(&_1$$4, this_ptr, "getuniqueprefix", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_2$$4); @@ -334,10 +334,10 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, attributeReader) zephir_concat_self(&exprCode, &_2$$4); zephir_update_property_array(this_ptr, SL("loopPointers"), &level, &level); } else { - zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_1, 1167, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_1, 1176, PH_NOISY_CC | PH_READONLY); _4$$5 = Z_TYPE_P(&_3$$5) != IS_NULL; if (_4$$5) { - zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 1167, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 1176, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_6$$5, &_5$$5, "has", NULL, 0, &variable); zephir_check_call_status(); _4$$5 = zephir_is_true(&_6$$5); @@ -508,31 +508,31 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compile) } else { } if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1168, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1177, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1168, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1177, &__$false); } if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1169, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1178, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1169, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1178, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1170, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1179, &__$null); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1171, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1180, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1166, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1175, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1172, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1181, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1173, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1182, &_0); ZEPHIR_INIT_VAR(&compilation); ZVAL_NULL(&compilation); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_7, 1174, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_7, 1183, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); zephir_memory_observe(&compileAlways); if (!(zephir_array_isset_string_fetch(&compileAlways, &options, SL("always"), 0))) { @@ -751,7 +751,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compile) } } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1175, &compiledTemplatePath); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1184, &compiledTemplatePath); RETURN_CCTOR(&compilation); } @@ -803,8 +803,8 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileAutoEscape) return; } zephir_memory_observe(&oldAutoescape); - zephir_read_property_cached(&oldAutoescape, this_ptr, _zephir_prop_0, 1176, PH_NOISY_CC); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1176, &autoescape); + zephir_read_property_cached(&oldAutoescape, this_ptr, _zephir_prop_0, 1185, PH_NOISY_CC); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1185, &autoescape); zephir_array_fetch_string(&_1, &statement, SL("block_statements"), PH_NOISY | PH_READONLY, "phalcon/Mvc/View/Engine/Volt/Compiler.zep", 543); if (extendsMode) { ZVAL_BOOL(&_2, 1); @@ -813,7 +813,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileAutoEscape) } ZEPHIR_CALL_METHOD(&compilation, this_ptr, "statementlist", NULL, 0, &_1, &_2); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1176, &oldAutoescape); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1185, &oldAutoescape); RETURN_CCTOR(&compilation); } @@ -1005,7 +1005,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileEcho) } } } - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 1176, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 1185, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_6)) { ZEPHIR_CONCAT_SVS(return_value, "escaper->html(", &exprCode, ") ?>"); RETURN_MM(); @@ -1149,7 +1149,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileFile) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1177, &path_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1186, &path_zv); if (extendsMode) { ZVAL_BOOL(&_4, 1); } else { @@ -1277,7 +1277,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileForeach) ZEPHIR_CALL_METHOD(&prefix, this_ptr, "getuniqueprefix", NULL, 0); zephir_check_call_status(); zephir_memory_observe(&level); - zephir_read_property_cached(&level, this_ptr, _zephir_prop_0, 1166, PH_NOISY_CC); + zephir_read_property_cached(&level, this_ptr, _zephir_prop_0, 1175, PH_NOISY_CC); ZEPHIR_INIT_VAR(&prefixLevel); ZEPHIR_CONCAT_VV(&prefixLevel, &prefix, &level); zephir_memory_observe(&expr); @@ -1350,7 +1350,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileForeach) ZEPHIR_CALL_METHOD(&code, this_ptr, "statementlist", NULL, 0, &blockStatements, &_6); zephir_check_call_status(); zephir_memory_observe(&loopContext); - zephir_read_property_cached(&loopContext, this_ptr, _zephir_prop_1, 1178, PH_NOISY_CC); + zephir_read_property_cached(&loopContext, this_ptr, _zephir_prop_1, 1187, PH_NOISY_CC); if (zephir_array_isset_value(&loopContext, &level)) { ZEPHIR_INIT_VAR(&_7$$11); ZEPHIR_CONCAT_SVSVS(&_7$$11, ""); RETURN_MM(); @@ -1741,7 +1741,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileMacro) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1180, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1189, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(zephir_array_isset_value(&_1, &name))) { ZEPHIR_INIT_VAR(&_2$$4); object_init_ex(&_2$$4, phalcon_mvc_view_engine_volt_exceptions_macroalreadydefined_ce); @@ -2194,7 +2194,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileString) ZEPHIR_INIT_VAR(&_0); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "eval code"); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1177, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1186, &_0); if (extendsMode) { ZVAL_BOOL(&_1, 1); } else { @@ -2373,7 +2373,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, expression) ZEPHIR_INIT_VAR(&exprCode); ZVAL_NULL(&exprCode); RETURN_ON_FAILURE(zephir_property_incr(this_ptr, SL("exprLevel"))); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1181, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1190, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extensions, &_0); while (1) { if (Z_TYPE_P(&extensions) == IS_ARRAY) { @@ -2886,7 +2886,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, fireExtensionEvent) } else { zephir_get_arrval(&arguments, arguments_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1181, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1190, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extensions, &_0); zephir_is_iterable(&extensions, 0, "phalcon/Mvc/View/Engine/Volt/Compiler.zep", 1760); if (Z_TYPE_P(&extensions) == IS_ARRAY) { @@ -3088,7 +3088,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, functionCall) if (ZEPHIR_IS_LONG(&nameType, 265)) { zephir_memory_observe(&name); zephir_array_fetch_string(&name, &nameExpr, SL("value"), PH_NOISY, "phalcon/Mvc/View/Engine/Volt/Compiler.zep", 1797); - zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_0, 1181, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_0, 1190, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extensions, &_1$$5); if (Z_TYPE_P(&extensions) == IS_ARRAY) { ZEPHIR_INIT_VAR(&_2$$6); @@ -3104,7 +3104,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, functionCall) RETURN_CCTOR(&code); } } - zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_1, 1182, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_1, 1191, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&functions, &_1$$5); if (Z_TYPE_P(&functions) == IS_ARRAY) { zephir_memory_observe(&definition); @@ -3152,14 +3152,14 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, functionCall) RETURN_MM(); } if (ZEPHIR_IS_STRING(&name, "super")) { - zephir_read_property_cached(&_12$$15, this_ptr, _zephir_prop_2, 1169, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$15, this_ptr, _zephir_prop_2, 1178, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extendedBlocks, &_12$$15); if (Z_TYPE_P(&extendedBlocks) == IS_ARRAY) { - zephir_read_property_cached(&_13$$16, this_ptr, _zephir_prop_3, 1183, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$16, this_ptr, _zephir_prop_3, 1192, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(¤tBlock, &_13$$16); zephir_memory_observe(&block); if (zephir_array_isset_fetch(&block, &extendedBlocks, ¤tBlock, 0)) { - zephir_read_property_cached(&_14$$17, this_ptr, _zephir_prop_4, 1173, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$17, this_ptr, _zephir_prop_4, 1182, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&exprLevel, &_14$$17); if (Z_TYPE_P(&block) == IS_ARRAY) { ZEPHIR_CALL_METHOD(&code, this_ptr, "statementlistorextends", NULL, 0, &block); @@ -3223,10 +3223,10 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, functionCall) ZEPHIR_CONCAT_SVSVS(return_value, "\\Phalcon\\Tag::", &method, "(", &arguments, ")"); RETURN_MM(); } - zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_5, 1167, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_5, 1176, PH_NOISY_CC | PH_READONLY); _17$$5 = Z_TYPE_P(&_1$$5) != IS_NULL; if (_17$$5) { - zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_5, 1167, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_5, 1176, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_20$$5); ZVAL_STRING(&_20$$5, "tag"); ZEPHIR_CALL_METHOD(&_19$$5, &_18$$5, "has", NULL, 0, &_20$$5); @@ -3234,7 +3234,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, functionCall) _17$$5 = ZEPHIR_IS_TRUE_IDENTICAL(&_19$$5); } if (_17$$5) { - zephir_read_property_cached(&_21$$28, this_ptr, _zephir_prop_5, 1167, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$28, this_ptr, _zephir_prop_5, 1176, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_22$$28); ZVAL_STRING(&_22$$28, "tag"); ZEPHIR_CALL_METHOD(&tagService, &_21$$28, "get", NULL, 0, &_22$$28); @@ -3385,7 +3385,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, getOption) zephir_memory_observe(&option_zv); ZVAL_STR_COPY(&option_zv, option); zephir_memory_observe(&value); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1174, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1183, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&value, &_0, &option_zv, 0))) { RETURN_MM_NULL(); } @@ -3449,31 +3449,31 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, getUniquePrefix) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1184, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1193, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_INIT_VAR(&_1$$3); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 1177, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 1186, PH_NOISY_CC | PH_READONLY); zephir_unique_path_key(&_1$$3, &_2$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1184, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1193, &_1$$3); } zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1184, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1193, PH_NOISY_CC); if (Z_TYPE_P(&_3) == IS_OBJECT) { zephir_memory_observe(&_4$$4); - zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_0, 1184, PH_NOISY_CC); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_0, 1193, PH_NOISY_CC); if (zephir_is_instance_of(&_4$$4, SL("Closure"))) { ZEPHIR_INIT_VAR(&_5$$5); - zephir_read_property_cached(&_6$$5, this_ptr, _zephir_prop_0, 1184, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$5, this_ptr, _zephir_prop_0, 1193, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_7$$5); zephir_create_array(&_7$$5, 1, 0); zephir_array_fast_append(&_7$$5, this_ptr); ZEPHIR_CALL_USER_FUNC_ARRAY(&_5$$5, &_6$$5, &_7$$5); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1184, &_5$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1193, &_5$$5); } } zephir_memory_observe(&_8); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 1184, PH_NOISY_CC); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 1193, PH_NOISY_CC); if (UNEXPECTED(Z_TYPE_P(&_8) != IS_STRING)) { ZEPHIR_INIT_VAR(&_9$$6); object_init_ex(&_9$$6, phalcon_mvc_view_engine_volt_exceptions_invalidcompilationprefix_ce); @@ -3644,7 +3644,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, setDI) Z_PARAM_OBJECT_OF_CLASS(container, phalcon_di_diinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &container); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1167, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1176, container); } /** @@ -3693,7 +3693,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, setOptions) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &options_param); zephir_get_arrval(&options, options_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1174, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1183, &options); RETURN_THIS(); } @@ -3716,7 +3716,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, setUniquePrefix) Z_PARAM_STR(prefix) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&prefix_zv, prefix); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1184, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1193, &prefix_zv); RETURN_THISW(); } @@ -3800,9 +3800,9 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileSource) extendsMode = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1177, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1186, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(¤tPath, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1174, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1183, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); if (Z_TYPE_P(&options) == IS_ARRAY) { zephir_memory_observe(&autoescape); @@ -3820,7 +3820,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileSource) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1176, &autoescape); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1185, &autoescape); } } ZEPHIR_INIT_VAR(&intermediate); @@ -3842,7 +3842,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileSource) } ZEPHIR_CALL_METHOD(&compilation, this_ptr, "statementlist", NULL, 0, &intermediate, &_0); zephir_check_call_status(); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_3, 1168, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_3, 1177, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extended, &_5); if (ZEPHIR_IS_TRUE_IDENTICAL(&extended)) { ZEPHIR_INIT_VAR(&finalCompilation); @@ -3851,9 +3851,9 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileSource) } else { ZVAL_NULL(&finalCompilation); } - zephir_read_property_cached(&_6$$7, this_ptr, _zephir_prop_4, 1170, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$7, this_ptr, _zephir_prop_4, 1179, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&blocks, &_6$$7); - zephir_read_property_cached(&_6$$7, this_ptr, _zephir_prop_5, 1169, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$7, this_ptr, _zephir_prop_5, 1178, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extendedBlocks, &_6$$7); if (Z_TYPE_P(&blocks) != IS_ARRAY) { ZEPHIR_INIT_NVAR(&blocks); @@ -3875,7 +3875,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileSource) if (zephir_array_key_exists(&blocks, &name)) { ZEPHIR_OBS_NVAR(&localBlock); zephir_array_fetch(&localBlock, &blocks, &name, PH_NOISY, "phalcon/Mvc/View/Engine/Volt/Compiler.zep", 2335); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1183, &name); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1192, &name); if (Z_TYPE_P(&localBlock) == IS_NULL) { ZEPHIR_INIT_NVAR(&localBlock); array_init(&localBlock); @@ -3927,7 +3927,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileSource) if (zephir_array_key_exists(&blocks, &name)) { ZEPHIR_OBS_NVAR(&localBlock); zephir_array_fetch(&localBlock, &blocks, &name, PH_NOISY, "phalcon/Mvc/View/Engine/Volt/Compiler.zep", 2335); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1183, &name); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1192, &name); if (Z_TYPE_P(&localBlock) == IS_NULL) { ZEPHIR_INIT_NVAR(&localBlock); array_init(&localBlock); @@ -4018,13 +4018,13 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, getFinalPath) _1 = zephir_start_with_str(&path_zv, SL("../")); } if (_1) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 1177, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 1186, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_3$$4, "dirname", NULL, 0, &_2$$4); zephir_check_call_status(); ZEPHIR_CONCAT_VSV(return_value, &_3$$4, "/", &path_zv); RETURN_MM(); } - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1165, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1174, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&view, &_4); if (Z_TYPE_P(&view) == IS_OBJECT) { ZEPHIR_CALL_METHOD(&viewsDirs, &view, "getviewsdir", NULL, 0); @@ -4230,7 +4230,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, resolveFilter) } else { ZEPHIR_CPY_WRT(&arguments, &left_zv); } - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 1181, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 1190, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extensions, &_7); if (Z_TYPE_P(&extensions) == IS_ARRAY) { ZEPHIR_INIT_VAR(&_8$$9); @@ -4246,7 +4246,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, resolveFilter) RETURN_CCTOR(&code); } } - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 1185, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 1194, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&filters, &_7); zephir_memory_observe(&definition); if (zephir_array_isset_fetch(&definition, &filters, &name, 0)) { @@ -4350,10 +4350,10 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, resolveFilter) RETURN_MM(); } if (ZEPHIR_IS_STRING(&name, "lower") || ZEPHIR_IS_STRING(&name, "lowercase")) { - zephir_read_property_cached(&_23$$30, this_ptr, _zephir_prop_2, 1167, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$30, this_ptr, _zephir_prop_2, 1176, PH_NOISY_CC | PH_READONLY); _24$$30 = Z_TYPE_P(&_23$$30) != IS_NULL; if (_24$$30) { - zephir_read_property_cached(&_25$$30, this_ptr, _zephir_prop_2, 1167, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$30, this_ptr, _zephir_prop_2, 1176, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_27$$30); ZVAL_STRING(&_27$$30, "helper"); ZEPHIR_CALL_METHOD(&_26$$30, &_25$$30, "has", NULL, 0, &_27$$30); @@ -4401,10 +4401,10 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, resolveFilter) RETURN_MM(); } if (ZEPHIR_IS_STRING(&name, "upper") || ZEPHIR_IS_STRING(&name, "uppercase")) { - zephir_read_property_cached(&_28$$41, this_ptr, _zephir_prop_2, 1167, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$41, this_ptr, _zephir_prop_2, 1176, PH_NOISY_CC | PH_READONLY); _29$$41 = Z_TYPE_P(&_28$$41) != IS_NULL; if (_29$$41) { - zephir_read_property_cached(&_30$$41, this_ptr, _zephir_prop_2, 1167, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_30$$41, this_ptr, _zephir_prop_2, 1176, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_32$$41); ZVAL_STRING(&_32$$41, "helper"); ZEPHIR_CALL_METHOD(&_31$$41, &_30$$41, "has", NULL, 0, &_32$$41); @@ -4596,7 +4596,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, statementList) if (!(zephir_fast_count_int(&statements))) { RETURN_MM_STRING(""); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1168, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1177, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extended, &_0); _1 = zephir_is_true(&extended); if (!(_1)) { @@ -4610,7 +4610,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, statementList) RETURN_ON_FAILURE(zephir_property_incr(this_ptr, SL("level"))); ZEPHIR_INIT_VAR(&compilation); ZVAL_NULL(&compilation); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1181, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1190, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extensions, &_0); zephir_is_iterable(&statements, 0, "phalcon/Mvc/View/Engine/Volt/Compiler.zep", 2902); if (Z_TYPE_P(&statements) == IS_ARRAY) { @@ -4734,7 +4734,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, statementList) zephir_array_fetch_string(&blockName, &statement, SL("name"), PH_NOISY, "phalcon/Mvc/View/Engine/Volt/Compiler.zep", 2749); ZEPHIR_OBS_NVAR(&blockStatements); zephir_array_isset_string_fetch(&blockStatements, &statement, SL("block_statements"), 0); - zephir_read_property_cached(&_34$$20, this_ptr, _zephir_prop_2, 1170, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_34$$20, this_ptr, _zephir_prop_2, 1179, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&blocks, &_34$$20); if (zephir_is_true(&blockMode)) { if (Z_TYPE_P(&blocks) != IS_ARRAY) { @@ -4747,7 +4747,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, statementList) ZVAL_NULL(&compilation); } zephir_array_update_zval(&blocks, &blockName, &blockStatements, PH_COPY | PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1170, &blocks); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1179, &blocks); } else { if (Z_TYPE_P(&blockStatements) == IS_ARRAY) { if (extendsMode) { @@ -4783,11 +4783,11 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, statementList) zephir_check_call_status(); } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1168, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1177, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1168, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1177, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1169, &tempCompilation); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1178, &tempCompilation); ZEPHIR_CPY_WRT(&blockMode, &extended); break; } @@ -5010,7 +5010,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, statementList) zephir_array_fetch_string(&blockName, &statement, SL("name"), PH_NOISY, "phalcon/Mvc/View/Engine/Volt/Compiler.zep", 2749); ZEPHIR_OBS_NVAR(&blockStatements); zephir_array_isset_string_fetch(&blockStatements, &statement, SL("block_statements"), 0); - zephir_read_property_cached(&_89$$54, this_ptr, _zephir_prop_2, 1170, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_89$$54, this_ptr, _zephir_prop_2, 1179, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&blocks, &_89$$54); if (zephir_is_true(&blockMode)) { if (Z_TYPE_P(&blocks) != IS_ARRAY) { @@ -5023,7 +5023,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, statementList) ZVAL_NULL(&compilation); } zephir_array_update_zval(&blocks, &blockName, &blockStatements, PH_COPY | PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1170, &blocks); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1179, &blocks); } else { if (Z_TYPE_P(&blockStatements) == IS_ARRAY) { if (extendsMode) { @@ -5059,11 +5059,11 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, statementList) zephir_check_call_status(); } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1168, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1177, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1168, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1177, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1169, &tempCompilation); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1178, &tempCompilation); ZEPHIR_CPY_WRT(&blockMode, &extended); break; } @@ -5155,7 +5155,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, statementList) } ZEPHIR_INIT_NVAR(&statement); if (ZEPHIR_IS_TRUE_IDENTICAL(&blockMode)) { - zephir_read_property_cached(&level, this_ptr, _zephir_prop_4, 1172, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&level, this_ptr, _zephir_prop_4, 1181, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_LONG(&level, 1)) { if (Z_TYPE_P(&compilation) != IS_NULL) { zephir_update_property_array_append(this_ptr, SL("blocks"), &compilation); diff --git a/ext/phalcon/mvc/view/simple.zep.c b/ext/phalcon/mvc/view/simple.zep.c index 79b660fc28..17f45279bd 100644 --- a/ext/phalcon/mvc/view/simple.zep.c +++ b/ext/phalcon/mvc/view/simple.zep.c @@ -145,13 +145,13 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, __construct) } else { zephir_get_arrval(&options, options_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1186, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1195, &options); ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1187, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1196, &_0); ZEPHIR_INIT_VAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1188, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1197, &_1); ZEPHIR_MM_RESTORE(); } @@ -187,7 +187,7 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, __get) zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); zephir_memory_observe(&value); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1188, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1197, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&value, &_0, &key_zv, 0))) { RETURN_MM_NULL(); } @@ -318,7 +318,7 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, partial) ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(params) == IS_ARRAY) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1188, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1197, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&viewParams, &_0$$3); ZEPHIR_INIT_VAR(&mergedParams); zephir_fast_array_merge(&mergedParams, &viewParams, params); @@ -331,11 +331,11 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, partial) ZEPHIR_CALL_METHOD(NULL, this_ptr, "internalrender", NULL, 0, &partialPath_zv, &mergedParams); zephir_check_call_status(); if (Z_TYPE_P(params) == IS_ARRAY) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1188, &viewParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1197, &viewParams); } ZEPHIR_CALL_FUNCTION(NULL, "ob_end_clean", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1189, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1198, PH_NOISY_CC | PH_READONLY); zend_print_zval(&_2, 0); ZEPHIR_MM_RESTORE(); } @@ -375,7 +375,7 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, registerEngines) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &engines_param); zephir_get_arrval(&engines, engines_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1187, &engines); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1196, &engines); ZEPHIR_MM_RESTORE(); } @@ -427,7 +427,7 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, render) ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1188, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1197, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&viewParams, &_1); ZEPHIR_INIT_VAR(&mergedParams); zephir_fast_array_merge(&mergedParams, &viewParams, ¶ms); @@ -458,7 +458,7 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, setEventsManager) Z_PARAM_OBJECT_OF_CLASS(eventsManager, phalcon_events_managerinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &eventsManager); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1190, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1199, eventsManager); } /** @@ -538,11 +538,11 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, setVars) } if (merge) { ZEPHIR_INIT_VAR(&_0$$3); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1188, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1197, PH_NOISY_CC | PH_READONLY); zephir_fast_array_merge(&_0$$3, &_1$$3, ¶ms); ZEPHIR_CPY_WRT(¶ms, &_0$$3); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1188, ¶ms); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1197, ¶ms); RETURN_THIS(); } @@ -575,7 +575,7 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, setViewsDir) ZVAL_STR_COPY(&viewsDir_zv, viewsDir); ZEPHIR_CALL_METHOD(&_0, this_ptr, "todirseparator", NULL, 0, &viewsDir_zv); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1191, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1200, &_0); ZEPHIR_MM_RESTORE(); } @@ -631,14 +631,14 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, loadTemplateEngines) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1192, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1201, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&engines, &_0); if (ZEPHIR_IS_FALSE_IDENTICAL(&engines)) { zephir_memory_observe(&di); - zephir_read_property_cached(&di, this_ptr, _zephir_prop_1, 1193, PH_NOISY_CC); + zephir_read_property_cached(&di, this_ptr, _zephir_prop_1, 1202, PH_NOISY_CC); ZEPHIR_INIT_NVAR(&engines); array_init(&engines); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 1187, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 1196, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(®isteredEngines, &_1$$3); if (ZEPHIR_IS_EMPTY(®isteredEngines)) { ZEPHIR_INIT_VAR(&_2$$4); @@ -748,9 +748,9 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, loadTemplateEngines) ZEPHIR_INIT_NVAR(&engineService); ZEPHIR_INIT_NVAR(&extension); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1192, &engines); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1201, &engines); } else { - zephir_read_property_cached(&_20$$19, this_ptr, _zephir_prop_0, 1192, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$19, this_ptr, _zephir_prop_0, 1201, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&engines, &_20$$19); } RETURN_CCTOR(&engines); @@ -833,10 +833,10 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, internalRender) params = ZEND_CALL_ARG(execute_data, 2); zephir_memory_observe(&path_zv); ZVAL_STR_COPY(&path_zv, path); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1190, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1199, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_0); if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1194, &path_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1203, &path_zv); } if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_2$$4); @@ -849,7 +849,7 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, internalRender) } notExists = 1; mustClean = 1; - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1191, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1200, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_3); ZEPHIR_CONCAT_VV(&_3, &_0, &path_zv); zephir_get_strval(&viewsDirPath, &_3); @@ -1508,7 +1508,7 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, getParamsToView) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1188, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1197, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } @@ -1533,7 +1533,7 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, getRegisteredEngines) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1187, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1196, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } @@ -1566,7 +1566,7 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, getVar) zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); zephir_memory_observe(&value); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1188, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1197, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&value, &_0, &key_zv, 0))) { RETURN_MM_NULL(); } @@ -1598,7 +1598,7 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, setContent) Z_PARAM_STR(content) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&content_zv, content); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1189, &content_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1198, &content_zv); RETURN_THISW(); } diff --git a/ext/phalcon/mvc/view/traits/viewparamstrait.zep.c b/ext/phalcon/mvc/view/traits/viewparamstrait.zep.c index c3c8a40522..f074e3b986 100644 --- a/ext/phalcon/mvc/view/traits/viewparamstrait.zep.c +++ b/ext/phalcon/mvc/view/traits/viewparamstrait.zep.c @@ -87,7 +87,7 @@ PHP_METHOD(Phalcon_Mvc_View_Traits_ViewParamsTrait, getParamsToView) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1195, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1204, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } @@ -112,7 +112,7 @@ PHP_METHOD(Phalcon_Mvc_View_Traits_ViewParamsTrait, getRegisteredEngines) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1196, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1205, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } @@ -145,7 +145,7 @@ PHP_METHOD(Phalcon_Mvc_View_Traits_ViewParamsTrait, getVar) zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); zephir_memory_observe(&value); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1195, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1204, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&value, &_0, &key_zv, 0))) { RETURN_MM_NULL(); } @@ -177,7 +177,7 @@ PHP_METHOD(Phalcon_Mvc_View_Traits_ViewParamsTrait, setContent) Z_PARAM_STR(content) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&content_zv, content); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1197, &content_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1206, &content_zv); RETURN_THISW(); } diff --git a/ext/phalcon/paginator/adapter/model.zep.c b/ext/phalcon/paginator/adapter/model.zep.c index 5773a80e25..2c8b55f5cb 100644 --- a/ext/phalcon/paginator/adapter/model.zep.c +++ b/ext/phalcon/paginator/adapter/model.zep.c @@ -184,12 +184,12 @@ PHP_METHOD(Phalcon_Paginator_Adapter_Model, paginate) ZEPHIR_INIT_VAR(&pageItems); array_init(&pageItems); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1198, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1207, PH_NOISY_CC); limit = zephir_get_intval(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1199, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1208, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&config, &_1); zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1200, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1209, PH_NOISY_CC); pageNumber = zephir_get_intval(&_2); zephir_array_fetch_string(&_3, &config, SL("model"), PH_NOISY | PH_READONLY, "phalcon/Paginator/Adapter/Model.zep", 119); ZEPHIR_CPY_WRT(&modelClass, &_3); @@ -258,7 +258,7 @@ PHP_METHOD(Phalcon_Paginator_Adapter_Model, paginate) ZVAL_LONG(&_6, rowcount); zephir_array_update_string(&_13, SL("total_items"), &_6, PH_COPY | PH_SEPARATE); zephir_memory_observe(&_14); - zephir_read_property_cached(&_14, this_ptr, _zephir_prop_0, 1198, PH_NOISY_CC); + zephir_read_property_cached(&_14, this_ptr, _zephir_prop_0, 1207, PH_NOISY_CC); zephir_array_update_string(&_13, SL("limit"), &_14, PH_COPY | PH_SEPARATE); add_assoc_long_ex(&_13, SL("first"), 1); ZEPHIR_INIT_NVAR(&_6); diff --git a/ext/phalcon/paginator/adapter/nativearray.zep.c b/ext/phalcon/paginator/adapter/nativearray.zep.c index 30f70e57bc..e37afb2562 100644 --- a/ext/phalcon/paginator/adapter/nativearray.zep.c +++ b/ext/phalcon/paginator/adapter/nativearray.zep.c @@ -97,7 +97,7 @@ PHP_METHOD(Phalcon_Paginator_Adapter_NativeArray, paginate) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1201, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1210, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&config, &_0); zephir_memory_observe(&items); zephir_array_fetch_string(&items, &config, SL("data"), PH_NOISY, "phalcon/Paginator/Adapter/NativeArray.zep", 52); @@ -111,10 +111,10 @@ PHP_METHOD(Phalcon_Paginator_Adapter_NativeArray, paginate) return; } zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1202, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1211, PH_NOISY_CC); show = zephir_get_intval(&_2); zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1203, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1212, PH_NOISY_CC); pageNumber = zephir_get_intval(&_3); if (pageNumber <= 0) { pageNumber = 1; @@ -130,7 +130,7 @@ PHP_METHOD(Phalcon_Paginator_Adapter_NativeArray, paginate) } ZVAL_LONG(&_0, (show * ((pageNumber - 1)))); ZVAL_LONG(&_5, show); - ZEPHIR_CALL_FUNCTION(&_6, "array_slice", NULL, 264, &items, &_0, &_5); + ZEPHIR_CALL_FUNCTION(&_6, "array_slice", NULL, 270, &items, &_0, &_5); zephir_check_call_status(); ZEPHIR_CPY_WRT(&items, &_6); if (pageNumber < totalPages) { @@ -150,7 +150,7 @@ PHP_METHOD(Phalcon_Paginator_Adapter_NativeArray, paginate) ZVAL_LONG(&_8, number); zephir_array_update_string(&_7, SL("total_items"), &_8, PH_COPY | PH_SEPARATE); zephir_memory_observe(&_9); - zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1202, PH_NOISY_CC); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1211, PH_NOISY_CC); zephir_array_update_string(&_7, SL("limit"), &_9, PH_COPY | PH_SEPARATE); add_assoc_long_ex(&_7, SL("first"), 1); ZEPHIR_INIT_NVAR(&_8); diff --git a/ext/phalcon/paginator/adapter/querybuilder.zep.c b/ext/phalcon/paginator/adapter/querybuilder.zep.c index c4a37fe257..92aa69a4c2 100644 --- a/ext/phalcon/paginator/adapter/querybuilder.zep.c +++ b/ext/phalcon/paginator/adapter/querybuilder.zep.c @@ -132,7 +132,7 @@ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilder, __construct) } zephir_memory_observe(&columns); if (zephir_array_isset_string_fetch(&columns, &config, SL("columns"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1204, &columns); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1213, &columns); } ZEPHIR_CALL_PARENT(NULL, phalcon_paginator_adapter_querybuilder_ce, getThis(), "__construct", NULL, 0, &config); zephir_check_call_status(); @@ -261,8 +261,8 @@ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilder, paginate) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&originalBuilder); - zephir_read_property_cached(&originalBuilder, this_ptr, _zephir_prop_0, 1205, PH_NOISY_CC); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1204, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&originalBuilder, this_ptr, _zephir_prop_0, 1214, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1213, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&columns, &_0); hasMultipleGroups = 0; ZEPHIR_INIT_VAR(&builder); @@ -274,9 +274,9 @@ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilder, paginate) RETURN_MM(); } zephir_memory_observe(&limit); - zephir_read_property_cached(&limit, this_ptr, _zephir_prop_2, 1206, PH_NOISY_CC); + zephir_read_property_cached(&limit, this_ptr, _zephir_prop_2, 1215, PH_NOISY_CC); zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1207, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1216, PH_NOISY_CC); numberPage = zephir_get_intval(&_1); if (!(numberPage)) { numberPage = 1; @@ -508,7 +508,7 @@ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilder, paginate) zephir_array_update_string(&_43, SL("items"), &items, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_43, SL("total_items"), &rowcount, PH_COPY | PH_SEPARATE); zephir_memory_observe(&_44); - zephir_read_property_cached(&_44, this_ptr, _zephir_prop_2, 1206, PH_NOISY_CC); + zephir_read_property_cached(&_44, this_ptr, _zephir_prop_2, 1215, PH_NOISY_CC); zephir_array_update_string(&_43, SL("limit"), &_44, PH_COPY | PH_SEPARATE); add_assoc_long_ex(&_43, SL("first"), 1); ZEPHIR_INIT_VAR(&_45); @@ -542,7 +542,7 @@ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilder, setQueryBuilder) Z_PARAM_OBJECT_OF_CLASS(builder, phalcon_mvc_model_query_builder_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &builder); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1205, builder); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1214, builder); RETURN_THISW(); } diff --git a/ext/phalcon/paginator/adapter/querybuildercursor.zep.c b/ext/phalcon/paginator/adapter/querybuildercursor.zep.c index 7f30e003cb..af2bc2b9e8 100644 --- a/ext/phalcon/paginator/adapter/querybuildercursor.zep.c +++ b/ext/phalcon/paginator/adapter/querybuildercursor.zep.c @@ -174,10 +174,10 @@ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilderCursor, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1208, &cursorColumn); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1217, &cursorColumn); zephir_memory_observe(&cursor); if (zephir_array_isset_string_fetch(&cursor, &config, SL("cursor"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1209, &cursor); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1218, &cursor); } ZEPHIR_CALL_PARENT(NULL, phalcon_paginator_adapter_querybuildercursor_ce, getThis(), "__construct", NULL, 0, &config); zephir_check_call_status(); @@ -225,12 +225,12 @@ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilderCursor, getCurrentPage) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1209, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1218, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { RETURN_MM_LONG(0); } zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1209, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1218, PH_NOISY_CC); RETURN_MM_LONG(zephir_get_intval(&_1)); } @@ -298,24 +298,24 @@ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilderCursor, paginate) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1210, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1219, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); if (zephir_clone(&_1, &_0) == FAILURE) { RETURN_MM(); } ZEPHIR_CPY_WRT(&builder, &_1); zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1211, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1220, PH_NOISY_CC); limit = zephir_get_intval(&_2); zephir_memory_observe(¤tCursor); - zephir_read_property_cached(¤tCursor, this_ptr, _zephir_prop_2, 1209, PH_NOISY_CC); + zephir_read_property_cached(¤tCursor, this_ptr, _zephir_prop_2, 1218, PH_NOISY_CC); if (Z_TYPE_P(¤tCursor) == IS_NULL) { currentPage = 0; } else { currentPage = zephir_get_intval(¤tCursor); } if (Z_TYPE_P(¤tCursor) != IS_NULL) { - zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_3, 1208, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_3, 1217, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_4$$5); ZEPHIR_CONCAT_SVS(&_4$$5, "[", &_3$$5, "] > :cursor:"); ZEPHIR_INIT_VAR(&_5$$5); @@ -341,7 +341,7 @@ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilderCursor, paginate) zephir_memory_observe(&lastItem); zephir_array_fetch_long(&lastItem, &items, (zephir_fast_count_int(&items) - 1), PH_NOISY, "phalcon/Paginator/Adapter/QueryBuilderCursor.zep", 220); zephir_memory_observe(&_8$$6); - zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_3, 1208, PH_NOISY_CC); + zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_3, 1217, PH_NOISY_CC); zephir_array_fetch(&_7$$6, &lastItem, &_8$$6, PH_NOISY | PH_READONLY, "phalcon/Paginator/Adapter/QueryBuilderCursor.zep", 226); if (UNEXPECTED(!(zephir_is_numeric(&_7$$6)))) { ZEPHIR_INIT_VAR(&_9$$7); @@ -354,7 +354,7 @@ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilderCursor, paginate) } zephir_memory_observe(&_10$$6); zephir_memory_observe(&_11$$6); - zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_3, 1208, PH_NOISY_CC); + zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_3, 1217, PH_NOISY_CC); zephir_array_fetch(&_10$$6, &lastItem, &_11$$6, PH_NOISY, "phalcon/Paginator/Adapter/QueryBuilderCursor.zep", 230); nextCursor = zephir_get_intval(&_10$$6); } else { @@ -365,7 +365,7 @@ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilderCursor, paginate) zephir_array_update_string(&_12, SL("items"), &items, PH_COPY | PH_SEPARATE); add_assoc_long_ex(&_12, SL("total_items"), 0); zephir_memory_observe(&_13); - zephir_read_property_cached(&_13, this_ptr, _zephir_prop_1, 1211, PH_NOISY_CC); + zephir_read_property_cached(&_13, this_ptr, _zephir_prop_1, 1220, PH_NOISY_CC); zephir_array_update_string(&_12, SL("limit"), &_13, PH_COPY | PH_SEPARATE); add_assoc_long_ex(&_12, SL("first"), 1); add_assoc_long_ex(&_12, SL("previous"), 0); @@ -402,7 +402,7 @@ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilderCursor, setCursor) Z_PARAM_ZVAL(cursor) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &cursor); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1209, cursor); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1218, cursor); RETURN_THISW(); } @@ -424,7 +424,7 @@ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilderCursor, setQueryBuilder) Z_PARAM_OBJECT_OF_CLASS(builder, phalcon_mvc_model_query_builder_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &builder); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1210, builder); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1219, builder); RETURN_THISW(); } diff --git a/ext/phalcon/paginator/exceptions/missingrequiredparameter.zep.c b/ext/phalcon/paginator/exceptions/missingrequiredparameter.zep.c index bdf1af7a82..c064aead58 100644 --- a/ext/phalcon/paginator/exceptions/missingrequiredparameter.zep.c +++ b/ext/phalcon/paginator/exceptions/missingrequiredparameter.zep.c @@ -60,7 +60,7 @@ PHP_METHOD(Phalcon_Paginator_Exceptions_MissingRequiredParameter, __construct) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(¶meter_zv); ZVAL_STR_COPY(¶meter_zv, parameter); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1212, ¶meter_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1221, ¶meter_zv); ZEPHIR_INIT_VAR(&_0); ZEPHIR_CONCAT_SVS(&_0, "Parameter '", ¶meter_zv, "' is required"); ZEPHIR_CALL_PARENT(NULL, phalcon_paginator_exceptions_missingrequiredparameter_ce, getThis(), "__construct", NULL, 0, &_0); diff --git a/ext/phalcon/paginator/repository.zep.c b/ext/phalcon/paginator/repository.zep.c index c1c695da90..bd99b6c162 100644 --- a/ext/phalcon/paginator/repository.zep.c +++ b/ext/phalcon/paginator/repository.zep.c @@ -323,7 +323,7 @@ PHP_METHOD(Phalcon_Paginator_Repository, setAliases) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &aliases_param); zephir_get_arrval(&aliases, aliases_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1213, &aliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1222, &aliases); RETURN_THIS(); } @@ -350,7 +350,7 @@ PHP_METHOD(Phalcon_Paginator_Repository, setProperties) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &properties_param); zephir_get_arrval(&properties, properties_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1214, &properties); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1223, &properties); RETURN_THIS(); } @@ -392,7 +392,7 @@ PHP_METHOD(Phalcon_Paginator_Repository, getProperty) defaultValue = &__$null; } zephir_memory_observe(&value); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1214, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1223, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&value, &_0, &property_zv, 0))) { ZEPHIR_CPY_WRT(&value, defaultValue); } @@ -425,7 +425,7 @@ PHP_METHOD(Phalcon_Paginator_Repository, getRealNameProperty) zephir_memory_observe(&property_zv); ZVAL_STR_COPY(&property_zv, property); zephir_memory_observe(&name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1213, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1222, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&name, &_0, &property_zv, 0))) { RETURN_MM_STR(zend_string_copy(property)); } diff --git a/ext/phalcon/queue/adapter/beanstalk/beanstalkconnection.zep.c b/ext/phalcon/queue/adapter/beanstalk/beanstalkconnection.zep.c index b0db2b163c..31674749de 100644 --- a/ext/phalcon/queue/adapter/beanstalk/beanstalkconnection.zep.c +++ b/ext/phalcon/queue/adapter/beanstalk/beanstalkconnection.zep.c @@ -148,19 +148,19 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, __construct) persistent = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1215, &host_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1224, &host_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, port); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1216, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1225, &_0); if (persistent) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1217, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1226, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1217, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1226, &__$false); } ZEPHIR_INIT_VAR(&_1); zephir_create_array(&_1, 1, 0); zephir_array_update_string(&_1, SL("default"), &__$true, PH_COPY | PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1218, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1227, &_1); ZEPHIR_MM_RESTORE(); } @@ -244,7 +244,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, connect) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1219, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1228, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&connection, &_0); if (Z_TYPE_P(&connection) == IS_RESOURCE) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "disconnect", NULL, 0); @@ -253,10 +253,10 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, connect) ZVAL_LONG(&_0, 0); ZEPHIR_CALL_FUNCTION(&errorLevel, "error_reporting", NULL, 0, &_0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1217, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1226, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { - zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_2, 1215, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 1216, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_2, 1224, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 1225, PH_NOISY_CC | PH_READONLY); ZVAL_NULL(&_3$$4); ZVAL_NULL(&_4$$4); ZEPHIR_MAKE_REF(&_3$$4); @@ -266,8 +266,8 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, connect) ZEPHIR_UNREF(&_4$$4); zephir_check_call_status(); } else { - zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_2, 1215, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6$$5, this_ptr, _zephir_prop_3, 1216, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_2, 1224, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$5, this_ptr, _zephir_prop_3, 1225, PH_NOISY_CC | PH_READONLY); ZVAL_NULL(&_7$$5); ZVAL_NULL(&_8$$5); ZEPHIR_MAKE_REF(&_7$$5); @@ -287,7 +287,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, connect) ZVAL_LONG(&_10, 0); ZEPHIR_CALL_FUNCTION(NULL, "stream_set_timeout", NULL, 0, &connection, &_9, &_10); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1219, &connection); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1228, &connection); ZEPHIR_CALL_METHOD(NULL, this_ptr, "restoresession", NULL, 0); zephir_check_call_status(); RETURN_CCTOR(&connection); @@ -346,14 +346,14 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, disconnect) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1219, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1228, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&connection, &_0); if (Z_TYPE_P(&connection) != IS_RESOURCE) { RETURN_MM_BOOL(0); } ZEPHIR_CALL_METHOD(NULL, this_ptr, "phpfclose", NULL, 0, &connection); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1219, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1228, &__$null); RETURN_MM_BOOL(1); } @@ -397,7 +397,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, ignoreTube) result = ZEPHIR_IS_STRING(&_2, "WATCHING"); if (result) { zephir_unset_property_array(this_ptr, ZEND_STRL("watchedTubes"), &tube_zv); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 1218, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 1227, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_3$$3, &tube_zv, PH_SEPARATE); } RETURN_MM_BOOL(result); @@ -507,7 +507,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, read) length = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1219, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1228, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&connection, &_0); if (Z_TYPE_P(&connection) != IS_RESOURCE) { ZEPHIR_CALL_METHOD(&connection, this_ptr, "connect", NULL, 0); @@ -811,7 +811,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, useTube) zephir_array_fetch_long(&_2, &_1, 0, PH_NOISY | PH_READONLY, "phalcon/Queue/Adapter/Beanstalk/BeanstalkConnection.zep", 347); result = ZEPHIR_IS_STRING(&_2, "USING"); if (result) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1220, &tube_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1229, &tube_zv); } RETURN_MM_BOOL(result); } @@ -884,7 +884,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, write) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&data_zv); ZVAL_STR_COPY(&data_zv, data); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1219, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1228, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&connection, &_0); if (Z_TYPE_P(&connection) != IS_RESOURCE) { ZEPHIR_CALL_METHOD(&connection, this_ptr, "connect", NULL, 0); @@ -1014,9 +1014,9 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, restoreSession) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1220, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1229, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_STRING(&_0, "default")) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1220, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1229, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2$$3); ZEPHIR_CONCAT_SV(&_2$$3, "use ", &_1$$3); ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, &_2$$3); @@ -1025,7 +1025,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, restoreSession) zephir_check_call_status(); } ZEPHIR_INIT_VAR(&_3); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1218, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1227, PH_NOISY_CC | PH_READONLY); zephir_array_keys(&_3, &_4); zephir_is_iterable(&_3, 0, "phalcon/Queue/Adapter/Beanstalk/BeanstalkConnection.zep", 452); ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_3), _5) @@ -1042,7 +1042,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, restoreSession) } } ZEND_HASH_FOREACH_END(); ZEPHIR_INIT_NVAR(&tube); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 1218, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 1227, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value_string(&_7, SL("default")))) { ZEPHIR_INIT_VAR(&_8$$6); ZVAL_STRING(&_8$$6, "ignore default"); diff --git a/ext/phalcon/queue/adapter/beanstalk/beanstalkconnectionfactory.zep.c b/ext/phalcon/queue/adapter/beanstalk/beanstalkconnectionfactory.zep.c index 4ad13e2be9..586a4ad34f 100644 --- a/ext/phalcon/queue/adapter/beanstalk/beanstalkconnectionfactory.zep.c +++ b/ext/phalcon/queue/adapter/beanstalk/beanstalkconnectionfactory.zep.c @@ -86,7 +86,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnectionFactory, __constru } else { zephir_get_arrval(&options, options_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1221, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1230, &options); ZEPHIR_MM_RESTORE(); } @@ -114,7 +114,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnectionFactory, createCon ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1221, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1230, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); if (zephir_array_isset_value_string(&options, SL("host"))) { zephir_memory_observe(&host); diff --git a/ext/phalcon/queue/adapter/beanstalk/beanstalkconsumer.zep.c b/ext/phalcon/queue/adapter/beanstalk/beanstalkconsumer.zep.c index 596555eb14..afa59a3eb5 100644 --- a/ext/phalcon/queue/adapter/beanstalk/beanstalkconsumer.zep.c +++ b/ext/phalcon/queue/adapter/beanstalk/beanstalkconsumer.zep.c @@ -89,8 +89,8 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConsumer, __construct) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 2, 0, &connection, &queue); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1222, connection); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1223, queue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1231, connection); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1232, queue); ZEPHIR_CALL_METHOD(&tube, queue, "getqueuename", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, connection, "watchtube", NULL, 0, &tube); @@ -125,7 +125,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConsumer, acknowledge) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &message); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1222, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1231, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "resolvejobid", NULL, 0, message); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_0, "deletejob", NULL, 0, &_1); @@ -165,7 +165,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConsumer, receive) } else { ZVAL_LONG(&seconds, (int) (zephir_safe_div_long_long(((timeout + 999)), 1000))); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1222, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1231, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "reserve", NULL, 0, &seconds); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "buildmessage", NULL, 0, &_1); @@ -190,7 +190,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConsumer, receiveNoWait) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1222, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1231, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2, 0); ZEPHIR_CALL_METHOD(&_1, &_0, "reserve", NULL, 0, &_2); zephir_check_call_status(); @@ -234,13 +234,13 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConsumer, reject) ZEPHIR_CALL_METHOD(&id, this_ptr, "resolvejobid", NULL, 0, message); zephir_check_call_status(); if (requeue) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1222, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1231, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1$$3, 100); ZVAL_LONG(&_2$$3, 0); ZEPHIR_CALL_METHOD(NULL, &_0$$3, "releasejob", NULL, 0, &id, &_1$$3, &_2$$3); zephir_check_call_status(); } else { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 1222, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 1231, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_4$$4, 100); ZEPHIR_CALL_METHOD(NULL, &_3$$4, "buryjob", NULL, 0, &id, &_4$$4); zephir_check_call_status(); @@ -272,7 +272,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConsumer, touch) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &message); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1222, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1231, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "resolvejobid", NULL, 0, message); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_0, "touchjob", NULL, 0, &_1); diff --git a/ext/phalcon/queue/adapter/beanstalk/beanstalkcontext.zep.c b/ext/phalcon/queue/adapter/beanstalk/beanstalkcontext.zep.c index c2c485411d..902e3944fb 100644 --- a/ext/phalcon/queue/adapter/beanstalk/beanstalkcontext.zep.c +++ b/ext/phalcon/queue/adapter/beanstalk/beanstalkcontext.zep.c @@ -145,21 +145,21 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkContext, __construct) pollInterval = 200; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1224, &host_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1233, &host_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, port); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1225, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1234, &_0); if (persistent) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1226, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1235, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1226, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1235, &__$false); } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, ttr); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1227, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1236, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1228, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1237, &_0); } PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkContext, close) @@ -179,12 +179,12 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkContext, close) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1229, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1238, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1229, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1238, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_1$$3, "disconnect", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1229, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1238, &__$null); } ZEPHIR_MM_RESTORE(); } @@ -298,7 +298,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkContext, createSubscriptionC zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); object_init_ex(return_value, phalcon_queue_adapter_beanstalk_beanstalksubscriptionconsumer_ce); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1228, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1237, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, this_ptr, &_0); zephir_check_call_status(); RETURN_MM(); @@ -477,11 +477,11 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkContext, getConnection) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1229, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1238, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "newconnection", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1229, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1238, &_1$$3); } RETURN_MM_MEMBER(getThis(), "connection"); } @@ -517,9 +517,9 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkContext, newConnection) ZEPHIR_INIT_VAR(&connection); object_init_ex(&connection, phalcon_queue_adapter_beanstalk_beanstalkconnection_ce); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1224, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1225, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1226, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1233, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1234, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1235, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &connection, "__construct", NULL, 0, &_0, &_1, &_2); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &connection, "connect", NULL, 0); diff --git a/ext/phalcon/queue/adapter/beanstalk/beanstalkmessage.zep.c b/ext/phalcon/queue/adapter/beanstalk/beanstalkmessage.zep.c index b3a49ddcb5..a90e9c0832 100644 --- a/ext/phalcon/queue/adapter/beanstalk/beanstalkmessage.zep.c +++ b/ext/phalcon/queue/adapter/beanstalk/beanstalkmessage.zep.c @@ -72,6 +72,6 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkMessage, setJobId) Z_PARAM_STR(jobId) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&jobId_zv, jobId); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1230, &jobId_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1239, &jobId_zv); } diff --git a/ext/phalcon/queue/adapter/beanstalk/beanstalkproducer.zep.c b/ext/phalcon/queue/adapter/beanstalk/beanstalkproducer.zep.c index 92a622e419..4789b0e1e6 100644 --- a/ext/phalcon/queue/adapter/beanstalk/beanstalkproducer.zep.c +++ b/ext/phalcon/queue/adapter/beanstalk/beanstalkproducer.zep.c @@ -86,7 +86,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkProducer, __construct) Z_PARAM_OBJECT_OF_CLASS(context, phalcon_queue_adapter_beanstalk_beanstalkcontext_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &context); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1231, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1240, context); } PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkProducer, getDeliveryDelay) @@ -151,32 +151,32 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkProducer, send) ZEPHIR_CALL_CE_STATIC(&payload, phalcon_queue_adapter_messageenvelope_ce, "encode", NULL, 0, message); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_1); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1232, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1241, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_2) == IS_NULL) { ZEPHIR_INIT_NVAR(&_1); ZVAL_LONG(&_1, 100); } else { zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1232, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1241, PH_NOISY_CC); ZEPHIR_INIT_NVAR(&_1); ZVAL_LONG(&_1, zephir_get_intval(&_3)); } priority = zephir_get_numberval(&_1); ZEPHIR_INIT_VAR(&_4); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 1233, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 1242, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_5) == IS_NULL) { ZEPHIR_INIT_NVAR(&_4); ZVAL_LONG(&_4, 0); } else { - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 1233, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 1242, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_4); ZVAL_LONG(&_4, (int) (zephir_safe_div_zval_long(&_6, 1000))); } delay = zephir_get_numberval(&_4); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 1231, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 1240, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_8, destination, "getqueuename", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 1231, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 1240, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_10, &_9, "getttr", NULL, 0); zephir_check_call_status(); ZVAL_LONG(&_11, priority); @@ -220,7 +220,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkProducer, setDeliveryDelay) ZEPHIR_INIT_NVAR(&_0); ZVAL_LONG(&_0, zephir_get_intval(deliveryDelay)); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1233, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1242, &_0); RETURN_THIS(); } @@ -258,7 +258,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkProducer, setPriority) ZEPHIR_INIT_NVAR(&_0); ZVAL_LONG(&_0, zephir_get_intval(priority)); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1232, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1241, &_0); RETURN_THIS(); } diff --git a/ext/phalcon/queue/adapter/beanstalk/beanstalksubscriptionconsumer.zep.c b/ext/phalcon/queue/adapter/beanstalk/beanstalksubscriptionconsumer.zep.c index 7e6b441957..ba2277b86e 100644 --- a/ext/phalcon/queue/adapter/beanstalk/beanstalksubscriptionconsumer.zep.c +++ b/ext/phalcon/queue/adapter/beanstalk/beanstalksubscriptionconsumer.zep.c @@ -79,9 +79,9 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkSubscriptionConsumer, __cons pollInterval = 200; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1234, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1243, context); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1235, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1244, &_0); } diff --git a/ext/phalcon/queue/adapter/genericqueue.zep.c b/ext/phalcon/queue/adapter/genericqueue.zep.c index fe66acb0d2..841004cdd7 100644 --- a/ext/phalcon/queue/adapter/genericqueue.zep.c +++ b/ext/phalcon/queue/adapter/genericqueue.zep.c @@ -68,7 +68,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_GenericQueue, __construct) Z_PARAM_STR(queueName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&queueName_zv, queueName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1236, &queueName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1245, &queueName_zv); } /** diff --git a/ext/phalcon/queue/adapter/generictopic.zep.c b/ext/phalcon/queue/adapter/generictopic.zep.c index 932fc771c6..77c4e44eb8 100644 --- a/ext/phalcon/queue/adapter/generictopic.zep.c +++ b/ext/phalcon/queue/adapter/generictopic.zep.c @@ -68,7 +68,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_GenericTopic, __construct) Z_PARAM_STR(topicName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&topicName_zv, topicName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1237, &topicName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1246, &topicName_zv); } /** diff --git a/ext/phalcon/queue/adapter/memory/memoryconnectionfactory.zep.c b/ext/phalcon/queue/adapter/memory/memoryconnectionfactory.zep.c index a95abba677..e6a235ccc0 100644 --- a/ext/phalcon/queue/adapter/memory/memoryconnectionfactory.zep.c +++ b/ext/phalcon/queue/adapter/memory/memoryconnectionfactory.zep.c @@ -81,7 +81,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Memory_MemoryConnectionFactory, __construct) } else { zephir_get_arrval(&options, options_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1238, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1247, &options); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/queue/adapter/memory/memoryconsumer.zep.c b/ext/phalcon/queue/adapter/memory/memoryconsumer.zep.c index d4b18da750..01fd53fb83 100644 --- a/ext/phalcon/queue/adapter/memory/memoryconsumer.zep.c +++ b/ext/phalcon/queue/adapter/memory/memoryconsumer.zep.c @@ -74,8 +74,8 @@ PHP_METHOD(Phalcon_Queue_Adapter_Memory_MemoryConsumer, __construct) Z_PARAM_OBJECT_OF_CLASS(queue, phalcon_contracts_queue_queue_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(2, 0, &context, &queue); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1239, context); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1240, queue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1248, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1249, queue); } /** @@ -116,8 +116,8 @@ PHP_METHOD(Phalcon_Queue_Adapter_Memory_MemoryConsumer, receiveNoWait) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1239, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1240, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1248, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1249, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "getqueuename", NULL, 0); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_0, "popmessage", NULL, 0, &_2); @@ -162,8 +162,8 @@ PHP_METHOD(Phalcon_Queue_Adapter_Memory_MemoryConsumer, reject) } else { } if (requeue) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1239, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1240, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1248, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1249, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2$$3, &_1$$3, "getqueuename", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_0$$3, "pushmessage", NULL, 0, &_2$$3, message); diff --git a/ext/phalcon/queue/adapter/memory/memorycontext.zep.c b/ext/phalcon/queue/adapter/memory/memorycontext.zep.c index d51309bc5d..ce0f4c2f7e 100644 --- a/ext/phalcon/queue/adapter/memory/memorycontext.zep.c +++ b/ext/phalcon/queue/adapter/memory/memorycontext.zep.c @@ -75,7 +75,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Memory_MemoryContext, close) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1241, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1250, &_0); ZEPHIR_MM_RESTORE(); } @@ -224,7 +224,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Memory_MemoryContext, popMessage) zephir_memory_observe(&queueName_zv); ZVAL_STR_COPY(&queueName_zv, queueName); zephir_memory_observe(&messages); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1241, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1250, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&messages, &_0, &queueName_zv, 0))) { RETURN_MM_NULL(); } @@ -296,7 +296,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Memory_MemoryContext, pushMessage) zephir_memory_observe(&queueName_zv); ZVAL_STR_COPY(&queueName_zv, queueName); zephir_memory_observe(&messages); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1241, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1250, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&messages, &_0, &queueName_zv, 0))) { ZEPHIR_INIT_NVAR(&messages); array_init(&messages); diff --git a/ext/phalcon/queue/adapter/memory/memoryproducer.zep.c b/ext/phalcon/queue/adapter/memory/memoryproducer.zep.c index 723792e160..0af724a06e 100644 --- a/ext/phalcon/queue/adapter/memory/memoryproducer.zep.c +++ b/ext/phalcon/queue/adapter/memory/memoryproducer.zep.c @@ -65,7 +65,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Memory_MemoryProducer, __construct) Z_PARAM_OBJECT_OF_CLASS(context, phalcon_queue_adapter_memory_memorycontext_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &context); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1242, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1251, context); } PHP_METHOD(Phalcon_Queue_Adapter_Memory_MemoryProducer, send) @@ -96,7 +96,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Memory_MemoryProducer, send) ZVAL_STRING(&_0, "send to"); ZEPHIR_CALL_CE_STATIC(NULL, phalcon_queue_adapter_queuedestinationguard_ce, "assertqueue", NULL, 0, destination, &_0); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1242, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1251, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, destination, "getqueuename", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_1, "pushmessage", NULL, 0, &_2, message); diff --git a/ext/phalcon/queue/adapter/memory/memorysubscriptionconsumer.zep.c b/ext/phalcon/queue/adapter/memory/memorysubscriptionconsumer.zep.c index 032357d9bf..2c45740516 100644 --- a/ext/phalcon/queue/adapter/memory/memorysubscriptionconsumer.zep.c +++ b/ext/phalcon/queue/adapter/memory/memorysubscriptionconsumer.zep.c @@ -66,6 +66,6 @@ PHP_METHOD(Phalcon_Queue_Adapter_Memory_MemorySubscriptionConsumer, __construct) Z_PARAM_OBJECT_OF_CLASS(context, phalcon_queue_adapter_memory_memorycontext_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &context); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1243, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1252, context); } diff --git a/ext/phalcon/queue/adapter/redis/redisconnectionfactory.zep.c b/ext/phalcon/queue/adapter/redis/redisconnectionfactory.zep.c index ebafe6681b..7f4a6637a6 100644 --- a/ext/phalcon/queue/adapter/redis/redisconnectionfactory.zep.c +++ b/ext/phalcon/queue/adapter/redis/redisconnectionfactory.zep.c @@ -94,7 +94,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisConnectionFactory, __construct) } else { zephir_get_arrval(&options, options_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1244, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1253, &options); ZEPHIR_MM_RESTORE(); } @@ -129,7 +129,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisConnectionFactory, createContext) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1244, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1253, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); if (zephir_array_isset_value_string(&options, SL("prefix"))) { zephir_memory_observe(&prefix); diff --git a/ext/phalcon/queue/adapter/redis/redisconsumer.zep.c b/ext/phalcon/queue/adapter/redis/redisconsumer.zep.c index f6880f5b3e..2c035c050b 100644 --- a/ext/phalcon/queue/adapter/redis/redisconsumer.zep.c +++ b/ext/phalcon/queue/adapter/redis/redisconsumer.zep.c @@ -73,8 +73,8 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisConsumer, __construct) Z_PARAM_OBJECT_OF_CLASS(queue, phalcon_contracts_queue_queue_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(2, 0, &context, &queue); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1245, context); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1246, queue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1254, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1255, queue); } /** @@ -127,7 +127,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisConsumer, receive) timeout = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1246, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1255, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&queueName, &_0, "getqueuename", NULL, 0); zephir_check_call_status(); deadline = 0; @@ -137,7 +137,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisConsumer, receive) deadline = ((zephir_get_numberval(&_1$$3) * 1000) + timeout); } while (1) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 1245, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 1254, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_3$$4, 1); ZEPHIR_CALL_METHOD(&message, &_2$$4, "blockingpop", NULL, 0, &queueName, &_3$$4); zephir_check_call_status(); @@ -178,8 +178,8 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisConsumer, receiveNoWait) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1245, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1246, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1254, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1255, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "getqueuename", NULL, 0); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_0, "popmessage", NULL, 0, &_2); @@ -221,8 +221,8 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisConsumer, reject) } else { } if (requeue) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1245, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1246, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1254, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1255, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2$$3, &_1$$3, "getqueuename", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_0$$3, "pushmessage", NULL, 0, &_2$$3, message); diff --git a/ext/phalcon/queue/adapter/redis/rediscontext.zep.c b/ext/phalcon/queue/adapter/redis/rediscontext.zep.c index 74e08b8be0..2db40032ec 100644 --- a/ext/phalcon/queue/adapter/redis/rediscontext.zep.c +++ b/ext/phalcon/queue/adapter/redis/rediscontext.zep.c @@ -119,11 +119,11 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, __construct) pollInterval = 200; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1247, redis); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1248, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1256, redis); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1257, &prefix_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1249, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1258, &_0); ZEPHIR_MM_RESTORE(); } @@ -165,7 +165,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, blockingPop) ZVAL_STR_COPY(&queueName_zv, queueName); ZEPHIR_CALL_METHOD(NULL, this_ptr, "promote", NULL, 0, &queueName_zv); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1256, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_create_array(&_1, 1, 0); ZEPHIR_CALL_METHOD(&_2, this_ptr, "listkey", NULL, 0, &queueName_zv); @@ -298,7 +298,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, createSubscriptionConsumer) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); object_init_ex(return_value, phalcon_queue_adapter_redis_redissubscriptionconsumer_ce); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1249, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1258, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, this_ptr, &_0); zephir_check_call_status(); RETURN_MM(); @@ -336,7 +336,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, popMessage) ZVAL_STR_COPY(&queueName_zv, queueName); ZEPHIR_CALL_METHOD(NULL, this_ptr, "promote", NULL, 0, &queueName_zv); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1256, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "listkey", NULL, 0, &queueName_zv); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&payload, &_0, "rpop", NULL, 0, &_1); @@ -379,12 +379,12 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, purgeQueue) zephir_fetch_params(1, 1, 0, &queue); ZEPHIR_CALL_METHOD(&queueName, queue, "getqueuename", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1256, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "listkey", NULL, 0, &queueName); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_0, "del", NULL, 0, &_1); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1256, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_3, this_ptr, "delayedkey", NULL, 0, &queueName); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_2, "del", NULL, 0, &_3); @@ -453,7 +453,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, pushMessage) zephir_check_call_status(); ZEPHIR_INIT_VAR(&member); ZEPHIR_CONCAT_VSV(&member, &_2$$3, "|", &payload); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 1247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 1256, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_4$$3, this_ptr, "delayedkey", NULL, 0, &queueName_zv); zephir_check_call_status(); ZVAL_LONG(&_5$$3, score); @@ -461,7 +461,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, pushMessage) zephir_check_call_status(); RETURN_MM_NULL(); } - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 1247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 1256, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_7, this_ptr, "listkey", NULL, 0, &queueName_zv); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_6, "lpush", NULL, 0, &_7, &payload); @@ -519,7 +519,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, delayedKey) Z_PARAM_STR(queueName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&queueName_zv, queueName); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1248, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1257, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_VVS(return_value, &_0, &queueName_zv, ":delayed"); return; } @@ -541,7 +541,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, listKey) Z_PARAM_STR(queueName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&queueName_zv, queueName); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1248, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1257, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_VV(return_value, &_0, &queueName_zv); return; } @@ -612,7 +612,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, promote) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&listKey, this_ptr, "listkey", NULL, 0, &queueName_zv); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1256, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "now", NULL, 0); zephir_check_call_status(); ZVAL_LONG(&_2, 0); @@ -627,7 +627,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, promote) { ZEPHIR_INIT_NVAR(&member); ZVAL_COPY(&member, _3); - zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_0, 1247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_0, 1256, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5$$4, &_4$$4, "zrem", NULL, 0, &delayedKey, &member); zephir_check_call_status(); if (ZEPHIR_GT_LONG(&_5$$4, 0)) { @@ -638,7 +638,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, promote) ZVAL_LONG(&_7$$5, (zephir_get_numberval(&position) + 1)); ZEPHIR_INIT_NVAR(&payload); zephir_substr(&payload, &member, zephir_get_intval(&_7$$5), 0, ZEPHIR_SUBSTR_NO_LENGTH); - zephir_read_property_cached(&_8$$5, this_ptr, _zephir_prop_0, 1247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$5, this_ptr, _zephir_prop_0, 1256, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_8$$5, "lpush", NULL, 0, &listKey, &payload); zephir_check_call_status(); } @@ -661,7 +661,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, promote) } ZEPHIR_CALL_METHOD(&member, &due, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_0, 1247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_0, 1256, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_12$$6, &_11$$6, "zrem", NULL, 0, &delayedKey, &member); zephir_check_call_status(); if (ZEPHIR_GT_LONG(&_12$$6, 0)) { @@ -672,7 +672,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, promote) ZVAL_LONG(&_14$$7, (zephir_get_numberval(&position) + 1)); ZEPHIR_INIT_NVAR(&payload); zephir_substr(&payload, &member, zephir_get_intval(&_14$$7), 0, ZEPHIR_SUBSTR_NO_LENGTH); - zephir_read_property_cached(&_15$$7, this_ptr, _zephir_prop_0, 1247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$7, this_ptr, _zephir_prop_0, 1256, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_15$$7, "lpush", NULL, 0, &listKey, &payload); zephir_check_call_status(); } diff --git a/ext/phalcon/queue/adapter/redis/redisproducer.zep.c b/ext/phalcon/queue/adapter/redis/redisproducer.zep.c index 27c33694ca..7145236aea 100644 --- a/ext/phalcon/queue/adapter/redis/redisproducer.zep.c +++ b/ext/phalcon/queue/adapter/redis/redisproducer.zep.c @@ -72,7 +72,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisProducer, __construct) Z_PARAM_OBJECT_OF_CLASS(context, phalcon_queue_adapter_redis_rediscontext_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &context); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1250, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1259, context); } PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisProducer, getDeliveryDelay) @@ -118,18 +118,18 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisProducer, send) ZEPHIR_CALL_CE_STATIC(NULL, phalcon_queue_adapter_queuedestinationguard_ce, "assertqueue", NULL, 0, destination, &_0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_1); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1251, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1260, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_2) == IS_NULL) { ZEPHIR_INIT_NVAR(&_1); ZVAL_LONG(&_1, 0); } else { zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1251, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1260, PH_NOISY_CC); ZEPHIR_INIT_NVAR(&_1); ZVAL_LONG(&_1, zephir_get_intval(&_3)); } delay = zephir_get_numberval(&_1); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1250, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1259, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5, destination, "getqueuename", NULL, 0); zephir_check_call_status(); ZVAL_LONG(&_6, delay); @@ -172,7 +172,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisProducer, setDeliveryDelay) ZEPHIR_INIT_NVAR(&_0); ZVAL_LONG(&_0, zephir_get_intval(deliveryDelay)); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1251, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1260, &_0); RETURN_THIS(); } diff --git a/ext/phalcon/queue/adapter/redis/redissubscriptionconsumer.zep.c b/ext/phalcon/queue/adapter/redis/redissubscriptionconsumer.zep.c index fc14330a36..ca68a2e950 100644 --- a/ext/phalcon/queue/adapter/redis/redissubscriptionconsumer.zep.c +++ b/ext/phalcon/queue/adapter/redis/redissubscriptionconsumer.zep.c @@ -79,9 +79,9 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisSubscriptionConsumer, __construct) pollInterval = 200; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1252, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1261, context); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1253, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1262, &_0); } diff --git a/ext/phalcon/queue/adapter/stream/streamconnectionfactory.zep.c b/ext/phalcon/queue/adapter/stream/streamconnectionfactory.zep.c index c5ce54364f..a29af03d9b 100644 --- a/ext/phalcon/queue/adapter/stream/streamconnectionfactory.zep.c +++ b/ext/phalcon/queue/adapter/stream/streamconnectionfactory.zep.c @@ -83,7 +83,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamConnectionFactory, __construct) } else { zephir_get_arrval(&options, options_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1254, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1263, &options); ZEPHIR_MM_RESTORE(); } @@ -110,16 +110,16 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamConnectionFactory, createContext) ZEPHIR_CALL_FUNCTION(&storageDir, "sys_get_temp_dir", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1254, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1263, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value_string(&_0, SL("storageDir"))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1254, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1263, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&storageDir); zephir_array_fetch_string(&storageDir, &_1$$3, SL("storageDir"), PH_NOISY, "phalcon/Queue/Adapter/Stream/StreamConnectionFactory.zep", 51); } pollInterval = 200; - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1254, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1263, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value_string(&_2, SL("pollInterval"))) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 1254, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 1263, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_4$$4); zephir_array_fetch_string(&_4$$4, &_3$$4, SL("pollInterval"), PH_NOISY, "phalcon/Queue/Adapter/Stream/StreamConnectionFactory.zep", 57); pollInterval = zephir_get_intval(&_4$$4); diff --git a/ext/phalcon/queue/adapter/stream/streamconsumer.zep.c b/ext/phalcon/queue/adapter/stream/streamconsumer.zep.c index b615ea2500..3ef60650fe 100644 --- a/ext/phalcon/queue/adapter/stream/streamconsumer.zep.c +++ b/ext/phalcon/queue/adapter/stream/streamconsumer.zep.c @@ -83,11 +83,11 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamConsumer, __construct) pollInterval = 200; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1255, context); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1256, queue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1264, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1265, queue); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1257, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1266, &_0); } /** @@ -125,8 +125,8 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamConsumer, receiveNoWait) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1255, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1256, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1264, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1265, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "getqueuename", NULL, 0); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_0, "popmessage", NULL, 0, &_2); @@ -168,8 +168,8 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamConsumer, reject) } else { } if (requeue) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1255, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1256, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1264, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1265, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2$$3, &_1$$3, "getqueuename", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_0$$3, "pushmessage", NULL, 0, &_2$$3, message); diff --git a/ext/phalcon/queue/adapter/stream/streamcontext.zep.c b/ext/phalcon/queue/adapter/stream/streamcontext.zep.c index d9748b0b3d..92ccaf0a7e 100644 --- a/ext/phalcon/queue/adapter/stream/streamcontext.zep.c +++ b/ext/phalcon/queue/adapter/stream/streamcontext.zep.c @@ -108,10 +108,10 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamContext, __construct) zephir_fast_trim(&_0, &storageDir_zv, &_1, ZEPHIR_TRIM_RIGHT); ZEPHIR_INIT_VAR(&_2); ZEPHIR_CONCAT_VS(&_2, &_0, "/"); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1258, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1267, &_2); ZVAL_UNDEF(&_3); ZVAL_LONG(&_3, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1259, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1268, &_3); ZEPHIR_MM_RESTORE(); } @@ -146,7 +146,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamContext, createConsumer) ZEPHIR_CALL_CE_STATIC(NULL, phalcon_queue_adapter_queuedestinationguard_ce, "assertqueue", NULL, 0, destination, &_0); zephir_check_call_status(); object_init_ex(return_value, phalcon_queue_adapter_stream_streamconsumer_ce); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1259, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1268, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, this_ptr, destination, &_1); zephir_check_call_status(); RETURN_MM(); @@ -233,7 +233,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamContext, createSubscriptionConsume zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); object_init_ex(return_value, phalcon_queue_adapter_stream_streamsubscriptionconsumer_ce); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1259, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1268, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, this_ptr, &_0); zephir_check_call_status(); RETURN_MM(); @@ -294,7 +294,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamContext, popMessage) RETURN_MM_NULL(); } ZVAL_LONG(&_2, 2); - ZEPHIR_CALL_FUNCTION(&_3, "flock", NULL, 285, &pointer, &_2); + ZEPHIR_CALL_FUNCTION(&_3, "flock", NULL, 291, &pointer, &_2); zephir_check_call_status(); if (!(zephir_is_true(&_3))) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "phpfclose", NULL, 0, &pointer); @@ -311,7 +311,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamContext, popMessage) zephir_check_call_status(); if (ZEPHIR_IS_EMPTY(&lines)) { ZVAL_LONG(&_5$$6, 3); - ZEPHIR_CALL_FUNCTION(NULL, "flock", NULL, 285, &pointer, &_5$$6); + ZEPHIR_CALL_FUNCTION(NULL, "flock", NULL, 291, &pointer, &_5$$6); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, this_ptr, "phpfclose", NULL, 0, &pointer); zephir_check_call_status(); @@ -341,7 +341,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamContext, popMessage) ZEPHIR_CALL_METHOD(NULL, this_ptr, "phpfwrite", NULL, 0, &pointer, &remaining); zephir_check_call_status(); ZVAL_LONG(&_2, 3); - ZEPHIR_CALL_FUNCTION(NULL, "flock", NULL, 285, &pointer, &_2); + ZEPHIR_CALL_FUNCTION(NULL, "flock", NULL, 291, &pointer, &_2); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, this_ptr, "phpfclose", NULL, 0, &pointer); zephir_check_call_status(); @@ -457,13 +457,13 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamContext, ensureDir) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1258, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_1, "is_dir", NULL, 288, &_0); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1267, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_FUNCTION(&_1, "is_dir", NULL, 294, &_0); zephir_check_call_status(); if (!(zephir_is_true(&_1))) { - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 1258, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 1267, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_3$$3, 0777); - ZEPHIR_CALL_FUNCTION(NULL, "mkdir", NULL, 289, &_2$$3, &_3$$3, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "mkdir", NULL, 295, &_2$$3, &_3$$3, &__$true); zephir_check_call_status(); } ZEPHIR_MM_RESTORE(); @@ -494,7 +494,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamContext, getFilepath) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&queueName_zv); ZVAL_STR_COPY(&queueName_zv, queueName); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1258, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1267, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "/[^a-zA-Z0-9_-]/"); ZEPHIR_INIT_VAR(&_2); diff --git a/ext/phalcon/queue/adapter/stream/streamproducer.zep.c b/ext/phalcon/queue/adapter/stream/streamproducer.zep.c index ee3694319c..85bff915dd 100644 --- a/ext/phalcon/queue/adapter/stream/streamproducer.zep.c +++ b/ext/phalcon/queue/adapter/stream/streamproducer.zep.c @@ -65,7 +65,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamProducer, __construct) Z_PARAM_OBJECT_OF_CLASS(context, phalcon_queue_adapter_stream_streamcontext_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &context); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1260, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1269, context); } PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamProducer, send) @@ -96,7 +96,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamProducer, send) ZVAL_STRING(&_0, "send to"); ZEPHIR_CALL_CE_STATIC(NULL, phalcon_queue_adapter_queuedestinationguard_ce, "assertqueue", NULL, 0, destination, &_0); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1260, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1269, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, destination, "getqueuename", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_1, "pushmessage", NULL, 0, &_2, message); diff --git a/ext/phalcon/queue/adapter/stream/streamsubscriptionconsumer.zep.c b/ext/phalcon/queue/adapter/stream/streamsubscriptionconsumer.zep.c index 3cdb572eb9..08993be4f0 100644 --- a/ext/phalcon/queue/adapter/stream/streamsubscriptionconsumer.zep.c +++ b/ext/phalcon/queue/adapter/stream/streamsubscriptionconsumer.zep.c @@ -79,9 +79,9 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamSubscriptionConsumer, __construct) pollInterval = 200; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1261, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1270, context); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1262, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1271, &_0); } diff --git a/ext/phalcon/queue/adapter/traits/messagetrait.zep.c b/ext/phalcon/queue/adapter/traits/messagetrait.zep.c index 8ea941a45b..890d02f077 100644 --- a/ext/phalcon/queue/adapter/traits/messagetrait.zep.c +++ b/ext/phalcon/queue/adapter/traits/messagetrait.zep.c @@ -132,9 +132,9 @@ PHP_METHOD(Phalcon_Queue_Adapter_Traits_MessageTrait, __construct) } else { zephir_get_arrval(&headers, headers_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1263, &body_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1264, &properties); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1265, &headers); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1272, &body_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1273, &properties); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1274, &headers); ZEPHIR_MM_RESTORE(); } @@ -202,9 +202,9 @@ PHP_METHOD(Phalcon_Queue_Adapter_Traits_MessageTrait, getHeader) defaultValue = &defaultValue_sub; defaultValue = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1265, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1274, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_0, &name_zv)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1265, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1274, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_2$$3, &_1$$3, &name_zv, PH_NOISY | PH_READONLY, "phalcon/Queue/Adapter/Traits/MessageTrait.zep", 88); RETURN_CTORW(&_2$$3); } @@ -232,7 +232,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Traits_MessageTrait, getHeaders) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1265, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1274, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } @@ -278,7 +278,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Traits_MessageTrait, getProperties) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1264, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1273, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } @@ -317,9 +317,9 @@ PHP_METHOD(Phalcon_Queue_Adapter_Traits_MessageTrait, getProperty) defaultValue = &defaultValue_sub; defaultValue = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1264, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1273, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_0, &name_zv)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1264, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1273, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_2$$3, &_1$$3, &name_zv, PH_NOISY | PH_READONLY, "phalcon/Queue/Adapter/Traits/MessageTrait.zep", 124); RETURN_CTORW(&_2$$3); } @@ -401,7 +401,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Traits_MessageTrait, setBody) Z_PARAM_STR(body) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&body_zv, body); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1263, &body_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1272, &body_zv); } /** @@ -474,7 +474,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Traits_MessageTrait, setHeaders) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &headers_param); zephir_get_arrval(&headers, headers_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1265, &headers); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1274, &headers); ZEPHIR_MM_RESTORE(); } @@ -528,7 +528,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Traits_MessageTrait, setProperties) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &properties_param); zephir_get_arrval(&properties, properties_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1264, &properties); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1273, &properties); ZEPHIR_MM_RESTORE(); } @@ -573,9 +573,9 @@ PHP_METHOD(Phalcon_Queue_Adapter_Traits_MessageTrait, setRedelivered) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &redelivered_param); if (redelivered) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1266, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1275, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1266, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1275, &__$false); } } diff --git a/ext/phalcon/queue/adapter/traits/subscriptionconsumertrait.zep.c b/ext/phalcon/queue/adapter/traits/subscriptionconsumertrait.zep.c index bf6975aa40..051c857758 100644 --- a/ext/phalcon/queue/adapter/traits/subscriptionconsumertrait.zep.c +++ b/ext/phalcon/queue/adapter/traits/subscriptionconsumertrait.zep.c @@ -114,18 +114,18 @@ PHP_METHOD(Phalcon_Queue_Adapter_Traits_SubscriptionConsumerTrait, consume) timeout = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1267, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1276, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_0)) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1268, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1277, PH_NOISY_CC | PH_READONLY); sleep = (zephir_get_numberval(&_1) * 1000); ZEPHIR_INIT_VAR(&_2); zephir_microtime(&_2, &__$true); startTime = (zephir_get_numberval(&_2) * 1000); while (1) { ZEPHIR_OBS_NVAR(&_3$$4); - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 1267, PH_NOISY_CC); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 1276, PH_NOISY_CC); zephir_get_arrval(&_4$$4, &_3$$4); zephir_is_iterable(&_4$$4, 0, "phalcon/Queue/Adapter/Traits/SubscriptionConsumerTrait.zep", 79); if (Z_TYPE_P(&_4$$4) == IS_ARRAY) { @@ -257,7 +257,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Traits_SubscriptionConsumerTrait, unsubscribe) ZEPHIR_CALL_METHOD(&_0, this_ptr, "resolvequeuename", NULL, 0, consumer); zephir_check_call_status(); zephir_unset_property_array(this_ptr, ZEND_STRL("subscriptions"), &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1267, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1276, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, this_ptr, "resolvequeuename", NULL, 0, consumer); zephir_check_call_status(); zephir_array_unset(&_1, &_2, PH_SEPARATE); @@ -283,7 +283,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Traits_SubscriptionConsumerTrait, unsubscribeAl ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1267, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1276, &_0); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/queue/consumer/boundprocessor.zep.c b/ext/phalcon/queue/consumer/boundprocessor.zep.c index e883c9bf4c..5c19be93c0 100644 --- a/ext/phalcon/queue/consumer/boundprocessor.zep.c +++ b/ext/phalcon/queue/consumer/boundprocessor.zep.c @@ -82,9 +82,9 @@ PHP_METHOD(Phalcon_Queue_Consumer_BoundProcessor, __construct) Z_PARAM_OBJECT_OF_CLASS(consumer, phalcon_contracts_queue_consumer_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(3, 0, &queue, &processor, &consumer); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1269, queue); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1270, processor); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1271, consumer); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1278, queue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1279, processor); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1280, consumer); } PHP_METHOD(Phalcon_Queue_Consumer_BoundProcessor, getConsumer) diff --git a/ext/phalcon/queue/consumer/queueconsumer.zep.c b/ext/phalcon/queue/consumer/queueconsumer.zep.c index 4cd9e2af6d..36a9ef9106 100644 --- a/ext/phalcon/queue/consumer/queueconsumer.zep.c +++ b/ext/phalcon/queue/consumer/queueconsumer.zep.c @@ -89,7 +89,7 @@ PHP_METHOD(Phalcon_Queue_Consumer_QueueConsumer, __construct) Z_PARAM_OBJECT_OF_CLASS(context, phalcon_contracts_queue_context_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &context); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1272, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1281, context); } /** @@ -122,7 +122,7 @@ PHP_METHOD(Phalcon_Queue_Consumer_QueueConsumer, bind) zephir_fetch_params(1, 2, 0, &queue, &processor); ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, phalcon_queue_consumer_boundprocessor_ce); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1272, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1281, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "createconsumer", NULL, 0, queue); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 0, queue, processor, &_2); @@ -178,7 +178,7 @@ PHP_METHOD(Phalcon_Queue_Consumer_QueueConsumer, consume) while (1) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "consumeonce", &_2, 0); zephir_check_call_status(); - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 1273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 1282, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_3$$4)) { break; } @@ -242,7 +242,7 @@ PHP_METHOD(Phalcon_Queue_Consumer_QueueConsumer, consumeOnce) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); handled = 0; - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1274, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1283, PH_NOISY_CC | PH_READONLY); zephir_is_iterable(&_0, 0, "phalcon/Queue/Consumer/QueueConsumer.zep", 144); if (Z_TYPE_P(&_0) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1) @@ -266,9 +266,9 @@ PHP_METHOD(Phalcon_Queue_Consumer_QueueConsumer, consumeOnce) zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&_5$$3)) { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1273, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1282, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1273, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1282, &__$false); } RETURN_MM_BOOL(handled); } @@ -313,9 +313,9 @@ PHP_METHOD(Phalcon_Queue_Consumer_QueueConsumer, consumeOnce) zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&_11$$7)) { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1273, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1282, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1273, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1282, &__$false); } RETURN_MM_BOOL(handled); } @@ -328,7 +328,7 @@ PHP_METHOD(Phalcon_Queue_Consumer_QueueConsumer, consumeOnce) } ZEPHIR_INIT_NVAR(&binding); if (!(handled)) { - zephir_read_property_cached(&_12$$11, this_ptr, _zephir_prop_2, 1275, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$11, this_ptr, _zephir_prop_2, 1284, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_13$$11, (zephir_get_numberval(&_12$$11) * 1000)); ZEPHIR_CALL_FUNCTION(NULL, "usleep", NULL, 73, &_13$$11); zephir_check_call_status(); @@ -392,7 +392,7 @@ PHP_METHOD(Phalcon_Queue_Consumer_QueueConsumer, setPollInterval) zephir_fetch_params_without_memory_grow(1, 0, &pollInterval_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1275, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1284, &_0); } /** @@ -418,9 +418,9 @@ PHP_METHOD(Phalcon_Queue_Consumer_QueueConsumer, start) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1273, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1282, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1273, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1282, &__$false); } ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "queue:beforeStart"); @@ -444,9 +444,9 @@ PHP_METHOD(Phalcon_Queue_Consumer_QueueConsumer, stop) _zephir_prop_0 = zend_string_init("shouldStop", 10, 1); } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1273, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1282, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1273, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1282, &__$false); } } @@ -543,7 +543,7 @@ PHP_METHOD(Phalcon_Queue_Consumer_QueueConsumer, process) /* try_start_1: */ - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 1272, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 1281, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&result, &processor, "process", NULL, 0, message, &_2$$4); zephir_check_call_status_or_jump(try_end_1); ZEPHIR_CALL_METHOD(NULL, this_ptr, "handleresult", NULL, 0, &consumer, message, &result); diff --git a/ext/phalcon/queue/consumer/worker.zep.c b/ext/phalcon/queue/consumer/worker.zep.c index 012d65412c..95a47e8292 100644 --- a/ext/phalcon/queue/consumer/worker.zep.c +++ b/ext/phalcon/queue/consumer/worker.zep.c @@ -99,8 +99,8 @@ PHP_METHOD(Phalcon_Queue_Consumer_Worker, __construct) ZEPHIR_CALL_METHOD(NULL, options, "__construct", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1276, consumer); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1277, options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1285, consumer); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1286, options); ZEPHIR_MM_RESTORE(); } @@ -126,7 +126,7 @@ PHP_METHOD(Phalcon_Queue_Consumer_Worker, handleSignal) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &signal_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1276, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1285, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "stop", NULL, 0); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -175,7 +175,7 @@ PHP_METHOD(Phalcon_Queue_Consumer_Worker, run) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1277, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1286, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); processed = 0; ZEPHIR_CALL_METHOD(&_1, &options, "getmaxmessages", NULL, 0); @@ -190,7 +190,7 @@ PHP_METHOD(Phalcon_Queue_Consumer_Worker, run) ZEPHIR_CALL_METHOD(&_4, &options, "getjitter", NULL, 0); zephir_check_call_status(); jitter = zephir_get_intval(&_4); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1276, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1285, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5, &_0, "start", NULL, 0); zephir_check_call_status(); if (!(zephir_is_true(&_5))) { @@ -212,13 +212,13 @@ PHP_METHOD(Phalcon_Queue_Consumer_Worker, run) ZEPHIR_CALL_METHOD(NULL, this_ptr, "installsignalhandlers", NULL, 0); zephir_check_call_status(); while (1) { - zephir_read_property_cached(&_10$$6, this_ptr, _zephir_prop_1, 1276, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$6, this_ptr, _zephir_prop_1, 1285, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_11$$6, &_10$$6, "isstoprequested", NULL, 0); zephir_check_call_status(); if (zephir_is_true(&_11$$6)) { break; } - zephir_read_property_cached(&_12$$6, this_ptr, _zephir_prop_1, 1276, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$6, this_ptr, _zephir_prop_1, 1285, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_13$$6, &_12$$6, "consumeonce", NULL, 0); zephir_check_call_status(); if (zephir_is_true(&_13$$6)) { @@ -250,7 +250,7 @@ PHP_METHOD(Phalcon_Queue_Consumer_Worker, run) break; } } - zephir_read_property_cached(&_20, this_ptr, _zephir_prop_1, 1276, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20, this_ptr, _zephir_prop_1, 1285, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_20, "end", NULL, 0); zephir_check_call_status(); RETURN_MM_LONG(processed); @@ -341,7 +341,7 @@ PHP_METHOD(Phalcon_Queue_Consumer_Worker, phpExtensionLoaded) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 431, &name_zv); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/queue/consumer/workeroptions.zep.c b/ext/phalcon/queue/consumer/workeroptions.zep.c index aed92ae57a..d571054968 100644 --- a/ext/phalcon/queue/consumer/workeroptions.zep.c +++ b/ext/phalcon/queue/consumer/workeroptions.zep.c @@ -120,16 +120,16 @@ PHP_METHOD(Phalcon_Queue_Consumer_WorkerOptions, __construct) } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, maxMessages); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1278, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1287, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, maxSeconds); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1279, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1288, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, maxMemory); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1280, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1289, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, jitter); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1281, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1290, &_0); } PHP_METHOD(Phalcon_Queue_Consumer_WorkerOptions, getJitter) diff --git a/ext/phalcon/queue/queuefactory.zep.c b/ext/phalcon/queue/queuefactory.zep.c index be27be844f..3f471f1b12 100644 --- a/ext/phalcon/queue/queuefactory.zep.c +++ b/ext/phalcon/queue/queuefactory.zep.c @@ -89,7 +89,7 @@ PHP_METHOD(Phalcon_Queue_QueueFactory, __construct) ZEPHIR_CALL_METHOD(NULL, factory, "__construct", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1282, factory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1291, factory); ZEPHIR_MM_RESTORE(); } @@ -179,7 +179,7 @@ PHP_METHOD(Phalcon_Queue_QueueFactory, newInstance) } else { zephir_get_arrval(&options, options_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1282, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1291, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&connectionFactory, &_0, "newinstance", NULL, 0, &name_zv, &options); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&connectionFactory, "createcontext", NULL, 0); diff --git a/ext/phalcon/session/adapter/libmemcached.zep.c b/ext/phalcon/session/adapter/libmemcached.zep.c index 490a4ee2d6..99c8ca5dac 100644 --- a/ext/phalcon/session/adapter/libmemcached.zep.c +++ b/ext/phalcon/session/adapter/libmemcached.zep.c @@ -109,7 +109,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Libmemcached, __construct) ZVAL_STRING(&_1, "libmemcached"); ZEPHIR_CALL_METHOD(&_5, factory, "newinstance", NULL, 0, &_1, &options); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1283, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1292, &_5); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/session/adapter/redis.zep.c b/ext/phalcon/session/adapter/redis.zep.c index c9f501443f..120d5fccb2 100644 --- a/ext/phalcon/session/adapter/redis.zep.c +++ b/ext/phalcon/session/adapter/redis.zep.c @@ -179,16 +179,16 @@ PHP_METHOD(Phalcon_Session_Adapter_Redis, __construct) zephir_check_call_status(); ZVAL_UNDEF(&_4); ZVAL_LONG(&_4, zephir_get_intval(&_5)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1284, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1293, &_4); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "lockingEnabled"); ZVAL_BOOL(&_4, 0); ZEPHIR_CALL_METHOD(&_6, this_ptr, "getarrval", NULL, 0, &options, &_1, &_4); zephir_check_call_status(); if (zephir_get_boolval(&_6)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1285, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1294, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1285, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1294, &__$false); } ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "lockRetries"); @@ -197,7 +197,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Redis, __construct) zephir_check_call_status(); ZVAL_UNDEF(&_4); ZVAL_LONG(&_4, zephir_get_intval(&_6)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1286, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1295, &_4); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "lockWaitTime"); ZVAL_LONG(&_4, 50000); @@ -205,16 +205,16 @@ PHP_METHOD(Phalcon_Session_Adapter_Redis, __construct) zephir_check_call_status(); ZVAL_UNDEF(&_4); ZVAL_LONG(&_4, zephir_get_intval(&_7)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1287, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1296, &_4); zephir_memory_observe(&_8); zephir_array_fetch_string(&_8, &options, SL("prefix"), PH_NOISY, "phalcon/Session/Adapter/Redis.zep", 99); zephir_cast_to_string(&_9, &_8); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1288, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1297, &_9); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "redis"); ZEPHIR_CALL_METHOD(&_10, factory, "newinstance", NULL, 0, &_1, &options); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1289, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1298, &_10); ZEPHIR_MM_RESTORE(); } @@ -291,7 +291,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Redis, read) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &id); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1285, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1294, PH_NOISY_CC | PH_READONLY); _1 = ZEPHIR_IS_TRUE_IDENTICAL(&_0); if (_1) { ZEPHIR_CALL_METHOD(&_2, this_ptr, "acquirelock", NULL, 0, id); @@ -301,7 +301,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Redis, read) if (_1) { ZEPHIR_INIT_VAR(&_3$$3); object_init_ex(&_3$$3, phalcon_session_adapter_exceptions_adapterruntimeerror_ce); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 1290, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 1299, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_5$$3); ZEPHIR_CONCAT_SV(&_5$$3, "Could not acquire the session lock with key: ", &_4$$3); ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 8, &_5$$3); @@ -386,35 +386,35 @@ PHP_METHOD(Phalcon_Session_Adapter_Redis, acquireLock) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &id); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1297, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&lockKey); ZEPHIR_CONCAT_VVS(&lockKey, &_0, id, "-lock"); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1291, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1300, PH_NOISY_CC | PH_READONLY); _2 = ZEPHIR_IS_TRUE_IDENTICAL(&_1); if (_2) { - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1290, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1299, PH_NOISY_CC | PH_READONLY); _2 = ZEPHIR_IS_IDENTICAL(&lockKey, &_3); } if (_2) { RETURN_MM_BOOL(1); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1290, &lockKey); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 1289, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1299, &lockKey); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 1298, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&client, &_4, "getadapter", NULL, 0); zephir_check_call_status(); ZVAL_LONG(&_5, 16); - ZEPHIR_CALL_FUNCTION(&_6, "random_bytes", NULL, 303, &_5); + ZEPHIR_CALL_FUNCTION(&_6, "random_bytes", NULL, 312, &_5); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&token, "bin2hex", NULL, 304, &_6); + ZEPHIR_CALL_FUNCTION(&token, "bin2hex", NULL, 313, &_6); zephir_check_call_status(); attempt = 0; while (1) { - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_4, 1286, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_4, 1295, PH_NOISY_CC | PH_READONLY); if (!(ZEPHIR_GT_LONG(&_5, attempt))) { break; } - zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_2, 1290, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_5, 1284, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_2, 1299, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_5, 1293, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_9$$4); ZVAL_STRING(&_9$$4, "SET"); ZEPHIR_INIT_NVAR(&_10$$4); @@ -425,14 +425,14 @@ PHP_METHOD(Phalcon_Session_Adapter_Redis, acquireLock) zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&result)) { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1291, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1300, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1291, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1300, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1292, &token); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1301, &token); RETURN_MM_BOOL(1); } - zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_7, 1287, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_7, 1296, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "usleep", &_14, 73, &_13$$4); zephir_check_call_status(); attempt++; @@ -480,30 +480,30 @@ PHP_METHOD(Phalcon_Session_Adapter_Redis, releaseLock) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1291, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1300, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { RETURN_MM_NULL(); } ZEPHIR_INIT_VAR(&script); ZVAL_STRING(&script, "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end"); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1289, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1298, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&client, &_1, "getadapter", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1290, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 1292, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1299, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 1301, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_4); ZVAL_STRING(&_4, "EVAL"); ZVAL_LONG(&_5, 1); ZEPHIR_CALL_METHOD(NULL, &client, "rawcommand", NULL, 0, &_4, &script, &_5, &_2, &_3); zephir_check_call_status(); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1291, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1300, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1291, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1300, &__$false); } ZEPHIR_INIT_NVAR(&_4); ZVAL_STRING(&_4, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1292, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1301, &_4); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/session/adapter/stream.zep.c b/ext/phalcon/session/adapter/stream.zep.c index 7645f6f614..ec62514a4d 100644 --- a/ext/phalcon/session/adapter/stream.zep.c +++ b/ext/phalcon/session/adapter/stream.zep.c @@ -139,8 +139,8 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, __construct) ZVAL_STRING(&_2, ""); ZEPHIR_CALL_METHOD(&_0, this_ptr, "getarrval", NULL, 0, &options, &_1, &_2); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1293, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1294, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1302, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1303, &options); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "session.save_path"); ZEPHIR_CALL_METHOD(&_3, this_ptr, "phpiniget", NULL, 0, &_1); @@ -171,7 +171,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, __construct) } ZEPHIR_CALL_METHOD(&_7, this_ptr, "todirseparator", NULL, 0, &path); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1295, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1304, &_7); ZEPHIR_MM_RESTORE(); } @@ -200,7 +200,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, destroy) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &id); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1295, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1304, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getprefixedname", NULL, 0, id); zephir_check_call_status(); ZEPHIR_INIT_VAR(&file); @@ -209,7 +209,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, destroy) zephir_check_call_status(); _3 = zephir_is_true(&_2); if (_3) { - ZEPHIR_CALL_FUNCTION(&_4, "is_file", NULL, 417, &file); + ZEPHIR_CALL_FUNCTION(&_4, "is_file", NULL, 429, &file); zephir_check_call_status(); _3 = zephir_is_true(&_4); } @@ -267,8 +267,8 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, gc) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &max_lifetime_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1295, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1293, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1304, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1302, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&pattern); ZEPHIR_CONCAT_VVS(&pattern, &_0, &_1, "*"); ZEPHIR_INIT_VAR(&_2); @@ -306,7 +306,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, gc) zephir_check_call_status(); _8$$7 = ZEPHIR_IS_TRUE_IDENTICAL(&_6$$7); if (_8$$7) { - ZEPHIR_CALL_FUNCTION(&_9$$7, "is_file", &_10, 417, &file); + ZEPHIR_CALL_FUNCTION(&_9$$7, "is_file", &_10, 429, &file); zephir_check_call_status(); _8$$7 = ZEPHIR_IS_TRUE_IDENTICAL(&_9$$7); } @@ -343,7 +343,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, gc) zephir_check_call_status(); _17$$9 = ZEPHIR_IS_TRUE_IDENTICAL(&_16$$9); if (_17$$9) { - ZEPHIR_CALL_FUNCTION(&_18$$9, "is_file", &_10, 417, &file); + ZEPHIR_CALL_FUNCTION(&_18$$9, "is_file", &_10, 429, &file); zephir_check_call_status(); _17$$9 = ZEPHIR_IS_TRUE_IDENTICAL(&_18$$9); } @@ -414,7 +414,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, read) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &id); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1295, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1304, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getprefixedname", NULL, 0, id); zephir_check_call_status(); ZEPHIR_INIT_VAR(&name); @@ -429,7 +429,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, read) ZEPHIR_CALL_METHOD(&pointer, this_ptr, "phpfopen", NULL, 0, &name, &_3$$3); zephir_check_call_status(); ZVAL_LONG(&_4$$3, 1); - ZEPHIR_CALL_FUNCTION(&_5$$3, "flock", NULL, 285, &pointer, &_4$$3); + ZEPHIR_CALL_FUNCTION(&_5$$3, "flock", NULL, 291, &pointer, &_4$$3); zephir_check_call_status(); if (zephir_is_true(&_5$$3)) { ZEPHIR_CALL_METHOD(&data, this_ptr, "phpfilegetcontents", NULL, 0, &name); @@ -471,7 +471,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, updateTimestamp) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 2, 0, &id, &data); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1295, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1304, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getprefixedname", NULL, 0, id); zephir_check_call_status(); ZEPHIR_INIT_VAR(&name); @@ -506,7 +506,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, validateId) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &id); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1295, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1304, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getprefixedname", NULL, 0, id); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_2); @@ -542,7 +542,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, write) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 2, 0, &id, &data); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1295, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1304, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getprefixedname", NULL, 0, id); zephir_check_call_status(); ZEPHIR_INIT_VAR(&name); @@ -617,7 +617,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, getPrefixedName) ZEPHIR_SEPARATE_PARAM(name); zephir_cast_to_string(&_0, name); ZEPHIR_CPY_WRT(name, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1293, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1302, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_VV(return_value, &_1, name); RETURN_MM(); } @@ -1191,7 +1191,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, phpIniGet) zephir_memory_observe(&defaultValue_zv); ZVAL_STR_COPY(&defaultValue_zv, defaultValue); } - ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 427, &input_zv); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&value)) { RETURN_MM_STR(zend_string_copy(defaultValue)); @@ -1238,7 +1238,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, phpIniGetBool) } else { } result = 0; - ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 427, &input_zv); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&value)) { RETURN_MM_BOOL(defaultValue); @@ -1290,7 +1290,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, phpIniGetInt) defaultValue = 0; } else { } - ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 427, &input_zv); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&value)) { RETURN_MM_LONG(defaultValue); @@ -1346,7 +1346,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, phpParseIniFile) } ZVAL_BOOL(&_0, (processSections ? 1 : 0)); ZVAL_LONG(&_1, scannerMode); - ZEPHIR_RETURN_CALL_FUNCTION("parse_ini_file", NULL, 416, &filename_zv, &_0, &_1); + ZEPHIR_RETURN_CALL_FUNCTION("parse_ini_file", NULL, 428, &filename_zv, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/session/bag.zep.c b/ext/phalcon/session/bag.zep.c index ff87f4eaf9..d5e519bd1e 100644 --- a/ext/phalcon/session/bag.zep.c +++ b/ext/phalcon/session/bag.zep.c @@ -106,14 +106,14 @@ PHP_METHOD(Phalcon_Session_Bag, __construct) session = ZEND_CALL_ARG(execute_data, 1); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1296, session); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1297, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1305, session); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1306, &name_zv); if ((zephir_method_exists_ex(session, ZEND_STRL("getdi")) == SUCCESS)) { ZEPHIR_CALL_METHOD(&_0$$3, session, "getdi", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1298, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1307, &_0$$3); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1297, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1306, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&data, session, "get", NULL, 0, &_1); zephir_check_call_status(); if (Z_TYPE_P(&data) != IS_ARRAY) { @@ -150,8 +150,8 @@ PHP_METHOD(Phalcon_Session_Bag, clear) ZEPHIR_CALL_PARENT(NULL, phalcon_session_bag_ce, getThis(), "clear", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1296, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1297, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1305, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1306, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "remove", NULL, 0, &_1); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -204,8 +204,8 @@ PHP_METHOD(Phalcon_Session_Bag, init) } ZEPHIR_CALL_PARENT(NULL, phalcon_session_bag_ce, getThis(), "init", NULL, 0, &data); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1296, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1297, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1305, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1306, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &_1, &data); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -248,9 +248,9 @@ PHP_METHOD(Phalcon_Session_Bag, remove) ZVAL_STR_COPY(&element_zv, element); ZEPHIR_CALL_PARENT(NULL, phalcon_session_bag_ce, getThis(), "remove", NULL, 0, &element_zv); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1296, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1297, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1299, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1305, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1306, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1308, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &_1, &_2); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -296,9 +296,9 @@ PHP_METHOD(Phalcon_Session_Bag, set) ZVAL_STR_COPY(&element_zv, element); ZEPHIR_CALL_PARENT(NULL, phalcon_session_bag_ce, getThis(), "set", NULL, 0, &element_zv, value); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1296, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1297, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1299, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1305, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1306, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1308, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &_1, &_2); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -322,6 +322,6 @@ PHP_METHOD(Phalcon_Session_Bag, setDI) Z_PARAM_OBJECT_OF_CLASS(container, phalcon_di_diinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &container); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1298, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1307, container); } diff --git a/ext/phalcon/session/manager.zep.c b/ext/phalcon/session/manager.zep.c index 0578c3789c..4ca55f0d69 100644 --- a/ext/phalcon/session/manager.zep.c +++ b/ext/phalcon/session/manager.zep.c @@ -368,13 +368,13 @@ PHP_METHOD(Phalcon_Session_Manager, getName) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1300, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1309, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, ""); if (ZEPHIR_IS_IDENTICAL(&_1, &_0)) { ZEPHIR_CALL_FUNCTION(&_2$$3, "session_name", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1300, &_2$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1309, &_2$$3); } RETURN_MM_MEMBER_TYPED(getThis(), "name", IS_STRING); } @@ -544,7 +544,7 @@ PHP_METHOD(Phalcon_Session_Manager, setAdapter) Z_PARAM_OBJECT_OF_CLASS(adapter, php_session_iface_entry) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &adapter); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1301, adapter); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1310, adapter); RETURN_THISW(); } @@ -687,7 +687,7 @@ PHP_METHOD(Phalcon_Session_Manager, setName) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1300, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1309, &name_zv); ZEPHIR_CALL_FUNCTION(NULL, "session_name", NULL, 0, &name_zv); zephir_check_call_status(); RETURN_THIS(); @@ -730,8 +730,8 @@ PHP_METHOD(Phalcon_Session_Manager, setOptions) ZVAL_STRING(&_2, ""); ZEPHIR_CALL_METHOD(&_0, this_ptr, "getarrval", NULL, 0, &options, &_1, &_2); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1302, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1303, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1311, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1312, &options); ZEPHIR_MM_RESTORE(); } @@ -792,7 +792,7 @@ PHP_METHOD(Phalcon_Session_Manager, start) } } zephir_memory_observe(&_6); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 1301, PH_NOISY_CC); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 1310, PH_NOISY_CC); if (UNEXPECTED(!(zephir_is_instance_of(&_6, SL("SessionHandlerInterface"))))) { ZEPHIR_INIT_VAR(&_7$$7); object_init_ex(&_7$$7, phalcon_session_exceptions_invalidsessionadapter_ce); @@ -802,7 +802,7 @@ PHP_METHOD(Phalcon_Session_Manager, start) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 1301, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 1310, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "session_set_save_handler", NULL, 0, &_8); zephir_check_call_status(); ZEPHIR_RETURN_CALL_FUNCTION("session_start", NULL, 0); @@ -868,9 +868,9 @@ PHP_METHOD(Phalcon_Session_Manager, getUniqueKey) zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1302, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1311, PH_NOISY_CC); if (1 != ZEPHIR_IS_EMPTY(&_0)) { - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1302, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1311, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&prefix); ZEPHIR_CONCAT_VS(&prefix, &_1, "#"); } else { @@ -957,7 +957,7 @@ PHP_METHOD(Phalcon_Session_Manager, phpHeadersSent) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - ZEPHIR_RETURN_CALL_FUNCTION("headers_sent", NULL, 0); + ZEPHIR_RETURN_CALL_FUNCTION("headers_sent", NULL, 215); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/storage/adapter/apcu.zep.c b/ext/phalcon/storage/adapter/apcu.zep.c index 0b52ae9948..96332f8ca8 100644 --- a/ext/phalcon/storage/adapter/apcu.zep.c +++ b/ext/phalcon/storage/adapter/apcu.zep.c @@ -117,7 +117,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Apcu, clear) ZEPHIR_INIT_VAR(&apc); ZVAL_NULL(&apc); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 307, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 308, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&pattern); ZEPHIR_CONCAT_SVS(&pattern, "/^", &_0, "/"); ZEPHIR_CALL_METHOD(&apc, this_ptr, "phpapcuiterator", NULL, 0, &pattern); @@ -190,7 +190,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Apcu, getKeys) } ZEPHIR_INIT_VAR(&apc); ZVAL_NULL(&apc); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 307, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 308, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&pattern); ZEPHIR_CONCAT_SVVS(&pattern, "/^", &_0, &prefix_zv, "/"); ZEPHIR_CALL_METHOD(&apc, this_ptr, "phpapcuiterator", NULL, 0, &pattern); @@ -632,7 +632,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Apcu, phpApcuDec) } else { } ZVAL_LONG(&_0, step); - ZEPHIR_RETURN_CALL_FUNCTION("apcu_dec", NULL, 265, key, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("apcu_dec", NULL, 271, key, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -657,7 +657,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Apcu, phpApcuDelete) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &key); - ZEPHIR_RETURN_CALL_FUNCTION("apcu_delete", NULL, 266, key); + ZEPHIR_RETURN_CALL_FUNCTION("apcu_delete", NULL, 272, key); zephir_check_call_status(); RETURN_MM(); } @@ -682,7 +682,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Apcu, phpApcuExists) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &key); - ZEPHIR_RETURN_CALL_FUNCTION("apcu_exists", NULL, 267, key); + ZEPHIR_RETURN_CALL_FUNCTION("apcu_exists", NULL, 273, key); zephir_check_call_status(); RETURN_MM(); } @@ -707,7 +707,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Apcu, phpApcuFetch) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &key); - ZEPHIR_RETURN_CALL_FUNCTION("apcu_fetch", NULL, 268, key); + ZEPHIR_RETURN_CALL_FUNCTION("apcu_fetch", NULL, 274, key); zephir_check_call_status(); RETURN_MM(); } @@ -741,7 +741,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Apcu, phpApcuInc) } else { } ZVAL_LONG(&_0, step); - ZEPHIR_RETURN_CALL_FUNCTION("apcu_inc", NULL, 269, key, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("apcu_inc", NULL, 275, key, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -806,7 +806,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Apcu, phpApcuStore) } else { } ZVAL_LONG(&_0, ttl); - ZEPHIR_RETURN_CALL_FUNCTION("apcu_store", NULL, 270, key, payload, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("apcu_store", NULL, 276, key, payload, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/storage/adapter/libmemcached.zep.c b/ext/phalcon/storage/adapter/libmemcached.zep.c index 087a20f308..ee68fe7d96 100644 --- a/ext/phalcon/storage/adapter/libmemcached.zep.c +++ b/ext/phalcon/storage/adapter/libmemcached.zep.c @@ -176,9 +176,9 @@ PHP_METHOD(Phalcon_Storage_Adapter_Libmemcached, getAdapter) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 308, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 309, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 309, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 310, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_1$$3); ZEPHIR_INIT_VAR(&_2$$3); ZVAL_STRING(&_2$$3, "persistentId"); @@ -198,7 +198,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Libmemcached, getAdapter) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&serverList, &connection, "getserverlist", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 310, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 311, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_4$$3, -1002); ZEPHIR_CALL_METHOD(NULL, &connection, "setoption", NULL, 0, &_4$$3, &_1$$3); zephir_check_call_status(); @@ -234,19 +234,19 @@ PHP_METHOD(Phalcon_Storage_Adapter_Libmemcached, getAdapter) add_index_long(&failover, 21, 2); zephir_array_update_long(&failover, 35, &__$true, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY); add_index_long(&failover, 15, 1); - ZEPHIR_CALL_FUNCTION(&_9$$4, "array_replace", NULL, 271, &failover, &client); + ZEPHIR_CALL_FUNCTION(&_9$$4, "array_replace", NULL, 277, &failover, &client); zephir_check_call_status(); ZEPHIR_CPY_WRT(&client, &_9$$4); - ZEPHIR_CALL_METHOD(&_9$$4, this_ptr, "setoptions", NULL, 272, &connection, &client); + ZEPHIR_CALL_METHOD(&_9$$4, this_ptr, "setoptions", NULL, 278, &connection, &client); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_10$$4, &_9$$4, "setservers", NULL, 273, &connection, &servers); + ZEPHIR_CALL_METHOD(&_10$$4, &_9$$4, "setservers", NULL, 279, &connection, &servers); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &_10$$4, "setsasl", NULL, 274, &connection, &saslUser, &saslPass); + ZEPHIR_CALL_METHOD(NULL, &_10$$4, "setsasl", NULL, 280, &connection, &saslUser, &saslPass); zephir_check_call_status(); } - ZEPHIR_CALL_METHOD(NULL, this_ptr, "setserializer", NULL, 275, &connection); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "setserializer", NULL, 281, &connection); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 308, &connection); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 309, &connection); } RETURN_MM_MEMBER(getThis(), "adapter"); } @@ -765,14 +765,14 @@ PHP_METHOD(Phalcon_Storage_Adapter_Libmemcached, setSerializer) add_assoc_long_ex(&map, SL("memcached_igbinary"), 2); add_assoc_long_ex(&map, SL("memcached_json"), 3); add_assoc_long_ex(&map, SL("memcached_php"), 1); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 311, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 312, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&serializer); zephir_fast_strtolower(&serializer, &_0); if (zephir_array_isset_value(&map, &serializer)) { ZEPHIR_INIT_VAR(&_1$$3); ZEPHIR_INIT_NVAR(&_1$$3); ZVAL_STRING(&_1$$3, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 311, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 312, &_1$$3); zephir_array_fetch(&_2$$3, &map, &serializer, PH_NOISY | PH_READONLY, "phalcon/Storage/Adapter/Libmemcached.zep", 342); ZVAL_LONG(&_3$$3, -1003); ZEPHIR_CALL_METHOD(NULL, connection, "setoption", NULL, 0, &_3$$3, &_2$$3); diff --git a/ext/phalcon/storage/adapter/memory.zep.c b/ext/phalcon/storage/adapter/memory.zep.c index f54da7b3a8..52ecaa2510 100644 --- a/ext/phalcon/storage/adapter/memory.zep.c +++ b/ext/phalcon/storage/adapter/memory.zep.c @@ -119,7 +119,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, clear) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 312, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 313, &_0); RETURN_MM_BOOL(1); } @@ -161,7 +161,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, getKeys) ZVAL_STR_COPY(&prefix_zv, prefix); } ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 312, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 313, PH_NOISY_CC | PH_READONLY); zephir_array_keys(&_0, &_1); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getfilteredkeys", NULL, 0, &_0, &prefix_zv); zephir_check_call_status(); @@ -201,7 +201,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, setMaxItems) zephir_fetch_params_without_memory_grow(1, 0, &maxItems_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, maxItems); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 313, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 314, &_0); RETURN_THISW(); } @@ -284,11 +284,11 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, doDecrement) } ZEPHIR_CALL_METHOD(&prefixedKey, this_ptr, "getprefixedkey", NULL, 0, &key_zv); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 312, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 313, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&result); ZVAL_BOOL(&result, zephir_array_key_exists(&_0, &prefixedKey)); if (EXPECTED(ZEPHIR_IS_TRUE_IDENTICAL(&result))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 312, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 313, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(¤t, &_1$$3, &prefixedKey, PH_NOISY | PH_READONLY, "phalcon/Storage/Adapter/Memory.zep", 134); ZEPHIR_INIT_VAR(&newValue); ZVAL_LONG(&newValue, (zephir_get_intval(¤t) - value)); @@ -332,11 +332,11 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, doDelete) ZVAL_STR_COPY(&key_zv, key); ZEPHIR_CALL_METHOD(&prefixedKey, this_ptr, "getprefixedkey", NULL, 0, &key_zv); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 312, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 313, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&exists); ZVAL_BOOL(&exists, zephir_array_key_exists(&_0, &prefixedKey)); zephir_unset_property_array(this_ptr, ZEND_STRL("data"), &prefixedKey); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 312, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 313, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_1, &prefixedKey, PH_SEPARATE); RETURN_CCTOR(&exists); } @@ -370,7 +370,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, doGetData) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 312, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 313, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, this_ptr, "getprefixedkey", NULL, 0, &key_zv); zephir_check_call_status(); zephir_array_fetch(&_1, &_0, &_2, PH_NOISY | PH_READONLY, "phalcon/Storage/Adapter/Memory.zep", 170); @@ -409,7 +409,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, doHas) ZVAL_STR_COPY(&key_zv, key); ZEPHIR_CALL_METHOD(&_0, this_ptr, "getprefixedkey", NULL, 0, &key_zv); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 312, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 313, PH_NOISY_CC | PH_READONLY); RETURN_MM_BOOL(zephir_array_key_exists(&_1, &_0)); } @@ -459,11 +459,11 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, doIncrement) } ZEPHIR_CALL_METHOD(&prefixedKey, this_ptr, "getprefixedkey", NULL, 0, &key_zv); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 312, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 313, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&result); ZVAL_BOOL(&result, zephir_array_key_exists(&_0, &prefixedKey)); if (EXPECTED(ZEPHIR_IS_TRUE_IDENTICAL(&result))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 312, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 313, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(¤t, &_1$$3, &prefixedKey, PH_NOISY | PH_READONLY, "phalcon/Storage/Adapter/Memory.zep", 201); ZEPHIR_INIT_VAR(&newValue); ZVAL_LONG(&newValue, (zephir_get_intval(¤t) + value)); @@ -550,25 +550,25 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, doSet) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&prefixedKey, this_ptr, "getprefixedkey", NULL, 0, &key_zv); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 313, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 314, PH_NOISY_CC | PH_READONLY); _2 = ZEPHIR_GT_LONG(&_1, 0); if (_2) { - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 312, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 313, PH_NOISY_CC | PH_READONLY); _2 = !(zephir_array_key_exists(&_3, &prefixedKey)); } _4 = _2; if (_4) { - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 312, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 313, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 313, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 314, PH_NOISY_CC | PH_READONLY); _4 = ZEPHIR_LE_LONG(&_6, zephir_fast_count_int(&_5)); } if (_4) { - zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_1, 312, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_1, 313, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&firstKey, "array_key_first", NULL, 17, &_7$$4); zephir_check_call_status(); if (Z_TYPE_P(&firstKey) != IS_NULL) { zephir_unset_property_array(this_ptr, ZEND_STRL("data"), &firstKey); - zephir_read_property_cached(&_8$$5, this_ptr, _zephir_prop_1, 312, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$5, this_ptr, _zephir_prop_1, 313, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_8$$5, &firstKey, PH_SEPARATE); } } diff --git a/ext/phalcon/storage/adapter/rediscluster.zep.c b/ext/phalcon/storage/adapter/rediscluster.zep.c index 48320a15f7..533a418ee5 100644 --- a/ext/phalcon/storage/adapter/rediscluster.zep.c +++ b/ext/phalcon/storage/adapter/rediscluster.zep.c @@ -291,9 +291,9 @@ PHP_METHOD(Phalcon_Storage_Adapter_RedisCluster, getAdapter) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 314, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 315, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 315, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 316, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_1$$3); /* try_start_1: */ @@ -332,13 +332,13 @@ PHP_METHOD(Phalcon_Storage_Adapter_RedisCluster, getAdapter) return; } } - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 316, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 317, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_13$$3, 2); ZEPHIR_CALL_METHOD(NULL, &connection, "setoption", NULL, 0, &_13$$3, &_1$$3); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "setserializer", NULL, 276, &connection); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "setserializer", NULL, 282, &connection); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 314, &connection); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 315, &connection); } RETURN_MM_MEMBER(getThis(), "adapter"); } @@ -470,14 +470,14 @@ PHP_METHOD(Phalcon_Storage_Adapter_RedisCluster, setSerializer) zephir_check_call_status(); zephir_array_update_string(&map, SL("redis_json"), &_9$$5, PH_COPY | PH_SEPARATE); } - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 317, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 318, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&serializer); zephir_fast_strtolower(&serializer, &_10); if (1 == zephir_array_isset_value(&map, &serializer)) { ZEPHIR_INIT_VAR(&_11$$6); ZEPHIR_INIT_NVAR(&_11$$6); ZVAL_STRING(&_11$$6, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 317, &_11$$6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 318, &_11$$6); zephir_array_fetch(&_12$$6, &map, &serializer, PH_NOISY | PH_READONLY, "phalcon/Storage/Adapter/RedisCluster.zep", 203); ZVAL_LONG(&_13$$6, 1); ZEPHIR_CALL_METHOD(NULL, connection, "setoption", NULL, 0, &_13$$6, &_12$$6); diff --git a/ext/phalcon/storage/adapter/stream.zep.c b/ext/phalcon/storage/adapter/stream.zep.c index 22209617a1..7cb5cbf858 100644 --- a/ext/phalcon/storage/adapter/stream.zep.c +++ b/ext/phalcon/storage/adapter/stream.zep.c @@ -119,7 +119,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, __construct) } ZEPHIR_CALL_METHOD(&_2, this_ptr, "todirseparator", NULL, 0, &storageDir); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 318, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 319, &_2); ZEPHIR_CALL_PARENT(NULL, phalcon_storage_adapter_stream_ce, getThis(), "__construct", NULL, 0, factory, &options); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, this_ptr, "initserializer", NULL, 0); @@ -154,14 +154,14 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, clear) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); result = 1; - ZEPHIR_CALL_METHOD(&directory, this_ptr, "getdir", NULL, 277); + ZEPHIR_CALL_METHOD(&directory, this_ptr, "getdir", NULL, 283); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_0, this_ptr, "phpfileexists", NULL, 0, &directory); zephir_check_call_status(); if (UNEXPECTED(!ZEPHIR_IS_TRUE_IDENTICAL(&_0))) { RETURN_MM_BOOL(result); } - ZEPHIR_CALL_METHOD(&iterator, this_ptr, "getiterator", NULL, 278, &directory); + ZEPHIR_CALL_METHOD(&iterator, this_ptr, "getiterator", NULL, 284, &directory); zephir_check_call_status(); zephir_is_iterable(&iterator, 0, "phalcon/Storage/Adapter/Stream.zep", 107); if (Z_TYPE_P(&iterator) == IS_ARRAY) { @@ -273,7 +273,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, getKeys) } ZEPHIR_INIT_VAR(&files); array_init(&files); - ZEPHIR_CALL_METHOD(&directory, this_ptr, "getdir", NULL, 277); + ZEPHIR_CALL_METHOD(&directory, this_ptr, "getdir", NULL, 283); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_0, this_ptr, "phpfileexists", NULL, 0, &directory); zephir_check_call_status(); @@ -281,7 +281,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, getKeys) array_init(return_value); RETURN_MM(); } - ZEPHIR_CALL_METHOD(&iterator, this_ptr, "getiterator", NULL, 278, &directory); + ZEPHIR_CALL_METHOD(&iterator, this_ptr, "getiterator", NULL, 284, &directory); zephir_check_call_status(); zephir_is_iterable(&iterator, 0, "phalcon/Storage/Adapter/Stream.zep", 137); if (Z_TYPE_P(&iterator) == IS_ARRAY) { @@ -292,7 +292,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, getKeys) ZEPHIR_CALL_METHOD(&_2$$4, &file, "isfile", NULL, 0); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_2$$4)) { - zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_0, 319, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_0, 320, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_4$$5, &file, "getfilename", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_5$$5); @@ -321,7 +321,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, getKeys) ZEPHIR_CALL_METHOD(&_8$$6, &file, "isfile", NULL, 0); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_8$$6)) { - zephir_read_property_cached(&_9$$7, this_ptr, _zephir_prop_0, 319, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$7, this_ptr, _zephir_prop_0, 320, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_10$$7, &file, "getfilename", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_11$$7); @@ -377,7 +377,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, setForever) ZEPHIR_CALL_METHOD(&_1, this_ptr, "getserializeddata", NULL, 0, value); zephir_check_call_status(); zephir_array_update_string(&payload, SL("content"), &_1, PH_COPY | PH_SEPARATE); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "storepayload", NULL, 279, &payload, &key_zv); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "storepayload", NULL, 285, &payload, &key_zv); zephir_check_call_status(); RETURN_MM(); } @@ -466,7 +466,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, doDelete) if (!ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { RETURN_MM_BOOL(0); } - ZEPHIR_CALL_METHOD(&filepath, this_ptr, "getfilepath", NULL, 280, &key_zv); + ZEPHIR_CALL_METHOD(&filepath, this_ptr, "getfilepath", NULL, 286, &key_zv); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "phpunlink", NULL, 0, &filepath); zephir_check_call_status(); @@ -516,7 +516,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, doGet) defaultValue = &defaultValue_sub; defaultValue = &__$null; } - ZEPHIR_CALL_METHOD(&filepath, this_ptr, "getfilepath", NULL, 280, &key_zv); + ZEPHIR_CALL_METHOD(&filepath, this_ptr, "getfilepath", NULL, 286, &key_zv); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_0, this_ptr, "phpfileexists", NULL, 0, &filepath); zephir_check_call_status(); @@ -524,11 +524,11 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, doGet) RETVAL_ZVAL(defaultValue, 1, 0); RETURN_MM(); } - ZEPHIR_CALL_METHOD(&payload, this_ptr, "getpayload", NULL, 281, &filepath); + ZEPHIR_CALL_METHOD(&payload, this_ptr, "getpayload", NULL, 287, &filepath); zephir_check_call_status(); _1 = ZEPHIR_IS_EMPTY(&payload); if (!(_1)) { - ZEPHIR_CALL_METHOD(&_2, this_ptr, "isexpired", NULL, 282, &payload); + ZEPHIR_CALL_METHOD(&_2, this_ptr, "isexpired", NULL, 288, &payload); zephir_check_call_status(); _1 = zephir_is_true(&_2); } @@ -572,19 +572,19 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, doHas) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); - ZEPHIR_CALL_METHOD(&filepath, this_ptr, "getfilepath", NULL, 280, &key_zv); + ZEPHIR_CALL_METHOD(&filepath, this_ptr, "getfilepath", NULL, 286, &key_zv); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_0, this_ptr, "phpfileexists", NULL, 0, &filepath); zephir_check_call_status(); if (UNEXPECTED(!ZEPHIR_IS_TRUE_IDENTICAL(&_0))) { RETURN_MM_BOOL(0); } - ZEPHIR_CALL_METHOD(&payload, this_ptr, "getpayload", NULL, 281, &filepath); + ZEPHIR_CALL_METHOD(&payload, this_ptr, "getpayload", NULL, 287, &filepath); zephir_check_call_status(); if (UNEXPECTED(ZEPHIR_IS_EMPTY(&payload))) { RETURN_MM_BOOL(0); } - ZEPHIR_CALL_METHOD(&_1, this_ptr, "isexpired", NULL, 282, &payload); + ZEPHIR_CALL_METHOD(&_1, this_ptr, "isexpired", NULL, 288, &payload); zephir_check_call_status(); RETURN_MM_BOOL(!zephir_is_true(&_1)); } @@ -712,7 +712,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, doSet) ZEPHIR_CALL_METHOD(&_2, this_ptr, "getserializeddata", NULL, 0, value); zephir_check_call_status(); zephir_array_update_string(&payload, SL("content"), &_2, PH_COPY | PH_SEPARATE); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "storepayload", NULL, 279, &payload, &key_zv); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "storepayload", NULL, 285, &payload, &key_zv); zephir_check_call_status(); RETURN_MM(); } @@ -764,8 +764,8 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, getDir) zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 318, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 319, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 319, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 320, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); ZEPHIR_CONCAT_VV(&_2, &_0, &_1); ZEPHIR_CALL_METHOD(&dirPrefix, this_ptr, "todirseparator", NULL, 0, &_2); @@ -807,7 +807,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, getFilepath) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "getdir", NULL, 277, &key_zv); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "getdir", NULL, 283, &key_zv); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getkeywithoutprefix", NULL, 0, &key_zv); zephir_check_call_status(); @@ -843,10 +843,10 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, getIterator) ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, spl_ce_RecursiveDirectoryIterator); ZVAL_LONG(&_1, 4096); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 283, &dir_zv, &_1); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 289, &dir_zv, &_1); zephir_check_call_status(); ZVAL_LONG(&_1, 2); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 284, &_0, &_1); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 290, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -894,7 +894,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, getPayload) RETURN_MM(); } ZVAL_LONG(&_1, 1); - ZEPHIR_CALL_FUNCTION(&_2, "flock", NULL, 285, &pointer, &_1); + ZEPHIR_CALL_FUNCTION(&_2, "flock", NULL, 291, &pointer, &_1); zephir_check_call_status(); if (EXPECTED(ZEPHIR_IS_TRUE_IDENTICAL(&_2))) { ZEPHIR_CALL_METHOD(&payload, this_ptr, "phpfilegetcontents", NULL, 0, &filepath_zv); @@ -911,12 +911,12 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, getPayload) ZEPHIR_INIT_NVAR(&_0); zephir_create_closure_ex(&_0, NULL, phalcon_2__closure_ce, SL("__invoke")); ZVAL_LONG(&_1, 8); - ZEPHIR_CALL_FUNCTION(NULL, "set_error_handler", NULL, 286, &_0, &_1); + ZEPHIR_CALL_FUNCTION(NULL, "set_error_handler", NULL, 292, &_0, &_1); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&_3, "unserialize", NULL, 26, &payload); zephir_check_call_status(); ZEPHIR_CPY_WRT(&payload, &_3); - ZEPHIR_CALL_FUNCTION(NULL, "restore_error_handler", NULL, 287); + ZEPHIR_CALL_FUNCTION(NULL, "restore_error_handler", NULL, 293); zephir_check_call_status(); _4 = ZEPHIR_GLOBAL(warning).enable; if (!(_4)) { @@ -1021,13 +1021,13 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, storePayload) ZVAL_STR_COPY(&key_zv, key); ZEPHIR_CALL_FUNCTION(&localPayload, "serialize", NULL, 21, &payload); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&directory, this_ptr, "getdir", NULL, 277, &key_zv); + ZEPHIR_CALL_METHOD(&directory, this_ptr, "getdir", NULL, 283, &key_zv); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&_0, "is_dir", NULL, 288, &directory); + ZEPHIR_CALL_FUNCTION(&_0, "is_dir", NULL, 294, &directory); zephir_check_call_status(); if (!(zephir_is_true(&_0))) { ZVAL_LONG(&_1$$3, 0777); - ZEPHIR_CALL_FUNCTION(NULL, "mkdir", NULL, 289, &directory, &_1$$3, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "mkdir", NULL, 295, &directory, &_1$$3, &__$true); zephir_check_call_status(); } ZEPHIR_INIT_VAR(&_3); @@ -1085,7 +1085,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, toDirFromFile) zephir_check_call_status(); ZVAL_LONG(&_0, 0); ZVAL_LONG(&_1, -2); - ZEPHIR_CALL_FUNCTION(&start, "mb_substr", NULL, 290, &name, &_0, &_1); + ZEPHIR_CALL_FUNCTION(&start, "mb_substr", NULL, 296, &name, &_0, &_1); zephir_check_call_status(); _2 = filesystemSafe == 1; if (_2) { @@ -1103,12 +1103,12 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, toDirFromFile) if (!zephir_is_true(&start)) { ZVAL_LONG(&_6$$4, 0); ZVAL_LONG(&_7$$4, 1); - ZEPHIR_CALL_FUNCTION(&start, "mb_substr", NULL, 290, &name, &_6$$4, &_7$$4); + ZEPHIR_CALL_FUNCTION(&start, "mb_substr", NULL, 296, &name, &_6$$4, &_7$$4); zephir_check_call_status(); } ZEPHIR_INIT_VAR(&_8); ZVAL_LONG(&_0, 2); - ZEPHIR_CALL_FUNCTION(&_9, "mb_str_split", NULL, 291, &start, &_0); + ZEPHIR_CALL_FUNCTION(&_9, "mb_str_split", NULL, 297, &start, &_0); zephir_check_call_status(); zephir_fast_join_str(&_8, SL("/"), &_9); ZEPHIR_CONCAT_VS(return_value, &_8, "/"); diff --git a/ext/phalcon/storage/adapter/weak.zep.c b/ext/phalcon/storage/adapter/weak.zep.c index 657b858bd0..10df3b3a07 100644 --- a/ext/phalcon/storage/adapter/weak.zep.c +++ b/ext/phalcon/storage/adapter/weak.zep.c @@ -114,17 +114,17 @@ PHP_METHOD(Phalcon_Storage_Adapter_Weak, __construct) ZEPHIR_INIT_VAR(&_0); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "none"); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 320, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 321, &_0); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "lifetime"); ZVAL_LONG(&_2, 3600); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getarrval", NULL, 0, &options, &_0, &_2); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 321, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 322, &_1); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 322, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 323, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 323, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 324, &options); ZEPHIR_MM_RESTORE(); } @@ -147,7 +147,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Weak, clear) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 324, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 325, &_0); RETURN_MM_BOOL(1); } @@ -192,7 +192,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Weak, getKeys) zephir_memory_observe(&prefix_zv); ZVAL_STR_COPY(&prefix_zv, prefix); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 324, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 325, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&keys); zephir_array_keys(&keys, &_0); ZEPHIR_INIT_VAR(&_1); @@ -329,14 +329,14 @@ PHP_METHOD(Phalcon_Storage_Adapter_Weak, doDelete) Z_PARAM_STR(key) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&key_zv, key); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 325, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 326, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_IDENTICAL(&key_zv, &_0)) { RETURN_BOOL(0); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 324, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 325, PH_NOISY_CC | PH_READONLY); exists = zephir_array_isset_value(&_1, &key_zv); zephir_unset_property_array(this_ptr, ZEND_STRL("weakList"), &key_zv); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 324, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 325, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_2, &key_zv, PH_SEPARATE); RETURN_BOOL(exists); } @@ -390,19 +390,19 @@ PHP_METHOD(Phalcon_Storage_Adapter_Weak, doGet) defaultValue = &defaultValue_sub; defaultValue = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 325, &key_zv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 324, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 326, &key_zv); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 325, PH_NOISY_CC | PH_READONLY); if (0 == zephir_array_isset_value(&_0, &key_zv)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 325, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 326, &__$null); RETVAL_ZVAL(defaultValue, 1, 0); RETURN_MM(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 324, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 325, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&wr); zephir_array_fetch(&wr, &_1, &key_zv, PH_NOISY, "phalcon/Storage/Adapter/Weak.zep", 178); ZEPHIR_CALL_METHOD(&value, &wr, "get", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 325, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 326, &__$null); if (Z_TYPE_P(&value) == IS_NULL) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "delete", NULL, 0, &key_zv); zephir_check_call_status(); @@ -434,7 +434,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Weak, doHas) Z_PARAM_STR(key) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&key_zv, key); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 324, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 325, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &key_zv)); } @@ -525,7 +525,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Weak, doSet) if (Z_TYPE_P(value) != IS_OBJECT) { RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 324, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 325, PH_NOISY_CC | PH_READONLY); if (0 == zephir_array_isset_value(&_0, &key_zv)) { _2$$4 = zephir_fetch_class_str_ex(SL("WeakReference"), ZEND_FETCH_CLASS_AUTO); ZEPHIR_CALL_CE_STATIC(&_1$$4, _2$$4, "create", NULL, 0, value); diff --git a/ext/phalcon/storage/adapterfactory.zep.c b/ext/phalcon/storage/adapterfactory.zep.c index dd93e7e08c..69a2c9517b 100644 --- a/ext/phalcon/storage/adapterfactory.zep.c +++ b/ext/phalcon/storage/adapterfactory.zep.c @@ -70,7 +70,7 @@ PHP_METHOD(Phalcon_Storage_AdapterFactory, __construct) } else { zephir_get_arrval(&services, services_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1304, factory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1313, factory); ZEPHIR_CALL_METHOD(NULL, this_ptr, "init", NULL, 0, &services); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -145,7 +145,7 @@ PHP_METHOD(Phalcon_Storage_AdapterFactory, newInstance) ZEPHIR_INIT_VAR(&_0); zephir_create_array(&_0, 2, 0); zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1304, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1313, PH_NOISY_CC); zephir_array_fast_append(&_0, &_1); zephir_array_fast_append(&_0, &options); ZEPHIR_LAST_CALL_STATUS = zephir_create_instance_params(return_value, &definition, &_0); diff --git a/ext/phalcon/storage/serializer/base64.zep.c b/ext/phalcon/storage/serializer/base64.zep.c index 0102d7ef8e..2e6134a7ad 100644 --- a/ext/phalcon/storage/serializer/base64.zep.c +++ b/ext/phalcon/storage/serializer/base64.zep.c @@ -58,7 +58,7 @@ PHP_METHOD(Phalcon_Storage_Serializer_Base64, serialize) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1305, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1314, PH_NOISY_CC); if (Z_TYPE_P(&_0) != IS_STRING) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_storage_serializer_exceptions_invalidserializationinput_ce); @@ -68,7 +68,7 @@ PHP_METHOD(Phalcon_Storage_Serializer_Base64, serialize) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1305, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1314, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "phpbase64encode", NULL, 0, &_2); zephir_check_call_status(); RETURN_MM(); @@ -127,20 +127,20 @@ PHP_METHOD(Phalcon_Storage_Serializer_Base64, unserialize) zephir_check_call_status(); if (UNEXPECTED(ZEPHIR_IS_FALSE_IDENTICAL(&result))) { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1306, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1315, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1306, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1315, &__$false); } ZEPHIR_INIT_NVAR(&result); ZVAL_STRING(&result, ""); } else { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1306, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1315, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1306, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1315, &__$false); } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1305, &result); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1314, &result); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/storage/serializer/igbinary.zep.c b/ext/phalcon/storage/serializer/igbinary.zep.c index 2327519027..e540ec3d90 100644 --- a/ext/phalcon/storage/serializer/igbinary.zep.c +++ b/ext/phalcon/storage/serializer/igbinary.zep.c @@ -62,28 +62,28 @@ PHP_METHOD(Phalcon_Storage_Serializer_Igbinary, serialize) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 326, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 327, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_0, this_ptr, "isserializable", NULL, 0, &_1); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { RETURN_MM_MEMBER(getThis(), "data"); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 326, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 327, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&result, this_ptr, "doserialize", NULL, 0, &_2); zephir_check_call_status(); if (UNEXPECTED(Z_TYPE_P(&result) == IS_NULL)) { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 327, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 328, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 327, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 328, &__$false); } ZEPHIR_INIT_NVAR(&result); ZVAL_STRING(&result, ""); } else { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 327, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 328, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 327, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 328, &__$false); } } RETURN_CCTOR(&result); @@ -130,18 +130,18 @@ PHP_METHOD(Phalcon_Storage_Serializer_Igbinary, unserialize) ZEPHIR_CALL_METHOD(&_0, this_ptr, "isserializable", NULL, 0, data); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 326, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 327, data); } else { ZEPHIR_GLOBAL(warning).enable = zend_is_true(&__$false); ZEPHIR_INIT_VAR(&_1$$4); ZEPHIR_INIT_NVAR(&_1$$4); zephir_create_closure_ex(&_1$$4, NULL, phalcon_3__closure_ce, SL("__invoke")); ZVAL_LONG(&_2$$4, 2); - ZEPHIR_CALL_FUNCTION(NULL, "set_error_handler", NULL, 286, &_1$$4, &_2$$4); + ZEPHIR_CALL_FUNCTION(NULL, "set_error_handler", NULL, 292, &_1$$4, &_2$$4); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&result, this_ptr, "dounserialize", NULL, 0, data); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(NULL, "restore_error_handler", NULL, 287); + ZEPHIR_CALL_FUNCTION(NULL, "restore_error_handler", NULL, 293); zephir_check_call_status(); _3$$4 = ZEPHIR_GLOBAL(warning).enable; if (!(_3$$4)) { @@ -149,20 +149,20 @@ PHP_METHOD(Phalcon_Storage_Serializer_Igbinary, unserialize) } if (UNEXPECTED(_3$$4)) { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 327, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 328, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 327, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 328, &__$false); } ZEPHIR_INIT_NVAR(&result); ZVAL_STRING(&result, ""); } else { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 327, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 328, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 327, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 328, &__$false); } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 326, &result); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 327, &result); } ZEPHIR_MM_RESTORE(); } @@ -239,7 +239,7 @@ PHP_METHOD(Phalcon_Storage_Serializer_Igbinary, phpIgbinarySerialize) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &value); - ZEPHIR_RETURN_CALL_FUNCTION("igbinary_serialize", NULL, 292, value); + ZEPHIR_RETURN_CALL_FUNCTION("igbinary_serialize", NULL, 298, value); zephir_check_call_status(); RETURN_MM(); } @@ -264,7 +264,7 @@ PHP_METHOD(Phalcon_Storage_Serializer_Igbinary, phpIgbinaryUnserialize) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &value); - ZEPHIR_RETURN_CALL_FUNCTION("igbinary_unserialize", NULL, 293, value); + ZEPHIR_RETURN_CALL_FUNCTION("igbinary_unserialize", NULL, 299, value); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/storage/serializer/json.zep.c b/ext/phalcon/storage/serializer/json.zep.c index ef7a0fb6dd..09f1d6cb55 100644 --- a/ext/phalcon/storage/serializer/json.zep.c +++ b/ext/phalcon/storage/serializer/json.zep.c @@ -85,7 +85,7 @@ PHP_METHOD(Phalcon_Storage_Serializer_Json, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1307, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1316, &_0); ZEPHIR_INIT_VAR(&_1); object_init_ex(&_1, phalcon_support_helper_json_decode_ce); if (zephir_has_constructor(&_1)) { @@ -93,7 +93,7 @@ PHP_METHOD(Phalcon_Storage_Serializer_Json, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1308, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1317, &_1); ZEPHIR_CALL_PARENT(NULL, phalcon_storage_serializer_json_ce, getThis(), "__construct", NULL, 0, data); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -126,14 +126,14 @@ PHP_METHOD(Phalcon_Storage_Serializer_Json, serialize) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1309, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1318, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_0, this_ptr, "isserializable", NULL, 0, &_1); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { RETURN_MM_MEMBER(getThis(), "data"); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1307, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1309, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1316, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1318, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_2, "__invoke", NULL, 0, &_3); zephir_check_call_status(); RETURN_MM(); @@ -176,12 +176,12 @@ PHP_METHOD(Phalcon_Storage_Serializer_Json, unserialize) ZEPHIR_CALL_METHOD(&_0, this_ptr, "isserializable", NULL, 0, data); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1309, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1318, data); } else { - zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_1, 1308, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_1, 1317, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2$$4, &_1$$4, "__invoke", NULL, 0, data); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1309, &_2$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1318, &_2$$4); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/storage/serializer/php.zep.c b/ext/phalcon/storage/serializer/php.zep.c index ffbc01e7e9..eb628e3353 100644 --- a/ext/phalcon/storage/serializer/php.zep.c +++ b/ext/phalcon/storage/serializer/php.zep.c @@ -56,13 +56,13 @@ PHP_METHOD(Phalcon_Storage_Serializer_Php, serialize) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1310, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1319, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_0, this_ptr, "isserializable", NULL, 0, &_1); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { RETURN_MM_MEMBER(getThis(), "data"); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1310, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1319, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "phpserialize", NULL, 0, &_2); zephir_check_call_status(); RETURN_MM(); @@ -109,7 +109,7 @@ PHP_METHOD(Phalcon_Storage_Serializer_Php, unserialize) ZEPHIR_CALL_METHOD(&_0, this_ptr, "isserializable", NULL, 0, data); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1310, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1319, data); RETURN_MM_NULL(); } ZEPHIR_INIT_VAR(&_1); @@ -126,13 +126,13 @@ PHP_METHOD(Phalcon_Storage_Serializer_Php, unserialize) ZEPHIR_GLOBAL(warning).enable = zend_is_true(&__$false); ZEPHIR_INIT_VAR(&_3); ZEPHIR_INIT_NVAR(&_3); - zephir_create_closure_ex(&_3, NULL, phalcon_90__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_3, NULL, phalcon_92__closure_ce, SL("__invoke")); ZVAL_LONG(&_4, (8 | 2)); - ZEPHIR_CALL_FUNCTION(NULL, "set_error_handler", NULL, 286, &_3, &_4); + ZEPHIR_CALL_FUNCTION(NULL, "set_error_handler", NULL, 292, &_3, &_4); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&result, this_ptr, "phpunserialize", NULL, 0, data); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(NULL, "restore_error_handler", NULL, 287); + ZEPHIR_CALL_FUNCTION(NULL, "restore_error_handler", NULL, 293); zephir_check_call_status(); _5 = ZEPHIR_GLOBAL(warning).enable; if (!(_5)) { @@ -140,20 +140,20 @@ PHP_METHOD(Phalcon_Storage_Serializer_Php, unserialize) } if (UNEXPECTED(_5)) { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1311, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1320, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1311, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1320, &__$false); } ZEPHIR_INIT_NVAR(&result); ZVAL_STRING(&result, ""); } else { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1311, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1320, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1311, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1320, &__$false); } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1310, &result); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1319, &result); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/support/collection/readonlycollection.zep.c b/ext/phalcon/support/collection/readonlycollection.zep.c index 34480f32fb..0a7ea7dff3 100644 --- a/ext/phalcon/support/collection/readonlycollection.zep.c +++ b/ext/phalcon/support/collection/readonlycollection.zep.c @@ -122,9 +122,9 @@ PHP_METHOD(Phalcon_Support_Collection_ReadOnlyCollection, __construct) ZEPHIR_CALL_PARENT(NULL, phalcon_support_collection_readonlycollection_ce, getThis(), "__construct", NULL, 0, &data, &_0, &_1, &type_zv); zephir_check_call_status(); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1312, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1321, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1312, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1321, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -163,9 +163,9 @@ PHP_METHOD(Phalcon_Support_Collection_ReadOnlyCollection, __unserialize) zephir_fetch_params(1, 1, 0, &data_param); zephir_get_arrval(&data, data_param); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1312, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1321, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1312, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1321, &__$false); } /* try_start_1: */ @@ -183,9 +183,9 @@ PHP_METHOD(Phalcon_Support_Collection_ReadOnlyCollection, __unserialize) zend_clear_exception(); ZEPHIR_CPY_WRT(&ex, &_0); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1312, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1321, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1312, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1321, &__$false); } zephir_throw_exception_debug(&ex, "phalcon/Support/Collection/ReadOnlyCollection.zep", 64); ZEPHIR_MM_RESTORE(); @@ -193,9 +193,9 @@ PHP_METHOD(Phalcon_Support_Collection_ReadOnlyCollection, __unserialize) } } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1312, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1321, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1312, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1321, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -254,7 +254,7 @@ PHP_METHOD(Phalcon_Support_Collection_ReadOnlyCollection, init) } else { zephir_get_arrval(&data, data_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1312, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1321, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_support_collection_exceptions_readonlyviolation_ce); diff --git a/ext/phalcon/support/debug.zep.c b/ext/phalcon/support/debug.zep.c index c9366494a8..6fa672cb50 100644 --- a/ext/phalcon/support/debug.zep.c +++ b/ext/phalcon/support/debug.zep.c @@ -109,7 +109,7 @@ PHP_METHOD(Phalcon_Support_Debug, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1313, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1322, &_0); ZEPHIR_INIT_VAR(&_1); object_init_ex(&_1, phalcon_support_debug_reportbuilder_ce); if (zephir_has_constructor(&_1)) { @@ -117,7 +117,7 @@ PHP_METHOD(Phalcon_Support_Debug, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1314, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1323, &_1); ZEPHIR_MM_RESTORE(); } @@ -140,7 +140,7 @@ PHP_METHOD(Phalcon_Support_Debug, clearVars) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1315, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1324, &_0); RETURN_THIS(); } @@ -203,8 +203,8 @@ PHP_METHOD(Phalcon_Support_Debug, getCssSources) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1313, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1316, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1322, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1325, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getcsssources", NULL, 0, &_1); zephir_check_call_status(); RETURN_MM(); @@ -233,8 +233,8 @@ PHP_METHOD(Phalcon_Support_Debug, getJsSources) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1313, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1316, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1322, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1325, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getjssources", NULL, 0, &_1); zephir_check_call_status(); RETURN_MM(); @@ -267,7 +267,7 @@ PHP_METHOD(Phalcon_Support_Debug, getVersion) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1313, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1322, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getversion", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -388,7 +388,7 @@ PHP_METHOD(Phalcon_Support_Debug, listenLowSeverity) ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "onUncaughtLowSeverity"); zephir_array_fast_append(&_0, &_1); - ZEPHIR_CALL_FUNCTION(NULL, "set_error_handler", NULL, 286, &_0); + ZEPHIR_CALL_FUNCTION(NULL, "set_error_handler", NULL, 292, &_0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_2); zephir_create_array(&_2, 2, 0); @@ -554,14 +554,14 @@ PHP_METHOD(Phalcon_Support_Debug, renderHtml) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &exception); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1313, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1314, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1317, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 1318, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_4, 1319, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_5, 1320, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_6, 1316, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_7, 1315, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1322, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1323, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1326, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 1327, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_4, 1328, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_5, 1329, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_6, 1325, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_7, 1324, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "build", NULL, 0, exception, &_3, &_4, &_5, &_6, &_7, &_8); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_0, "render", NULL, 0, &_2); @@ -714,7 +714,7 @@ PHP_METHOD(Phalcon_Support_Debug, setBlacklist) } ZEPHIR_INIT_NVAR(&value); zephir_array_update_string(&result, SL("server"), &subArray, PH_COPY | PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1317, &result); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1326, &result); RETURN_THIS(); } @@ -738,7 +738,7 @@ PHP_METHOD(Phalcon_Support_Debug, setRenderer) Z_PARAM_OBJECT_OF_CLASS(renderer, phalcon_contracts_support_debug_renderer_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &renderer); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1313, renderer); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1322, renderer); RETURN_THISW(); } @@ -765,9 +765,9 @@ PHP_METHOD(Phalcon_Support_Debug, setShowBackTrace) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &showBackTrace_param); if (showBackTrace) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1318, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1327, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1318, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1327, &__$false); } RETURN_THISW(); } @@ -796,9 +796,9 @@ PHP_METHOD(Phalcon_Support_Debug, setShowFileFragment) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &showFileFragment_param); if (showFileFragment) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1320, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1329, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1320, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1329, &__$false); } RETURN_THISW(); } @@ -826,9 +826,9 @@ PHP_METHOD(Phalcon_Support_Debug, setShowFiles) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &showFiles_param); if (showFiles) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1319, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1328, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1319, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1328, &__$false); } RETURN_THISW(); } @@ -854,7 +854,7 @@ PHP_METHOD(Phalcon_Support_Debug, setUri) Z_PARAM_STR(uri) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&uri_zv, uri); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1316, &uri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1325, &uri_zv); RETURN_THISW(); } diff --git a/ext/phalcon/support/debug/dump.zep.c b/ext/phalcon/support/debug/dump.zep.c index 27073d69e5..6dac219bb4 100644 --- a/ext/phalcon/support/debug/dump.zep.c +++ b/ext/phalcon/support/debug/dump.zep.c @@ -133,13 +133,13 @@ PHP_METHOD(Phalcon_Support_Debug_Dump, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1321, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1330, &_0); ZEPHIR_CALL_METHOD(NULL, this_ptr, "setstyles", NULL, 0, &styles); zephir_check_call_status(); if (detailed) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1322, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1331, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1322, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1331, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -211,7 +211,7 @@ PHP_METHOD(Phalcon_Support_Debug_Dump, getTemplate) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); zephir_memory_observe(&template); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1323, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1332, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&template, &_0, &name_zv, 0)) { RETURN_CCTOR(&template); } @@ -271,9 +271,9 @@ PHP_METHOD(Phalcon_Support_Debug_Dump, setDetailed) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &flag_param); if (flag) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1322, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1331, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1322, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1331, &__$false); } } @@ -323,7 +323,7 @@ PHP_METHOD(Phalcon_Support_Debug_Dump, setStyles) add_assoc_stringl_ex(&defaultStyles, SL("str"), SL("color:teal")); ZEPHIR_INIT_VAR(&_0); zephir_fast_array_merge(&_0, &defaultStyles, &styles); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1324, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1333, &_0); RETURN_MM_MEMBER_TYPED(getThis(), "styles", IS_ARRAY); } @@ -390,7 +390,7 @@ PHP_METHOD(Phalcon_Support_Debug_Dump, toJson) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &variable); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1321, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1330, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1, (((128 | 64) | 256) | 4194304)); ZEPHIR_RETURN_CALL_METHOD(&_0, "__invoke", NULL, 0, variable, &_1); zephir_check_call_status(); @@ -613,7 +613,7 @@ PHP_METHOD(Phalcon_Support_Debug_Dump, getStyle) zephir_memory_observe(&type_zv); ZVAL_STR_COPY(&type_zv, type); zephir_memory_observe(&style); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1324, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1333, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&style, &_0, &type_zv, 0))) { RETURN_MM_STRING("color:gray"); } @@ -1054,13 +1054,13 @@ PHP_METHOD(Phalcon_Support_Debug_Dump, output) ZEPHIR_CONCAT_VS(&_51$$11, &_50$$11, "[skipped]\n"); zephir_concat_self(&output, &_51$$11); } else { - zephir_read_property_cached(&_47$$9, this_ptr, _zephir_prop_0, 1322, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_47$$9, this_ptr, _zephir_prop_0, 1331, PH_NOISY_CC | PH_READONLY); _48$$9 = !zephir_is_true(&_47$$9); if (!(_48$$9)) { _48$$9 = zephir_is_instance_of(variable, SL("stdClass")); } if (_48$$9) { - ZEPHIR_CALL_FUNCTION(&_52$$12, "get_object_vars", NULL, 313, variable); + ZEPHIR_CALL_FUNCTION(&_52$$12, "get_object_vars", NULL, 325, variable); zephir_check_call_status(); zephir_is_iterable(&_52$$12, 0, "phalcon/Support/Debug/Dump.zep", 367); if (Z_TYPE_P(&_52$$12) == IS_ARRAY) { @@ -1160,10 +1160,10 @@ PHP_METHOD(Phalcon_Support_Debug_Dump, output) } else { ZEPHIR_INIT_VAR(&reflect); object_init_ex(&reflect, zephir_get_internal_ce(SL("reflectionclass"))); - ZEPHIR_CALL_METHOD(NULL, &reflect, "__construct", NULL, 233, variable); + ZEPHIR_CALL_METHOD(NULL, &reflect, "__construct", NULL, 239, variable); zephir_check_call_status(); ZVAL_LONG(&_76$$15, ((1 | 2) | 4)); - ZEPHIR_CALL_METHOD(&props, &reflect, "getproperties", NULL, 325, &_76$$15); + ZEPHIR_CALL_METHOD(&props, &reflect, "getproperties", NULL, 337, &_76$$15); zephir_check_call_status(); zephir_is_iterable(&props, 0, "phalcon/Support/Debug/Dump.zep", 393); if (Z_TYPE_P(&props) == IS_ARRAY) { @@ -1302,7 +1302,7 @@ PHP_METHOD(Phalcon_Support_Debug_Dump, output) zephir_concat_self(&output, &_112$$9); ZEPHIR_INIT_NVAR(&_39$$9); zephir_get_class(&_39$$9, variable, 0); - zephir_read_property_cached(&_107$$9, this_ptr, _zephir_prop_1, 1325, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_107$$9, this_ptr, _zephir_prop_1, 1334, PH_NOISY_CC | PH_READONLY); if (zephir_fast_in_array(&_39$$9, &_107$$9)) { ZVAL_LONG(&_113$$18, tab); ZEPHIR_CALL_FUNCTION(&_114$$18, "str_repeat", &_10, 6, &space, &_113$$18); diff --git a/ext/phalcon/support/debug/renderer/htmlrenderer.zep.c b/ext/phalcon/support/debug/renderer/htmlrenderer.zep.c index 6ed4d39c7f..edc4f7a894 100644 --- a/ext/phalcon/support/debug/renderer/htmlrenderer.zep.c +++ b/ext/phalcon/support/debug/renderer/htmlrenderer.zep.c @@ -163,7 +163,7 @@ PHP_METHOD(Phalcon_Support_Debug_Renderer_HtmlRenderer, getTemplate) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); zephir_memory_observe(&template); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1326, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1335, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&template, &_0, &name_zv, 0)) { RETURN_CCTOR(&template); } diff --git a/ext/phalcon/support/debug/report/backtraceitem.zep.c b/ext/phalcon/support/debug/report/backtraceitem.zep.c index cfa01e1adb..902c1c0788 100644 --- a/ext/phalcon/support/debug/report/backtraceitem.zep.c +++ b/ext/phalcon/support/debug/report/backtraceitem.zep.c @@ -233,20 +233,20 @@ PHP_METHOD(Phalcon_Support_Debug_Report_BacktraceItem, __construct) fragment = &fragment_sub; fragment = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1327, &functionName_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1328, type); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1329, className); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1330, classLink); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1331, functionLink); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1336, &functionName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1337, type); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1338, className); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1339, classLink); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1340, functionLink); if (hasArgs) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1332, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1341, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1332, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1341, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1333, &args); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1334, file); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1335, line); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1336, fragment); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1342, &args); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1343, file); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1344, line); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1345, fragment); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/support/debug/report/exceptionreport.zep.c b/ext/phalcon/support/debug/report/exceptionreport.zep.c index 447f5c663c..4103cb3363 100644 --- a/ext/phalcon/support/debug/report/exceptionreport.zep.c +++ b/ext/phalcon/support/debug/report/exceptionreport.zep.c @@ -152,18 +152,18 @@ PHP_METHOD(Phalcon_Support_Debug_Report_ExceptionReport, __construct) ZVAL_STR(&message_zv, message); ZVAL_STR(&file_zv, file); ZVAL_STR(&uri_zv, uri); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1337, &className_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1338, &message_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1339, &file_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1346, &className_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1347, &message_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1348, &file_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, line); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1340, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1349, &_0); if (showBackTrace) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1341, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1350, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1341, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1350, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1342, &uri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1351, &uri_zv); } /** @@ -292,7 +292,7 @@ PHP_METHOD(Phalcon_Support_Debug_Report_ExceptionReport, hasVariables) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1343, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1352, PH_NOISY_CC); RETURN_MM_BOOL(!(ZEPHIR_IS_EMPTY(&_0))); } @@ -330,7 +330,7 @@ PHP_METHOD(Phalcon_Support_Debug_Report_ExceptionReport, setBacktrace) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &backtrace_param); zephir_get_arrval(&backtrace, backtrace_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1344, &backtrace); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1353, &backtrace); RETURN_THIS(); } @@ -359,7 +359,7 @@ PHP_METHOD(Phalcon_Support_Debug_Report_ExceptionReport, setIncludedFiles) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &includedFiles_param); zephir_get_arrval(&includedFiles, includedFiles_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1345, &includedFiles); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1354, &includedFiles); RETURN_THIS(); } @@ -386,7 +386,7 @@ PHP_METHOD(Phalcon_Support_Debug_Report_ExceptionReport, setMemoryUsage) zephir_fetch_params_without_memory_grow(1, 0, &memoryUsage_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, memoryUsage); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1346, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1355, &_0); RETURN_THISW(); } @@ -413,7 +413,7 @@ PHP_METHOD(Phalcon_Support_Debug_Report_ExceptionReport, setPeakMemoryUsage) zephir_fetch_params_without_memory_grow(1, 0, &peakMemoryUsage_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, peakMemoryUsage); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1347, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1356, &_0); RETURN_THISW(); } @@ -442,7 +442,7 @@ PHP_METHOD(Phalcon_Support_Debug_Report_ExceptionReport, setRequest) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &request_param); zephir_get_arrval(&request, request_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1348, &request); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1357, &request); RETURN_THIS(); } @@ -471,7 +471,7 @@ PHP_METHOD(Phalcon_Support_Debug_Report_ExceptionReport, setServer) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &server_param); zephir_get_arrval(&server, server_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1349, &server); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1358, &server); RETURN_THIS(); } @@ -500,7 +500,7 @@ PHP_METHOD(Phalcon_Support_Debug_Report_ExceptionReport, setVariables) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &variables_param); zephir_get_arrval(&variables, variables_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1343, &variables); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1352, &variables); RETURN_THIS(); } diff --git a/ext/phalcon/support/debug/reportbuilder.zep.c b/ext/phalcon/support/debug/reportbuilder.zep.c index 07a4cb7f58..f6f3399221 100644 --- a/ext/phalcon/support/debug/reportbuilder.zep.c +++ b/ext/phalcon/support/debug/reportbuilder.zep.c @@ -547,7 +547,7 @@ PHP_METHOD(Phalcon_Support_Debug_ReportBuilder, resolveClassLink) } ZEPHIR_INIT_VAR(&reflection); object_init_ex(&reflection, zephir_get_internal_ce(SL("reflectionclass"))); - ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 233, &className_zv); + ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 239, &className_zv); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_4, &reflection, "isinternal", NULL, 0); zephir_check_call_status(); @@ -601,7 +601,7 @@ PHP_METHOD(Phalcon_Support_Debug_ReportBuilder, resolveFunctionLink) } ZEPHIR_INIT_VAR(&reflection); object_init_ex(&reflection, zephir_get_internal_ce(SL("reflectionfunction"))); - ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 230, &functionName_zv); + ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 236, &functionName_zv); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_1, &reflection, "isinternal", NULL, 0); zephir_check_call_status(); @@ -704,7 +704,7 @@ PHP_METHOD(Phalcon_Support_Debug_ReportBuilder, phpExtensionLoaded) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 431, &name_zv); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/support/helper/arr/blacklist.zep.c b/ext/phalcon/support/helper/arr/blacklist.zep.c index a15a153a56..685db67348 100644 --- a/ext/phalcon/support/helper/arr/blacklist.zep.c +++ b/ext/phalcon/support/helper/arr/blacklist.zep.c @@ -67,12 +67,12 @@ PHP_METHOD(Phalcon_Support_Helper_Arr_Blacklist, __invoke) zephir_get_arrval(&blackList, blackList_param); ZEPHIR_INIT_VAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_91__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_93__closure_ce, SL("__invoke")); ZEPHIR_CALL_METHOD(&blackListed, this_ptr, "tofilter", NULL, 0, &blackList, &_0); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&_1, "array_flip", NULL, 247, &blackListed); + ZEPHIR_CALL_FUNCTION(&_1, "array_flip", NULL, 253, &blackListed); zephir_check_call_status(); - ZEPHIR_RETURN_CALL_FUNCTION("array_diff_key", NULL, 243, &collection, &_1); + ZEPHIR_RETURN_CALL_FUNCTION("array_diff_key", NULL, 249, &collection, &_1); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/support/helper/arr/group.zep.c b/ext/phalcon/support/helper/arr/group.zep.c index d84d551f3b..873ad90b5d 100644 --- a/ext/phalcon/support/helper/arr/group.zep.c +++ b/ext/phalcon/support/helper/arr/group.zep.c @@ -316,7 +316,7 @@ PHP_METHOD(Phalcon_Support_Helper_Arr_Group, phpExtensionLoaded) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 431, &name_zv); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/support/helper/arr/isunique.zep.c b/ext/phalcon/support/helper/arr/isunique.zep.c index 1dce2ea851..7993ab300e 100644 --- a/ext/phalcon/support/helper/arr/isunique.zep.c +++ b/ext/phalcon/support/helper/arr/isunique.zep.c @@ -58,7 +58,7 @@ PHP_METHOD(Phalcon_Support_Helper_Arr_IsUnique, __invoke) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &collection_param); zephir_get_arrval(&collection, collection_param); - ZEPHIR_CALL_FUNCTION(&_0, "array_unique", NULL, 390, &collection); + ZEPHIR_CALL_FUNCTION(&_0, "array_unique", NULL, 402, &collection); zephir_check_call_status(); RETURN_MM_BOOL(zephir_fast_count_int(&collection) == zephir_fast_count_int(&_0)); } diff --git a/ext/phalcon/support/helper/arr/sliceleft.zep.c b/ext/phalcon/support/helper/arr/sliceleft.zep.c index 107fc1809f..9d098b7fe2 100644 --- a/ext/phalcon/support/helper/arr/sliceleft.zep.c +++ b/ext/phalcon/support/helper/arr/sliceleft.zep.c @@ -67,7 +67,7 @@ PHP_METHOD(Phalcon_Support_Helper_Arr_SliceLeft, __invoke) } ZVAL_LONG(&_0, 0); ZVAL_LONG(&_1, elements); - ZEPHIR_RETURN_CALL_FUNCTION("array_slice", NULL, 264, &collection, &_0, &_1); + ZEPHIR_RETURN_CALL_FUNCTION("array_slice", NULL, 270, &collection, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/support/helper/arr/sliceright.zep.c b/ext/phalcon/support/helper/arr/sliceright.zep.c index 6630496dbd..70d285f478 100644 --- a/ext/phalcon/support/helper/arr/sliceright.zep.c +++ b/ext/phalcon/support/helper/arr/sliceright.zep.c @@ -65,7 +65,7 @@ PHP_METHOD(Phalcon_Support_Helper_Arr_SliceRight, __invoke) } else { } ZVAL_LONG(&_0, elements); - ZEPHIR_RETURN_CALL_FUNCTION("array_slice", NULL, 264, &collection, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("array_slice", NULL, 270, &collection, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/support/helper/arr/whitelist.zep.c b/ext/phalcon/support/helper/arr/whitelist.zep.c index cbddffdf7d..dfa39565f3 100644 --- a/ext/phalcon/support/helper/arr/whitelist.zep.c +++ b/ext/phalcon/support/helper/arr/whitelist.zep.c @@ -67,10 +67,10 @@ PHP_METHOD(Phalcon_Support_Helper_Arr_Whitelist, __invoke) zephir_get_arrval(&whiteList, whiteList_param); ZEPHIR_INIT_VAR(&_0); ZEPHIR_INIT_NVAR(&_0); - zephir_create_closure_ex(&_0, NULL, phalcon_92__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_0, NULL, phalcon_94__closure_ce, SL("__invoke")); ZEPHIR_CALL_METHOD(&filtered, this_ptr, "tofilter", NULL, 0, &whiteList, &_0); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&_1, "array_flip", NULL, 247, &filtered); + ZEPHIR_CALL_FUNCTION(&_1, "array_flip", NULL, 253, &filtered); zephir_check_call_status(); ZEPHIR_RETURN_CALL_FUNCTION("array_intersect_key", NULL, 7, &collection, &_1); zephir_check_call_status(); diff --git a/ext/phalcon/support/helper/str/decapitalize.zep.c b/ext/phalcon/support/helper/str/decapitalize.zep.c index 498f29c75b..7615dec9a1 100644 --- a/ext/phalcon/support/helper/str/decapitalize.zep.c +++ b/ext/phalcon/support/helper/str/decapitalize.zep.c @@ -89,7 +89,7 @@ PHP_METHOD(Phalcon_Support_Helper_Str_Decapitalize, __invoke) ZVAL_STR_COPY(&encoding_zv, encoding); } ZVAL_LONG(&_0, 1); - ZEPHIR_CALL_FUNCTION(&substr, "mb_substr", NULL, 290, &text_zv, &_0); + ZEPHIR_CALL_FUNCTION(&substr, "mb_substr", NULL, 296, &text_zv, &_0); zephir_check_call_status(); if (upperRest) { ZEPHIR_CALL_METHOD(&suffix, this_ptr, "toupper", NULL, 0, &substr, &encoding_zv); @@ -99,7 +99,7 @@ PHP_METHOD(Phalcon_Support_Helper_Str_Decapitalize, __invoke) } ZVAL_LONG(&_0, 0); ZVAL_LONG(&_2, 1); - ZEPHIR_CALL_FUNCTION(&_3, "mb_substr", NULL, 290, &text_zv, &_0, &_2); + ZEPHIR_CALL_FUNCTION(&_3, "mb_substr", NULL, 296, &text_zv, &_0, &_2); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_1, this_ptr, "tolower", NULL, 0, &_3, &encoding_zv); zephir_check_call_status(); diff --git a/ext/phalcon/support/helper/str/dirfromfile.zep.c b/ext/phalcon/support/helper/str/dirfromfile.zep.c index ff325356d8..738431f0a6 100644 --- a/ext/phalcon/support/helper/str/dirfromfile.zep.c +++ b/ext/phalcon/support/helper/str/dirfromfile.zep.c @@ -112,7 +112,7 @@ PHP_METHOD(Phalcon_Support_Helper_Str_DirFromFile, toDirFromFile) zephir_check_call_status(); ZVAL_LONG(&_0, 0); ZVAL_LONG(&_1, -2); - ZEPHIR_CALL_FUNCTION(&start, "mb_substr", NULL, 290, &name, &_0, &_1); + ZEPHIR_CALL_FUNCTION(&start, "mb_substr", NULL, 296, &name, &_0, &_1); zephir_check_call_status(); _2 = filesystemSafe == 1; if (_2) { @@ -130,12 +130,12 @@ PHP_METHOD(Phalcon_Support_Helper_Str_DirFromFile, toDirFromFile) if (!zephir_is_true(&start)) { ZVAL_LONG(&_6$$4, 0); ZVAL_LONG(&_7$$4, 1); - ZEPHIR_CALL_FUNCTION(&start, "mb_substr", NULL, 290, &name, &_6$$4, &_7$$4); + ZEPHIR_CALL_FUNCTION(&start, "mb_substr", NULL, 296, &name, &_6$$4, &_7$$4); zephir_check_call_status(); } ZEPHIR_INIT_VAR(&_8); ZVAL_LONG(&_0, 2); - ZEPHIR_CALL_FUNCTION(&_9, "mb_str_split", NULL, 291, &start, &_0); + ZEPHIR_CALL_FUNCTION(&_9, "mb_str_split", NULL, 297, &start, &_0); zephir_check_call_status(); zephir_fast_join_str(&_8, SL("/"), &_9); ZEPHIR_CONCAT_VS(return_value, &_8, "/"); diff --git a/ext/phalcon/support/helper/str/dynamic.zep.c b/ext/phalcon/support/helper/str/dynamic.zep.c index 49fda8b49a..36083147d8 100644 --- a/ext/phalcon/support/helper/str/dynamic.zep.c +++ b/ext/phalcon/support/helper/str/dynamic.zep.c @@ -162,7 +162,7 @@ PHP_METHOD(Phalcon_Support_Helper_Str_Dynamic, __invoke) ZEPHIR_INIT_NVAR(&words); zephir_fast_explode(&words, &separator_zv, &_7$$6, LONG_MAX); ZEPHIR_OBS_NVAR(&word); - ZEPHIR_CALL_FUNCTION(&_8$$6, "array_rand", &_9, 466, &words); + ZEPHIR_CALL_FUNCTION(&_8$$6, "array_rand", &_9, 477, &words); zephir_check_call_status(); zephir_array_fetch(&word, &words, &_8$$6, PH_NOISY, "phalcon/Support/Helper/Str/Dynamic.zep", 60); zephir_array_fetch_long(&_10$$6, &match, 0, PH_NOISY | PH_READONLY, "phalcon/Support/Helper/Str/Dynamic.zep", 61); diff --git a/ext/phalcon/support/helperfactory.zep.c b/ext/phalcon/support/helperfactory.zep.c index a7ddbe5a40..d8f2dd9653 100644 --- a/ext/phalcon/support/helperfactory.zep.c +++ b/ext/phalcon/support/helperfactory.zep.c @@ -205,7 +205,7 @@ PHP_METHOD(Phalcon_Support_HelperFactory, newInstance) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1350, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1359, PH_NOISY_CC | PH_READONLY); if (1 != zephir_array_isset_value(&_0, &name_zv)) { ZEPHIR_INIT_VAR(&_1$$3); ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "getservice", NULL, 0, &name_zv); @@ -214,7 +214,7 @@ PHP_METHOD(Phalcon_Support_HelperFactory, newInstance) zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("services"), &name_zv, &_1$$3); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1350, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1359, PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_4, &_3, &name_zv, PH_NOISY | PH_READONLY, "phalcon/Support/HelperFactory.zep", 118); RETURN_CTOR(&_4); } diff --git a/ext/phalcon/tag.zep.c b/ext/phalcon/tag.zep.c index f921d969ef..83dae154be 100644 --- a/ext/phalcon/tag.zep.c +++ b/ext/phalcon/tag.zep.c @@ -889,7 +889,7 @@ PHP_METHOD(Phalcon_Tag, getTitle) zephir_read_static_property_ce(&_6$$3, phalcon_tag_ce, SL("documentPrependTitle"), PH_NOISY_CC); ZEPHIR_CPY_WRT(&documentPrependTitle, &_6$$3); if (!(ZEPHIR_IS_EMPTY(&documentPrependTitle))) { - ZEPHIR_CALL_FUNCTION(&tmp$$5, "array_reverse", NULL, 255, &documentPrependTitle); + ZEPHIR_CALL_FUNCTION(&tmp$$5, "array_reverse", NULL, 261, &documentPrependTitle); zephir_check_call_status(); zephir_is_iterable(&tmp$$5, 0, "phalcon/Tag.zep", 476); if (Z_TYPE_P(&tmp$$5) == IS_ARRAY) { diff --git a/ext/phalcon/time/clock/frozenclock.zep.c b/ext/phalcon/time/clock/frozenclock.zep.c index 6c2cfd30a1..a12c362503 100644 --- a/ext/phalcon/time/clock/frozenclock.zep.c +++ b/ext/phalcon/time/clock/frozenclock.zep.c @@ -60,7 +60,7 @@ PHP_METHOD(Phalcon_Time_Clock_FrozenClock, __construct) Z_PARAM_OBJECT_OF_CLASS(now, php_date_get_immutable_ce()) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &now); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1351, now); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1360, now); } /** @@ -117,7 +117,7 @@ PHP_METHOD(Phalcon_Time_Clock_FrozenClock, adjust) /* try_start_1: */ - zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_0, 1351, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_0, 1360, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&modified, &_4$$4, "modify", NULL, 0, &modifier_zv); zephir_check_call_status_or_jump(try_end_1); @@ -145,14 +145,14 @@ PHP_METHOD(Phalcon_Time_Clock_FrozenClock, adjust) ZEPHIR_GLOBAL(warning).enable = zend_is_true(&__$false); ZEPHIR_INIT_VAR(&_7$$6); ZEPHIR_INIT_NVAR(&_7$$6); - zephir_create_closure_ex(&_7$$6, NULL, phalcon_93__closure_ce, SL("__invoke")); + zephir_create_closure_ex(&_7$$6, NULL, phalcon_95__closure_ce, SL("__invoke")); ZVAL_LONG(&_8$$6, 2); - ZEPHIR_CALL_FUNCTION(NULL, "set_error_handler", NULL, 286, &_7$$6, &_8$$6); + ZEPHIR_CALL_FUNCTION(NULL, "set_error_handler", NULL, 292, &_7$$6, &_8$$6); zephir_check_call_status(); - zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_0, 1351, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_0, 1360, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&modified, &_8$$6, "modify", NULL, 0, &modifier_zv); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(NULL, "restore_error_handler", NULL, 287); + ZEPHIR_CALL_FUNCTION(NULL, "restore_error_handler", NULL, 293); zephir_check_call_status(); failed = ZEPHIR_GLOBAL(warning).enable; ZEPHIR_GLOBAL(warning).enable = zend_is_true(&priorWarning); @@ -170,7 +170,7 @@ PHP_METHOD(Phalcon_Time_Clock_FrozenClock, adjust) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1351, &modified); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1360, &modified); RETURN_THIS(); } @@ -195,7 +195,7 @@ PHP_METHOD(Phalcon_Time_Clock_FrozenClock, fromSystemTimezone) object_init_ex(&_0, php_date_get_immutable_ce()); ZEPHIR_INIT_VAR(&_1); object_init_ex(&_1, php_date_get_timezone_ce()); - ZEPHIR_CALL_FUNCTION(&_2, "date_default_timezone_get", NULL, 241); + ZEPHIR_CALL_FUNCTION(&_2, "date_default_timezone_get", NULL, 247); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 0, &_2); zephir_check_call_status(); @@ -268,7 +268,7 @@ PHP_METHOD(Phalcon_Time_Clock_FrozenClock, set) Z_PARAM_OBJECT_OF_CLASS(now, php_date_get_immutable_ce()) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &now); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1351, now); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1360, now); RETURN_THISW(); } diff --git a/ext/phalcon/time/clock/systemclock.zep.c b/ext/phalcon/time/clock/systemclock.zep.c index 50a80e24b0..e9a866968d 100644 --- a/ext/phalcon/time/clock/systemclock.zep.c +++ b/ext/phalcon/time/clock/systemclock.zep.c @@ -58,7 +58,7 @@ PHP_METHOD(Phalcon_Time_Clock_SystemClock, __construct) Z_PARAM_OBJECT_OF_CLASS(timezone, php_date_get_timezone_ce()) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &timezone); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1352, timezone); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1361, timezone); } /** @@ -78,11 +78,11 @@ PHP_METHOD(Phalcon_Time_Clock_SystemClock, fromSystemTimezone) object_init_ex(return_value, phalcon_time_clock_systemclock_ce); ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, php_date_get_timezone_ce()); - ZEPHIR_CALL_FUNCTION(&_1, "date_default_timezone_get", NULL, 241); + ZEPHIR_CALL_FUNCTION(&_1, "date_default_timezone_get", NULL, 247); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 242, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 248, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -108,7 +108,7 @@ PHP_METHOD(Phalcon_Time_Clock_SystemClock, fromUTC) ZVAL_STRING(&_1, "UTC"); ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 0, &_1); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 242, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 248, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -133,7 +133,7 @@ PHP_METHOD(Phalcon_Time_Clock_SystemClock, now) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); object_init_ex(return_value, php_date_get_immutable_ce()); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1352, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1361, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "now"); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &_1, &_0); diff --git a/ext/phalcon/traits/php/apcutrait.zep.c b/ext/phalcon/traits/php/apcutrait.zep.c index 4e8f0c210b..c7e7a2cf76 100644 --- a/ext/phalcon/traits/php/apcutrait.zep.c +++ b/ext/phalcon/traits/php/apcutrait.zep.c @@ -65,7 +65,7 @@ PHP_METHOD(Phalcon_Traits_Php_ApcuTrait, phpApcuDec) } else { } ZVAL_LONG(&_0, step); - ZEPHIR_RETURN_CALL_FUNCTION("apcu_dec", NULL, 265, key, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("apcu_dec", NULL, 271, key, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -90,7 +90,7 @@ PHP_METHOD(Phalcon_Traits_Php_ApcuTrait, phpApcuDelete) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &key); - ZEPHIR_RETURN_CALL_FUNCTION("apcu_delete", NULL, 266, key); + ZEPHIR_RETURN_CALL_FUNCTION("apcu_delete", NULL, 272, key); zephir_check_call_status(); RETURN_MM(); } @@ -115,7 +115,7 @@ PHP_METHOD(Phalcon_Traits_Php_ApcuTrait, phpApcuExists) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &key); - ZEPHIR_RETURN_CALL_FUNCTION("apcu_exists", NULL, 267, key); + ZEPHIR_RETURN_CALL_FUNCTION("apcu_exists", NULL, 273, key); zephir_check_call_status(); RETURN_MM(); } @@ -140,7 +140,7 @@ PHP_METHOD(Phalcon_Traits_Php_ApcuTrait, phpApcuFetch) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &key); - ZEPHIR_RETURN_CALL_FUNCTION("apcu_fetch", NULL, 268, key); + ZEPHIR_RETURN_CALL_FUNCTION("apcu_fetch", NULL, 274, key); zephir_check_call_status(); RETURN_MM(); } @@ -174,7 +174,7 @@ PHP_METHOD(Phalcon_Traits_Php_ApcuTrait, phpApcuInc) } else { } ZVAL_LONG(&_0, step); - ZEPHIR_RETURN_CALL_FUNCTION("apcu_inc", NULL, 269, key, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("apcu_inc", NULL, 275, key, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -239,7 +239,7 @@ PHP_METHOD(Phalcon_Traits_Php_ApcuTrait, phpApcuStore) } else { } ZVAL_LONG(&_0, ttl); - ZEPHIR_RETURN_CALL_FUNCTION("apcu_store", NULL, 270, key, payload, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("apcu_store", NULL, 276, key, payload, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/traits/php/headertrait.zep.c b/ext/phalcon/traits/php/headertrait.zep.c index f1d5c3a3c1..c947fe5116 100644 --- a/ext/phalcon/traits/php/headertrait.zep.c +++ b/ext/phalcon/traits/php/headertrait.zep.c @@ -49,7 +49,7 @@ PHP_METHOD(Phalcon_Traits_Php_HeaderTrait, phpHeadersSent) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - ZEPHIR_RETURN_CALL_FUNCTION("headers_sent", NULL, 0); + ZEPHIR_RETURN_CALL_FUNCTION("headers_sent", NULL, 215); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/traits/php/igbinarytrait.zep.c b/ext/phalcon/traits/php/igbinarytrait.zep.c index 312fca781a..2ec60e56a3 100644 --- a/ext/phalcon/traits/php/igbinarytrait.zep.c +++ b/ext/phalcon/traits/php/igbinarytrait.zep.c @@ -55,7 +55,7 @@ PHP_METHOD(Phalcon_Traits_Php_IgbinaryTrait, phpIgbinarySerialize) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &value); - ZEPHIR_RETURN_CALL_FUNCTION("igbinary_serialize", NULL, 292, value); + ZEPHIR_RETURN_CALL_FUNCTION("igbinary_serialize", NULL, 298, value); zephir_check_call_status(); RETURN_MM(); } @@ -80,7 +80,7 @@ PHP_METHOD(Phalcon_Traits_Php_IgbinaryTrait, phpIgbinaryUnserialize) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &value); - ZEPHIR_RETURN_CALL_FUNCTION("igbinary_unserialize", NULL, 293, value); + ZEPHIR_RETURN_CALL_FUNCTION("igbinary_unserialize", NULL, 299, value); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/traits/php/infotrait.zep.c b/ext/phalcon/traits/php/infotrait.zep.c index 5fc3e36ded..4e5eba07cd 100644 --- a/ext/phalcon/traits/php/infotrait.zep.c +++ b/ext/phalcon/traits/php/infotrait.zep.c @@ -59,7 +59,7 @@ PHP_METHOD(Phalcon_Traits_Php_InfoTrait, phpExtensionLoaded) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 431, &name_zv); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/traits/php/initrait.zep.c b/ext/phalcon/traits/php/initrait.zep.c index cf1338362c..97f4a9f2fa 100644 --- a/ext/phalcon/traits/php/initrait.zep.c +++ b/ext/phalcon/traits/php/initrait.zep.c @@ -72,7 +72,7 @@ PHP_METHOD(Phalcon_Traits_Php_IniTrait, phpIniGet) zephir_memory_observe(&defaultValue_zv); ZVAL_STR_COPY(&defaultValue_zv, defaultValue); } - ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 427, &input_zv); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&value)) { RETURN_MM_STR(zend_string_copy(defaultValue)); @@ -119,7 +119,7 @@ PHP_METHOD(Phalcon_Traits_Php_IniTrait, phpIniGetBool) } else { } result = 0; - ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 427, &input_zv); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&value)) { RETURN_MM_BOOL(defaultValue); @@ -171,7 +171,7 @@ PHP_METHOD(Phalcon_Traits_Php_IniTrait, phpIniGetInt) defaultValue = 0; } else { } - ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 427, &input_zv); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&value)) { RETURN_MM_LONG(defaultValue); @@ -227,7 +227,7 @@ PHP_METHOD(Phalcon_Traits_Php_IniTrait, phpParseIniFile) } ZVAL_BOOL(&_0, (processSections ? 1 : 0)); ZVAL_LONG(&_1, scannerMode); - ZEPHIR_RETURN_CALL_FUNCTION("parse_ini_file", NULL, 416, &filename_zv, &_0, &_1); + ZEPHIR_RETURN_CALL_FUNCTION("parse_ini_file", NULL, 428, &filename_zv, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/traits/php/yamltrait.zep.c b/ext/phalcon/traits/php/yamltrait.zep.c index e9a27f66be..51f0e501ba 100644 --- a/ext/phalcon/traits/php/yamltrait.zep.c +++ b/ext/phalcon/traits/php/yamltrait.zep.c @@ -89,7 +89,7 @@ PHP_METHOD(Phalcon_Traits_Php_YamlTrait, phpYamlParseFile) ZVAL_NULL(&ndocs); ZVAL_LONG(&_0, pos); ZEPHIR_MAKE_REF(&ndocs); - ZEPHIR_RETURN_CALL_FUNCTION("yaml_parse_file", NULL, 420, &filename_zv, &_0, &ndocs, &callbacks); + ZEPHIR_RETURN_CALL_FUNCTION("yaml_parse_file", NULL, 432, &filename_zv, &_0, &ndocs, &callbacks); ZEPHIR_UNREF(&ndocs); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/traits/support/helper/str/dirfromfiletrait.zep.c b/ext/phalcon/traits/support/helper/str/dirfromfiletrait.zep.c index 0f84bec227..a4446bd9c5 100644 --- a/ext/phalcon/traits/support/helper/str/dirfromfiletrait.zep.c +++ b/ext/phalcon/traits/support/helper/str/dirfromfiletrait.zep.c @@ -86,7 +86,7 @@ PHP_METHOD(Phalcon_Traits_Support_Helper_Str_DirFromFileTrait, toDirFromFile) zephir_check_call_status(); ZVAL_LONG(&_0, 0); ZVAL_LONG(&_1, -2); - ZEPHIR_CALL_FUNCTION(&start, "mb_substr", NULL, 290, &name, &_0, &_1); + ZEPHIR_CALL_FUNCTION(&start, "mb_substr", NULL, 296, &name, &_0, &_1); zephir_check_call_status(); _2 = filesystemSafe == 1; if (_2) { @@ -104,12 +104,12 @@ PHP_METHOD(Phalcon_Traits_Support_Helper_Str_DirFromFileTrait, toDirFromFile) if (!zephir_is_true(&start)) { ZVAL_LONG(&_6$$4, 0); ZVAL_LONG(&_7$$4, 1); - ZEPHIR_CALL_FUNCTION(&start, "mb_substr", NULL, 290, &name, &_6$$4, &_7$$4); + ZEPHIR_CALL_FUNCTION(&start, "mb_substr", NULL, 296, &name, &_6$$4, &_7$$4); zephir_check_call_status(); } ZEPHIR_INIT_VAR(&_8); ZVAL_LONG(&_0, 2); - ZEPHIR_CALL_FUNCTION(&_9, "mb_str_split", NULL, 291, &start, &_0); + ZEPHIR_CALL_FUNCTION(&_9, "mb_str_split", NULL, 297, &start, &_0); zephir_check_call_status(); zephir_fast_join_str(&_8, SL("/"), &_9); ZEPHIR_CONCAT_VS(return_value, &_8, "/"); diff --git a/ext/phalcon/translate/adapter/csv.zep.c b/ext/phalcon/translate/adapter/csv.zep.c index 9a99abdfd9..5b7e8f1d48 100644 --- a/ext/phalcon/translate/adapter/csv.zep.c +++ b/ext/phalcon/translate/adapter/csv.zep.c @@ -168,7 +168,7 @@ PHP_METHOD(Phalcon_Translate_Adapter_Csv, has) Z_PARAM_STR(index) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&index_zv, index); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1353, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1362, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &index_zv)); } @@ -217,7 +217,7 @@ PHP_METHOD(Phalcon_Translate_Adapter_Csv, query) zephir_get_arrval(&placeholders, placeholders_param); } zephir_memory_observe(&translation); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1353, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1362, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&translation, &_0, &translateKey_zv, 0))) { ZEPHIR_CALL_METHOD(&translation, this_ptr, "notfound", NULL, 0, &translateKey_zv); zephir_check_call_status(); diff --git a/ext/phalcon/translate/adapter/gettext.zep.c b/ext/phalcon/translate/adapter/gettext.zep.c index 7a9a13a604..8bad824149 100644 --- a/ext/phalcon/translate/adapter/gettext.zep.c +++ b/ext/phalcon/translate/adapter/gettext.zep.c @@ -388,7 +388,7 @@ PHP_METHOD(Phalcon_Translate_Adapter_Gettext, setDefaultDomain) Z_PARAM_STR(domain) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&domain_zv, domain); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1354, &domain_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1363, &domain_zv); } /** @@ -439,7 +439,7 @@ PHP_METHOD(Phalcon_Translate_Adapter_Gettext, setDirectory) if (ZEPHIR_IS_EMPTY(directory)) { RETURN_MM_NULL(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1355, directory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1364, directory); if (Z_TYPE_P(directory) == IS_ARRAY) { zephir_is_iterable(directory, 0, "phalcon/Translate/Adapter/Gettext.zep", 250); if (Z_TYPE_P(directory) == IS_ARRAY) { @@ -591,28 +591,28 @@ PHP_METHOD(Phalcon_Translate_Adapter_Gettext, setLocale) ZVAL_LONG(&_0, category); ZEPHIR_CALL_FUNCTION(&_1, "setlocale", NULL, 0, &_0, &localeArray); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1356, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1365, &_1); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, category); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1357, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1356, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1366, &_0); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1365, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_FALSE_IDENTICAL(&_0)) { - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 1356, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 1365, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_3$$3); ZEPHIR_CONCAT_SV(&_3$$3, "LC_ALL=", &_2$$3); ZEPHIR_CALL_FUNCTION(NULL, "putenv", NULL, 0, &_3$$3); zephir_check_call_status(); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 1356, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 1365, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_5$$3); ZEPHIR_CONCAT_SV(&_5$$3, "LANG=", &_4$$3); ZEPHIR_CALL_FUNCTION(NULL, "putenv", NULL, 0, &_5$$3); zephir_check_call_status(); - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 1356, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 1365, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_7$$3); ZEPHIR_CONCAT_SV(&_7$$3, "LANGUAGE=", &_6$$3); ZEPHIR_CALL_FUNCTION(NULL, "putenv", NULL, 0, &_7$$3); zephir_check_call_status(); - zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 1356, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 1365, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_9$$3, 6); ZEPHIR_CALL_FUNCTION(NULL, "setlocale", NULL, 0, &_9$$3, &_8$$3); zephir_check_call_status(); @@ -718,7 +718,7 @@ PHP_METHOD(Phalcon_Translate_Adapter_Gettext, phpExtensionLoaded) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 431, &name_zv); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/translate/adapter/nativearray.zep.c b/ext/phalcon/translate/adapter/nativearray.zep.c index 222a5622c7..e93c5afeb8 100644 --- a/ext/phalcon/translate/adapter/nativearray.zep.c +++ b/ext/phalcon/translate/adapter/nativearray.zep.c @@ -104,7 +104,7 @@ PHP_METHOD(Phalcon_Translate_Adapter_NativeArray, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1358, &data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1367, &data); ZEPHIR_MM_RESTORE(); } @@ -161,7 +161,7 @@ PHP_METHOD(Phalcon_Translate_Adapter_NativeArray, has) Z_PARAM_STR(index) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&index_zv, index); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1358, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1367, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &index_zv)); } @@ -210,7 +210,7 @@ PHP_METHOD(Phalcon_Translate_Adapter_NativeArray, query) zephir_get_arrval(&placeholders, placeholders_param); } zephir_memory_observe(&translation); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1358, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1367, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&translation, &_0, &translateKey_zv, 0))) { ZEPHIR_RETURN_CALL_METHOD(this_ptr, "notfound", NULL, 0, &translateKey_zv); zephir_check_call_status(); diff --git a/ext/phalcon/translate/exceptions/missingrequiredparameter.zep.c b/ext/phalcon/translate/exceptions/missingrequiredparameter.zep.c index c267a37711..e373116649 100644 --- a/ext/phalcon/translate/exceptions/missingrequiredparameter.zep.c +++ b/ext/phalcon/translate/exceptions/missingrequiredparameter.zep.c @@ -60,7 +60,7 @@ PHP_METHOD(Phalcon_Translate_Exceptions_MissingRequiredParameter, __construct) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(¶meter_zv); ZVAL_STR_COPY(¶meter_zv, parameter); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1359, ¶meter_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1368, ¶meter_zv); ZEPHIR_INIT_VAR(&_0); ZEPHIR_CONCAT_SVS(&_0, "Parameter '", ¶meter_zv, "' is required"); ZEPHIR_CALL_PARENT(NULL, phalcon_translate_exceptions_missingrequiredparameter_ce, getThis(), "__construct", NULL, 0, &_0); diff --git a/ext/phalcon/translate/translatefactory.zep.c b/ext/phalcon/translate/translatefactory.zep.c index 37cbec4f1c..3ebe5611fa 100644 --- a/ext/phalcon/translate/translatefactory.zep.c +++ b/ext/phalcon/translate/translatefactory.zep.c @@ -87,7 +87,7 @@ PHP_METHOD(Phalcon_Translate_TranslateFactory, __construct) } else { zephir_get_arrval(&services, services_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1360, interpolator); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1369, interpolator); ZEPHIR_CALL_METHOD(NULL, this_ptr, "init", NULL, 0, &services); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -189,7 +189,7 @@ PHP_METHOD(Phalcon_Translate_TranslateFactory, newInstance) ZEPHIR_INIT_VAR(&_0); zephir_create_array(&_0, 2, 0); zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1360, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1369, PH_NOISY_CC); zephir_array_fast_append(&_0, &_1); zephir_array_fast_append(&_0, &options); ZEPHIR_LAST_CALL_STATUS = zephir_create_instance_params(return_value, &definition, &_0); From f6cac25c60782e53b9918ad2cdba4126c4a0d507 Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Fri, 17 Jul 2026 21:13:43 -0500 Subject: [PATCH 8/8] [#17341] - correcting stubs --- ext/phalcon/adr/kernel/abstracthttpkernel.zep.c | 3 +++ phalcon/ADR/Kernel/AbstractHttpKernel.zep | 3 +++ 2 files changed, 6 insertions(+) diff --git a/ext/phalcon/adr/kernel/abstracthttpkernel.zep.c b/ext/phalcon/adr/kernel/abstracthttpkernel.zep.c index b131dbb0fc..e1182601f1 100644 --- a/ext/phalcon/adr/kernel/abstracthttpkernel.zep.c +++ b/ext/phalcon/adr/kernel/abstracthttpkernel.zep.c @@ -38,6 +38,9 @@ ZEPHIR_INIT_CLASS(Phalcon_ADR_Kernel_AbstractHttpKernel) { ZEPHIR_REGISTER_CLASS(Phalcon\\ADR\\Kernel, AbstractHttpKernel, phalcon, adr_kernel_abstracthttpkernel, phalcon_adr_kernel_abstracthttpkernel_method_entry, ZEND_ACC_EXPLICIT_ABSTRACT_CLASS); + /** + * @var string + */ zend_declare_property_null(phalcon_adr_kernel_abstracthttpkernel_ce, SL("projectRoot"), ZEND_ACC_PROTECTED); zend_class_implements(phalcon_adr_kernel_abstracthttpkernel_ce, 1, phalcon_contracts_adr_kernel_kernel_ce); return SUCCESS; diff --git a/phalcon/ADR/Kernel/AbstractHttpKernel.zep b/phalcon/ADR/Kernel/AbstractHttpKernel.zep index 12581c56f6..914e282fb5 100644 --- a/phalcon/ADR/Kernel/AbstractHttpKernel.zep +++ b/phalcon/ADR/Kernel/AbstractHttpKernel.zep @@ -24,6 +24,9 @@ use Phalcon\Contracts\ADR\Kernel\Kernel; */ abstract class AbstractHttpKernel implements Kernel { + /** + * @var string + */ protected projectRoot; public function __construct(string projectRoot)