From 4b65b0dc034edd446ffac461336bca4f0abfb743 Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Fri, 17 Jul 2026 19:58:25 -0500 Subject: [PATCH 1/6] [#17341] - add ADR event catalog Assisted-by: Claude Code --- phalcon/ADR/Events/Event.zep | 52 +++++++++++++++++++++++++++++ tests/unit/ADR/Events/EventTest.php | 33 ++++++++++++++++++ 2 files changed, 85 insertions(+) create mode 100644 phalcon/ADR/Events/Event.zep create mode 100644 tests/unit/ADR/Events/EventTest.php diff --git a/phalcon/ADR/Events/Event.zep b/phalcon/ADR/Events/Event.zep new file mode 100644 index 0000000000..0c7acfc7e3 --- /dev/null +++ b/phalcon/ADR/Events/Event.zep @@ -0,0 +1,52 @@ + +/** + * 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\Events; + +/** + * The ADR event vocabulary, fired through the native events manager. + */ +class Event +{ + /** + * @var string + */ + const ADR_AFTER_EXECUTE_ACTION = "adr:afterExecuteAction"; + /** + * @var string + */ + const ADR_BEFORE_EXECUTE_ACTION = "adr:beforeExecuteAction"; + /** + * @var string + */ + const APPLICATION_AFTER_HANDLE = "application:afterHandle"; + /** + * @var string + */ + const APPLICATION_BEFORE_HANDLE = "application:beforeHandle"; + /** + * @var string + */ + const PIPELINE_AFTER_DISPATCH = "pipeline:afterDispatch"; + /** + * @var string + */ + const PIPELINE_BEFORE_DISPATCH = "pipeline:beforeDispatch"; + + /** + * Instantiation not allowed. + */ + final private function __construct() + { + } +} diff --git a/tests/unit/ADR/Events/EventTest.php b/tests/unit/ADR/Events/EventTest.php new file mode 100644 index 0000000000..41f38aa914 --- /dev/null +++ b/tests/unit/ADR/Events/EventTest.php @@ -0,0 +1,33 @@ + + * + * 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\Events; + +use Phalcon\ADR\Events\Event; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; + +final class EventTest extends AbstractUnitTestCase +{ + /** + * Unit Tests Phalcon\ADR\Events\Event :: event name constants + */ + public function testAdrEventsEventNames(): void + { + $this->assertSame('application:beforeHandle', Event::APPLICATION_BEFORE_HANDLE); + $this->assertSame('application:afterHandle', Event::APPLICATION_AFTER_HANDLE); + $this->assertSame('pipeline:beforeDispatch', Event::PIPELINE_BEFORE_DISPATCH); + $this->assertSame('pipeline:afterDispatch', Event::PIPELINE_AFTER_DISPATCH); + $this->assertSame('adr:beforeExecuteAction', Event::ADR_BEFORE_EXECUTE_ACTION); + $this->assertSame('adr:afterExecuteAction', Event::ADR_AFTER_EXECUTE_ACTION); + } +} From 98557050f70f5c25e4fed74f2104a1141f32422e Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Fri, 17 Jul 2026 19:58:25 -0500 Subject: [PATCH 2/6] [#17341] - add ADR Pipeline Assisted-by: Claude Code --- phalcon/ADR/Pipeline.zep | 64 ++++++++++++++++++ tests/unit/ADR/Pipeline/InvokeTest.php | 92 ++++++++++++++++++++++++++ 2 files changed, 156 insertions(+) create mode 100644 phalcon/ADR/Pipeline.zep create mode 100644 tests/unit/ADR/Pipeline/InvokeTest.php diff --git a/phalcon/ADR/Pipeline.zep b/phalcon/ADR/Pipeline.zep new file mode 100644 index 0000000000..05a99f7cd3 --- /dev/null +++ b/phalcon/ADR/Pipeline.zep @@ -0,0 +1,64 @@ + +/** + * 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\Contracts\ADR\Handler; +use Phalcon\Contracts\Http\AttributeRequestInterface; +use Phalcon\Http\ResponseInterface; + +/** + * Self-recursive middleware runner. It is itself a Handler: it carries an index + * and hands a new Pipeline (advanced by one) forward as the `next` handler, so + * `next` is always a real Handler - no anonymous classes or callables. + * + * When the middleware is exhausted it invokes the terminal handler (the Action). + */ +final class Pipeline implements Handler +{ + /** + * @var int + */ + protected index; + + /** + * @var array + */ + protected middleware; + + /** + * @var Handler + */ + protected terminal; + + public function __construct(array middleware, terminal, int index = 0) + { + let this->middleware = middleware, + this->terminal = terminal, + this->index = index; + } + + public function __invoke( request) -> + { + var mw, next; + + if this->index >= count(this->middleware) { + return this->terminal->__invoke(request); + } + + let mw = this->middleware[this->index], + next = new Pipeline(this->middleware, this->terminal, this->index + 1); + + return mw->__invoke(request, next); + } +} diff --git a/tests/unit/ADR/Pipeline/InvokeTest.php b/tests/unit/ADR/Pipeline/InvokeTest.php new file mode 100644 index 0000000000..4bc9a0706a --- /dev/null +++ b/tests/unit/ADR/Pipeline/InvokeTest.php @@ -0,0 +1,92 @@ + + * + * 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\Pipeline; + +use Phalcon\ADR\Pipeline; +use Phalcon\Contracts\ADR\Handler; +use Phalcon\Contracts\ADR\Middleware; +use Phalcon\Contracts\Http\AttributeRequestInterface; +use Phalcon\Http\Request; +use Phalcon\Http\Response; +use Phalcon\Http\ResponseInterface; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; + +final class InvokeTest extends AbstractUnitTestCase +{ + /** + * Unit Tests Phalcon\ADR\Pipeline :: __invoke() runs the terminal handler + */ + public function testAdrPipelineInvokeRunsTerminal(): void + { + $pipeline = new Pipeline([], $this->terminal('terminal')); + + $result = $pipeline(new Request()); + + $this->assertSame('terminal', $result->getContent()); + } + + /** + * Unit Tests Phalcon\ADR\Pipeline :: __invoke() threads middleware as an onion + */ + public function testAdrPipelineInvokeRunsMiddlewareOnion(): void + { + $wrap = new class implements Middleware { + public function __invoke(AttributeRequestInterface $request, Handler $next): ResponseInterface + { + $response = $next($request); + + return $response->setContent('[' . $response->getContent() . ']'); + } + }; + + $pipeline = new Pipeline([$wrap, $wrap], $this->terminal('T')); + + $result = $pipeline(new Request()); + + $this->assertSame('[[T]]', $result->getContent()); + } + + /** + * Unit Tests Phalcon\ADR\Pipeline :: __invoke() a middleware can short-circuit + */ + public function testAdrPipelineInvokeMiddlewareCanShortCircuit(): void + { + $shortCircuit = new class implements Middleware { + public function __invoke(AttributeRequestInterface $request, Handler $next): ResponseInterface + { + return (new Response())->setContent('short-circuit'); + } + }; + + $pipeline = new Pipeline([$shortCircuit], $this->terminal('terminal-ran')); + + $result = $pipeline(new Request()); + + $this->assertSame('short-circuit', $result->getContent()); + } + + private function terminal(string $body): Handler + { + return new class ($body) implements Handler { + public function __construct(private string $body) + { + } + + public function __invoke(AttributeRequestInterface $request): ResponseInterface + { + return (new Response())->setContent($this->body); + } + }; + } +} From e81e6440322cb950cbcde4f910602f23369ee59a Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Fri, 17 Jul 2026 19:58:25 -0500 Subject: [PATCH 3/6] [#17341] - add ADR middleware (request id, timing, method override, cors) Assisted-by: Claude Code --- phalcon/ADR/Middleware/CorsMiddleware.zep | 111 ++++++++++++++++++ .../Middleware/MethodOverrideMiddleware.zep | 51 ++++++++ .../ADR/Middleware/RequestIdMiddleware.zep | 43 +++++++ phalcon/ADR/Middleware/TimingMiddleware.zep | 39 ++++++ .../Middleware/CorsMiddleware/InvokeTest.php | 63 ++++++++++ .../MethodOverrideMiddleware/InvokeTest.php | 72 ++++++++++++ .../RequestIdMiddleware/InvokeTest.php | 49 ++++++++ .../TimingMiddleware/InvokeTest.php | 48 ++++++++ 8 files changed, 476 insertions(+) create mode 100644 phalcon/ADR/Middleware/CorsMiddleware.zep create mode 100644 phalcon/ADR/Middleware/MethodOverrideMiddleware.zep create mode 100644 phalcon/ADR/Middleware/RequestIdMiddleware.zep create mode 100644 phalcon/ADR/Middleware/TimingMiddleware.zep create mode 100644 tests/unit/ADR/Middleware/CorsMiddleware/InvokeTest.php create mode 100644 tests/unit/ADR/Middleware/MethodOverrideMiddleware/InvokeTest.php create mode 100644 tests/unit/ADR/Middleware/RequestIdMiddleware/InvokeTest.php create mode 100644 tests/unit/ADR/Middleware/TimingMiddleware/InvokeTest.php diff --git a/phalcon/ADR/Middleware/CorsMiddleware.zep b/phalcon/ADR/Middleware/CorsMiddleware.zep new file mode 100644 index 0000000000..36d2f89e6a --- /dev/null +++ b/phalcon/ADR/Middleware/CorsMiddleware.zep @@ -0,0 +1,111 @@ + +/** + * 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\Middleware; + +use Phalcon\Contracts\ADR\Handler; +use Phalcon\Contracts\ADR\Middleware; +use Phalcon\Contracts\Http\AttributeRequestInterface; +use Phalcon\Http\Response; +use Phalcon\Http\ResponseInterface; + +/** + * CORS middleware. Inert by default: it emits nothing until an origin allowlist + * is configured, and only for requests whose `Origin` is on it. The allowed + * origin is always echoed back explicitly, so credentials are never paired with + * a wildcard origin. Preflight `OPTIONS` requests are answered directly. + */ +class CorsMiddleware implements Middleware +{ + /** + * @var bool + */ + protected allowCredentials = false; + + /** + * @var array + */ + protected allowedHeaders; + + /** + * @var array + */ + protected allowedMethods; + + /** + * @var array + */ + protected allowedOrigins; + + /** + * @var int + */ + protected maxAge = 0; + + public function __construct(array config = []) + { + let this->allowedOrigins = isset config["origins"] ? config["origins"] : [], + this->allowedMethods = isset config["methods"] ? config["methods"] : ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"], + this->allowedHeaders = isset config["headers"] ? config["headers"] : ["Content-Type", "Authorization"], + this->allowCredentials = isset config["credentials"] ? (bool) config["credentials"] : false, + this->maxAge = isset config["maxAge"] ? (int) config["maxAge"] : 0; + } + + public function __invoke( request, next) -> + { + var origin, response; + + let origin = request->getHeader("Origin"); + + if empty origin || !this->isAllowed(origin) { + return next->__invoke(request); + } + + if "OPTIONS" === request->getMethod() { + let response = new Response(); + response->setStatusCode(204); + this->applyHeaders(response, origin); + response->setHeader("Access-Control-Allow-Methods", implode(", ", this->allowedMethods)); + response->setHeader("Access-Control-Allow-Headers", implode(", ", this->allowedHeaders)); + + if this->maxAge > 0 { + response->setHeader("Access-Control-Max-Age", (string) this->maxAge); + } + + return response; + } + + let response = next->__invoke(request); + this->applyHeaders(response, origin); + + return response; + } + + protected function applyHeaders( response, string origin) -> void + { + response->setHeader("Access-Control-Allow-Origin", origin); + + if this->allowCredentials { + response->setHeader("Access-Control-Allow-Credentials", "true"); + } + } + + protected function isAllowed(string origin) -> bool + { + if in_array("*", this->allowedOrigins, true) { + return true; + } + + return in_array(origin, this->allowedOrigins, true); + } +} diff --git a/phalcon/ADR/Middleware/MethodOverrideMiddleware.zep b/phalcon/ADR/Middleware/MethodOverrideMiddleware.zep new file mode 100644 index 0000000000..b3aa115c68 --- /dev/null +++ b/phalcon/ADR/Middleware/MethodOverrideMiddleware.zep @@ -0,0 +1,51 @@ + +/** + * 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\Middleware; + +use Phalcon\Contracts\ADR\Handler; +use Phalcon\Contracts\ADR\Middleware; +use Phalcon\Contracts\Http\AttributeRequestInterface; +use Phalcon\Http\ResponseInterface; + +/** + * Thin enabler for the native `_method` override. + * + * `Request::getMethod()` already honors `X-HTTP-Method-Override` and, when the + * parameter-override flag is on, the `_method` field. This middleware only + * turns that flag on, and only for a `POST` request whose `_method` names a + * safe verb (`PUT`/`PATCH`/`DELETE`), so `_method` cannot spoof an arbitrary + * method. + */ +class MethodOverrideMiddleware implements Middleware +{ + /** + * @var array + */ + protected allowed = ["DELETE", "PATCH", "PUT"]; + + public function __invoke( request, next) -> + { + var spoofed; + + if "POST" === request->getMethod() { + let spoofed = strtoupper((string) request->getPost("_method")); + + if in_array(spoofed, this->allowed, true) { + request->setHttpMethodParameterOverride(true); + } + } + + return next->__invoke(request); + } +} diff --git a/phalcon/ADR/Middleware/RequestIdMiddleware.zep b/phalcon/ADR/Middleware/RequestIdMiddleware.zep new file mode 100644 index 0000000000..4a915825de --- /dev/null +++ b/phalcon/ADR/Middleware/RequestIdMiddleware.zep @@ -0,0 +1,43 @@ + +/** + * 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\Middleware; + +use Phalcon\Contracts\ADR\Handler; +use Phalcon\Contracts\ADR\Middleware; +use Phalcon\Contracts\Http\AttributeRequestInterface; +use Phalcon\Http\ResponseInterface; + +/** + * Ensures every request carries an `X-Request-Id`, reusing an incoming one or + * generating it, exposing it on the request attributes and the response. + */ +class RequestIdMiddleware implements Middleware +{ + public function __invoke( request, next) -> + { + var id, response; + + let id = request->getHeader("X-Request-Id"); + if empty id { + let id = bin2hex(random_bytes(16)); + } + + request->getAttributes()->set("requestId", id); + + let response = next->__invoke(request); + response->setHeader("X-Request-Id", id); + + return response; + } +} diff --git a/phalcon/ADR/Middleware/TimingMiddleware.zep b/phalcon/ADR/Middleware/TimingMiddleware.zep new file mode 100644 index 0000000000..c38decd3b3 --- /dev/null +++ b/phalcon/ADR/Middleware/TimingMiddleware.zep @@ -0,0 +1,39 @@ + +/** + * 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\Middleware; + +use Phalcon\Contracts\ADR\Handler; +use Phalcon\Contracts\ADR\Middleware; +use Phalcon\Contracts\Http\AttributeRequestInterface; +use Phalcon\Http\ResponseInterface; + +/** + * Adds an `X-Response-Time` header measuring how long the rest of the pipeline + * took to produce the response. + */ +class TimingMiddleware implements Middleware +{ + public function __invoke( request, next) -> + { + var start, response, elapsed; + + let start = microtime(true), + response = next->__invoke(request), + elapsed = (microtime(true) - start) * 1000.0; + + response->setHeader("X-Response-Time", sprintf("%.2fms", elapsed)); + + return response; + } +} diff --git a/tests/unit/ADR/Middleware/CorsMiddleware/InvokeTest.php b/tests/unit/ADR/Middleware/CorsMiddleware/InvokeTest.php new file mode 100644 index 0000000000..f9d6f46689 --- /dev/null +++ b/tests/unit/ADR/Middleware/CorsMiddleware/InvokeTest.php @@ -0,0 +1,63 @@ + + * + * 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\Middleware\CorsMiddleware; + +use Phalcon\ADR\Middleware\CorsMiddleware; +use Phalcon\Contracts\ADR\Handler; +use Phalcon\Contracts\Http\AttributeRequestInterface; +use Phalcon\Http\Request; +use Phalcon\Http\Response; +use Phalcon\Http\ResponseInterface; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; + +final class InvokeTest extends AbstractUnitTestCase +{ + /** + * Unit Tests Phalcon\ADR\Middleware\CorsMiddleware :: __invoke() is inert unconfigured + */ + public function testAdrMiddlewareCorsMiddlewareInertWithoutConfig(): void + { + $response = (new CorsMiddleware())(new Request(), $this->next()); + + $this->assertFalse($response->getHeaders()->get('Access-Control-Allow-Origin')); + } + + /** + * Unit Tests Phalcon\ADR\Middleware\CorsMiddleware :: __invoke() echoes an allowed origin + */ + public function testAdrMiddlewareCorsMiddlewareAllowsConfiguredOrigin(): void + { + $_SERVER['HTTP_ORIGIN'] = 'https://example.com'; + + $middleware = new CorsMiddleware(['origins' => ['https://example.com']]); + $response = $middleware(new Request(), $this->next()); + + $this->assertSame( + 'https://example.com', + $response->getHeaders()->get('Access-Control-Allow-Origin') + ); + + unset($_SERVER['HTTP_ORIGIN']); + } + + private function next(): Handler + { + return new class implements Handler { + public function __invoke(AttributeRequestInterface $request): ResponseInterface + { + return new Response(); + } + }; + } +} diff --git a/tests/unit/ADR/Middleware/MethodOverrideMiddleware/InvokeTest.php b/tests/unit/ADR/Middleware/MethodOverrideMiddleware/InvokeTest.php new file mode 100644 index 0000000000..ed8bfee668 --- /dev/null +++ b/tests/unit/ADR/Middleware/MethodOverrideMiddleware/InvokeTest.php @@ -0,0 +1,72 @@ + + * + * 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\Middleware\MethodOverrideMiddleware; + +use Phalcon\ADR\Middleware\MethodOverrideMiddleware; +use Phalcon\Contracts\ADR\Handler; +use Phalcon\Contracts\Http\AttributeRequestInterface; +use Phalcon\Http\Request; +use Phalcon\Http\Response; +use Phalcon\Http\ResponseInterface; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; + +final class InvokeTest extends AbstractUnitTestCase +{ + /** + * Unit Tests Phalcon\ADR\Middleware\MethodOverrideMiddleware :: __invoke() + */ + public function testAdrMiddlewareMethodOverrideMiddlewareInvokeEnablesWhitelisted(): void + { + $_SERVER['REQUEST_METHOD'] = 'POST'; + $_POST['_method'] = 'PUT'; + $_REQUEST['_method'] = 'PUT'; + + $request = new Request(); + $this->assertSame('POST', $request->getMethod()); + + (new MethodOverrideMiddleware())($request, $this->next()); + + $this->assertSame('PUT', $request->getMethod()); + + unset($_SERVER['REQUEST_METHOD'], $_POST['_method'], $_REQUEST['_method']); + } + + /** + * Unit Tests Phalcon\ADR\Middleware\MethodOverrideMiddleware :: __invoke() ignores non-whitelisted verbs + */ + public function testAdrMiddlewareMethodOverrideMiddlewareIgnoresNonWhitelisted(): void + { + $_SERVER['REQUEST_METHOD'] = 'POST'; + $_POST['_method'] = 'GET'; + $_REQUEST['_method'] = 'GET'; + + $request = new Request(); + + (new MethodOverrideMiddleware())($request, $this->next()); + + $this->assertSame('POST', $request->getMethod()); + + unset($_SERVER['REQUEST_METHOD'], $_POST['_method'], $_REQUEST['_method']); + } + + private function next(): Handler + { + return new class implements Handler { + public function __invoke(AttributeRequestInterface $request): ResponseInterface + { + return new Response(); + } + }; + } +} diff --git a/tests/unit/ADR/Middleware/RequestIdMiddleware/InvokeTest.php b/tests/unit/ADR/Middleware/RequestIdMiddleware/InvokeTest.php new file mode 100644 index 0000000000..1bf3e7fb62 --- /dev/null +++ b/tests/unit/ADR/Middleware/RequestIdMiddleware/InvokeTest.php @@ -0,0 +1,49 @@ + + * + * 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\Middleware\RequestIdMiddleware; + +use Phalcon\ADR\Middleware\RequestIdMiddleware; +use Phalcon\Contracts\ADR\Handler; +use Phalcon\Contracts\Http\AttributeRequestInterface; +use Phalcon\Http\Request; +use Phalcon\Http\Response; +use Phalcon\Http\ResponseInterface; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; + +final class InvokeTest extends AbstractUnitTestCase +{ + /** + * Unit Tests Phalcon\ADR\Middleware\RequestIdMiddleware :: __invoke() + */ + public function testAdrMiddlewareRequestIdMiddlewareInvoke(): void + { + $request = new Request(); + $response = (new RequestIdMiddleware())($request, $this->next()); + + $id = $request->getAttributes()->get('requestId'); + + $this->assertNotEmpty($id); + $this->assertSame($id, $response->getHeaders()->get('X-Request-Id')); + } + + private function next(): Handler + { + return new class implements Handler { + public function __invoke(AttributeRequestInterface $request): ResponseInterface + { + return new Response(); + } + }; + } +} diff --git a/tests/unit/ADR/Middleware/TimingMiddleware/InvokeTest.php b/tests/unit/ADR/Middleware/TimingMiddleware/InvokeTest.php new file mode 100644 index 0000000000..b1b8b5632f --- /dev/null +++ b/tests/unit/ADR/Middleware/TimingMiddleware/InvokeTest.php @@ -0,0 +1,48 @@ + + * + * 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\Middleware\TimingMiddleware; + +use Phalcon\ADR\Middleware\TimingMiddleware; +use Phalcon\Contracts\ADR\Handler; +use Phalcon\Contracts\Http\AttributeRequestInterface; +use Phalcon\Http\Request; +use Phalcon\Http\Response; +use Phalcon\Http\ResponseInterface; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; + +final class InvokeTest extends AbstractUnitTestCase +{ + /** + * Unit Tests Phalcon\ADR\Middleware\TimingMiddleware :: __invoke() + */ + public function testAdrMiddlewareTimingMiddlewareInvoke(): void + { + $response = (new TimingMiddleware())(new Request(), $this->next()); + + $time = $response->getHeaders()->get('X-Response-Time'); + + $this->assertIsString($time); + $this->assertStringEndsWith('ms', $time); + } + + private function next(): Handler + { + return new class implements Handler { + public function __invoke(AttributeRequestInterface $request): ResponseInterface + { + return new Response(); + } + }; + } +} From 706a4e947d48c1c9185694b0d069e2589297912f Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Fri, 17 Jul 2026 19:58:26 -0500 Subject: [PATCH 4/6] [#17341] - add ADR Dispatcher and EventfulHandler Assisted-by: Claude Code --- phalcon/ADR/Dispatcher.zep | 105 ++++++++++++++++++ phalcon/ADR/EventfulHandler.zep | 57 ++++++++++ phalcon/Contracts/ADR/Dispatcher.zep | 26 +++++ tests/unit/ADR/Dispatcher/DispatchTest.php | 79 +++++++++++++ tests/unit/ADR/EventfulHandler/InvokeTest.php | 52 +++++++++ 5 files changed, 319 insertions(+) create mode 100644 phalcon/ADR/Dispatcher.zep create mode 100644 phalcon/ADR/EventfulHandler.zep create mode 100644 phalcon/Contracts/ADR/Dispatcher.zep create mode 100644 tests/unit/ADR/Dispatcher/DispatchTest.php create mode 100644 tests/unit/ADR/EventfulHandler/InvokeTest.php diff --git a/phalcon/ADR/Dispatcher.zep b/phalcon/ADR/Dispatcher.zep new file mode 100644 index 0000000000..151c917472 --- /dev/null +++ b/phalcon/ADR/Dispatcher.zep @@ -0,0 +1,105 @@ + +/** + * 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\Exceptions\NotAnAction; +use Phalcon\Contracts\ADR\Action; +use Phalcon\Contracts\ADR\Dispatcher as DispatcherInterface; +use Phalcon\Contracts\Container\Ioc\IocContainer; +use Phalcon\Contracts\Events\Manager; +use Phalcon\Contracts\Http\AttributeRequestInterface; +use Phalcon\Http\ResponseInterface; + +/** + * Resolves the Action (and middleware) through the container, wraps it in the + * pipeline and runs it, firing the `pipeline:*` events. Global middleware is + * resolved once and cached; only route middleware resolves per request. + * + * The container resolution is the one deliberate Service Locator: it uses the + * resolve-only `IocContainer` contract, so a container swap is a two-method + * adapter. Everything else is constructor-injected. + */ +final class Dispatcher implements DispatcherInterface +{ + /** + * @var IocContainer + */ + protected container; + + /** + * @var Manager + */ + protected events; + + /** + * @var array + */ + protected globalMiddleware; + + /** + * @var array|null + */ + protected resolvedGlobal = null; + + public function __construct( container, events, array globalMiddleware = []) + { + let this->container = container, + this->events = events, + this->globalMiddleware = globalMiddleware; + } + + public function dispatch(string actionClass, request, array routeMiddleware = []) -> + { + var action, middleware, terminal, pipeline, response; + + let action = this->container->getService(actionClass); + if !(action instanceof Action) { + throw new NotAnAction("Class '" . actionClass . "' is not an ADR Action."); + } + + let middleware = array_merge(this->resolveGlobal(), this->resolveAll(routeMiddleware)), + terminal = new EventfulHandler(action, this->events), + pipeline = new Pipeline(middleware, terminal); + + this->events->fire(Event::PIPELINE_BEFORE_DISPATCH, this, request); + + let response = pipeline->__invoke(request); + + this->events->fire(Event::PIPELINE_AFTER_DISPATCH, this, response); + + return response; + } + + protected function resolveAll(array classes) -> array + { + var result, className; + + let result = []; + for className in classes { + let result[] = this->container->getService(className); + } + + return result; + } + + protected function resolveGlobal() -> array + { + if null === this->resolvedGlobal { + let this->resolvedGlobal = this->resolveAll(this->globalMiddleware); + } + + return this->resolvedGlobal; + } +} diff --git a/phalcon/ADR/EventfulHandler.zep b/phalcon/ADR/EventfulHandler.zep new file mode 100644 index 0000000000..5a707975da --- /dev/null +++ b/phalcon/ADR/EventfulHandler.zep @@ -0,0 +1,57 @@ + +/** + * 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\Contracts\ADR\Action; +use Phalcon\Contracts\ADR\Handler; +use Phalcon\Contracts\Events\Manager; +use Phalcon\Contracts\Http\AttributeRequestInterface; +use Phalcon\Http\ResponseInterface; + +/** + * The terminal handler of the pipeline: fires the `adr:*` events around the + * Action's execution. + */ +final class EventfulHandler implements Handler +{ + /** + * @var Action + */ + protected action; + + /** + * @var Manager + */ + protected events; + + public function __construct( action, events) + { + let this->action = action, + this->events = events; + } + + public function __invoke( request) -> + { + var response; + + this->events->fire(Event::ADR_BEFORE_EXECUTE_ACTION, this->action, request); + + let response = this->action->__invoke(request); + + this->events->fire(Event::ADR_AFTER_EXECUTE_ACTION, this->action, response); + + return response; + } +} diff --git a/phalcon/Contracts/ADR/Dispatcher.zep b/phalcon/Contracts/ADR/Dispatcher.zep new file mode 100644 index 0000000000..aed4d799fc --- /dev/null +++ b/phalcon/Contracts/ADR/Dispatcher.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; + +/** + * Resolves an Action by class name, builds the middleware pipeline around it and + * runs it to produce a response. + */ +interface Dispatcher +{ + public function dispatch(string actionClass, request, array routeMiddleware = []) -> ; +} diff --git a/tests/unit/ADR/Dispatcher/DispatchTest.php b/tests/unit/ADR/Dispatcher/DispatchTest.php new file mode 100644 index 0000000000..0a0a6429c8 --- /dev/null +++ b/tests/unit/ADR/Dispatcher/DispatchTest.php @@ -0,0 +1,79 @@ + + * + * 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\Dispatcher; + +use Phalcon\ADR\Dispatcher; +use Phalcon\ADR\Exceptions\NotAnAction; +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\Talon\PHPUnit\AbstractUnitTestCase; +use stdClass; + +final class DispatchTest extends AbstractUnitTestCase +{ + /** + * Unit Tests Phalcon\ADR\Dispatcher :: dispatch() resolves and runs the action + */ + public function testAdrDispatcherDispatchRunsAction(): void + { + $action = new class implements Action { + public function __invoke(AttributeRequestInterface $request): ResponseInterface + { + return (new Response())->setContent('dispatched'); + } + }; + + $dispatcher = new Dispatcher($this->containerReturning($action), new Manager()); + + $response = $dispatcher->dispatch('SomeAction', new Request()); + + $this->assertSame('dispatched', $response->getContent()); + } + + /** + * Unit Tests Phalcon\ADR\Dispatcher :: dispatch() rejects a non-Action + */ + public function testAdrDispatcherDispatchRejectsNonAction(): void + { + $dispatcher = new Dispatcher($this->containerReturning(new stdClass()), new Manager()); + + $this->expectException(NotAnAction::class); + + $dispatcher->dispatch('NotAnAction', new Request()); + } + + 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; + } + }; + } +} diff --git a/tests/unit/ADR/EventfulHandler/InvokeTest.php b/tests/unit/ADR/EventfulHandler/InvokeTest.php new file mode 100644 index 0000000000..f9bcf20f8a --- /dev/null +++ b/tests/unit/ADR/EventfulHandler/InvokeTest.php @@ -0,0 +1,52 @@ + + * + * 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\EventfulHandler; + +use Phalcon\ADR\EventfulHandler; +use Phalcon\Contracts\ADR\Action; +use Phalcon\Contracts\Http\AttributeRequestInterface; +use Phalcon\Events\Manager; +use Phalcon\Http\Request; +use Phalcon\Http\Response; +use Phalcon\Http\ResponseInterface; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; + +final class InvokeTest extends AbstractUnitTestCase +{ + /** + * Unit Tests Phalcon\ADR\EventfulHandler :: __invoke() fires the adr events + */ + public function testAdrEventfulHandlerInvokeFiresEvents(): void + { + $action = new class implements Action { + public function __invoke(AttributeRequestInterface $request): ResponseInterface + { + return new Response(); + } + }; + + $manager = new Manager(); + $count = 0; + $manager->attach( + 'adr', + function () use (&$count) { + $count++; + } + ); + + (new EventfulHandler($action, $manager))(new Request()); + + $this->assertSame(2, $count); + } +} From 74205b9e360423d953f11962201a0b1b16e7ddf8 Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Fri, 17 Jul 2026 19:58:26 -0500 Subject: [PATCH 5/6] [#17341] - add ADR Router Assisted-by: Claude Code --- .../Router/Exceptions/MethodNotAllowed.zep | 23 ++++ .../ADR/Router/Exceptions/RouteNotFound.zep | 23 ++++ phalcon/ADR/Router/Group.zep | 86 ++++++++++++++ phalcon/ADR/Router/Route.zep | 111 ++++++++++++++++++ phalcon/ADR/Router/Router.zep | 111 ++++++++++++++++++ phalcon/ADR/Router/RouterMatch.zep | 70 +++++++++++ phalcon/ADR/Router/Traits/HasMiddleware.zep | 40 +++++++ phalcon/Contracts/ADR/Router/Group.zep | 23 ++++ phalcon/Contracts/ADR/Router/Route.zep | 25 ++++ phalcon/Contracts/ADR/Router/Router.zep | 40 +++++++ phalcon/Contracts/ADR/Router/RouterMatch.zep | 29 +++++ .../ADR/Router/Route/AllowsMethodTest.php | 34 ++++++ tests/unit/ADR/Router/Route/MatchesTest.php | 42 +++++++ tests/unit/ADR/Router/Router/GroupTest.php | 49 ++++++++ tests/unit/ADR/Router/Router/MatchTest.php | 79 +++++++++++++ .../ADR/Router/RouterMatch/GettersTest.php | 33 ++++++ 16 files changed, 818 insertions(+) create mode 100644 phalcon/ADR/Router/Exceptions/MethodNotAllowed.zep create mode 100644 phalcon/ADR/Router/Exceptions/RouteNotFound.zep create mode 100644 phalcon/ADR/Router/Group.zep create mode 100644 phalcon/ADR/Router/Route.zep create mode 100644 phalcon/ADR/Router/Router.zep create mode 100644 phalcon/ADR/Router/RouterMatch.zep create mode 100644 phalcon/ADR/Router/Traits/HasMiddleware.zep create mode 100644 phalcon/Contracts/ADR/Router/Group.zep create mode 100644 phalcon/Contracts/ADR/Router/Route.zep create mode 100644 phalcon/Contracts/ADR/Router/Router.zep create mode 100644 phalcon/Contracts/ADR/Router/RouterMatch.zep create mode 100644 tests/unit/ADR/Router/Route/AllowsMethodTest.php create mode 100644 tests/unit/ADR/Router/Route/MatchesTest.php create mode 100644 tests/unit/ADR/Router/Router/GroupTest.php create mode 100644 tests/unit/ADR/Router/Router/MatchTest.php create mode 100644 tests/unit/ADR/Router/RouterMatch/GettersTest.php diff --git a/phalcon/ADR/Router/Exceptions/MethodNotAllowed.zep b/phalcon/ADR/Router/Exceptions/MethodNotAllowed.zep new file mode 100644 index 0000000000..1a2226d615 --- /dev/null +++ b/phalcon/ADR/Router/Exceptions/MethodNotAllowed.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\Router\Exceptions; + +use Phalcon\ADR\Exceptions\Exception; + +/** + * Thrown when a route matches the path but not the request method. + */ +class MethodNotAllowed extends Exception +{ +} diff --git a/phalcon/ADR/Router/Exceptions/RouteNotFound.zep b/phalcon/ADR/Router/Exceptions/RouteNotFound.zep new file mode 100644 index 0000000000..b2fff67597 --- /dev/null +++ b/phalcon/ADR/Router/Exceptions/RouteNotFound.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\Router\Exceptions; + +use Phalcon\ADR\Exceptions\Exception; + +/** + * Thrown when no route matches the request. + */ +class RouteNotFound extends Exception +{ +} diff --git a/phalcon/ADR/Router/Group.zep b/phalcon/ADR/Router/Group.zep new file mode 100644 index 0000000000..c7f59dc858 --- /dev/null +++ b/phalcon/ADR/Router/Group.zep @@ -0,0 +1,86 @@ + +/** + * 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\Router; + +use Phalcon\ADR\Router\Traits\HasMiddleware; +use Phalcon\Contracts\ADR\Router\Group as GroupInterface; +use Phalcon\Contracts\ADR\Router\Route as RouteInterface; + +/** + * A group of routes sharing a path prefix and middleware. Routes registered + * through the group get the prefix prepended and the group's middleware + * flattened onto them (set middleware before adding routes). + */ +class Group implements GroupInterface +{ + use HasMiddleware; + + /** + * @var string + */ + protected prefix; + + /** + * @var Router + */ + protected router; + + public function __construct(string prefix, router) + { + let this->prefix = prefix, + this->router = router; + } + + public function add(string pattern, string actionClass, array methods = []) -> + { + var route; + + let route = this->router->add(this->prefix . pattern, actionClass, methods); + route->pushMiddleware(this->middleware); + + return route; + } + + public function delete(string pattern, string actionClass) -> + { + return this->add(pattern, actionClass, ["DELETE"]); + } + + public function get(string pattern, string actionClass) -> + { + return this->add(pattern, actionClass, ["GET"]); + } + + public function patch(string pattern, string actionClass) -> + { + return this->add(pattern, actionClass, ["PATCH"]); + } + + public function post(string pattern, string actionClass) -> + { + return this->add(pattern, actionClass, ["POST"]); + } + + public function put(string pattern, string actionClass) -> + { + return this->add(pattern, actionClass, ["PUT"]); + } + + public function withMiddleware(string... classes) -> + { + this->pushMiddleware(classes); + + return this; + } +} diff --git a/phalcon/ADR/Router/Route.zep b/phalcon/ADR/Router/Route.zep new file mode 100644 index 0000000000..48214e7874 --- /dev/null +++ b/phalcon/ADR/Router/Route.zep @@ -0,0 +1,111 @@ + +/** + * 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\Router; + +use Phalcon\ADR\Router\Traits\HasMiddleware; +use Phalcon\Contracts\ADR\Router\Route as RouteInterface; + +/** + * A route registered with the router. Compiles a `/posts/{id}` style pattern to + * a regular expression (with `{name:regex}` constraints supported) and matches + * the request path against it, extracting the named parameters. + */ +class Route implements RouteInterface +{ + use HasMiddleware; + + /** + * @var string + */ + protected action; + + /** + * @var string + */ + protected compiled; + + /** + * @var array + */ + protected methods; + + /** + * @var string|null + */ + protected name = null; + + public function __construct(string pattern, string action, array methods = []) + { + let this->action = action, + this->methods = methods, + this->compiled = this->compile(pattern); + } + + public function allowsMethod(string method) -> bool + { + return empty this->methods || in_array(method, this->methods, true); + } + + public function getAction() -> string + { + return this->action; + } + + public function getName() -> string | null + { + return this->name; + } + + public function matches(string uri) -> array | bool + { + var matches, params, key, value; + + if !preg_match(this->compiled, uri, matches) { + return false; + } + + let params = []; + for key, value in matches { + if typeof key === "string" { + let params[key] = value; + } + } + + return params; + } + + public function withMiddleware(string... classes) -> + { + this->pushMiddleware(classes); + + return this; + } + + public function withName(string name) -> + { + let this->name = name; + + return this; + } + + protected function compile(string pattern) -> string + { + var compiled; + + let compiled = preg_replace("#\\{([a-zA-Z_][a-zA-Z0-9_]*):([^{}]+)\\}#", "(?<$1>$2)", pattern), + compiled = preg_replace("#\\{([a-zA-Z_][a-zA-Z0-9_]*)\\}#", "(?<$1>[^/]+)", compiled); + + return "#^" . compiled . "$#"; + } +} diff --git a/phalcon/ADR/Router/Router.zep b/phalcon/ADR/Router/Router.zep new file mode 100644 index 0000000000..ea13de63b4 --- /dev/null +++ b/phalcon/ADR/Router/Router.zep @@ -0,0 +1,111 @@ + +/** + * 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\Router; + +use Closure; +use Phalcon\ADR\Router\Exceptions\MethodNotAllowed; +use Phalcon\Contracts\ADR\Router\Router as RouterInterface; +use Phalcon\Contracts\ADR\Router\RouterMatch as RouterMatchInterface; +use Phalcon\Http\RequestInterface; + +/** + * The ADR router. Routes are registered by pattern + HTTP method (verb helpers + * or `add()`), optionally grouped, and matched against the request. `match()` + * returns a RouterMatch, `null` when nothing matches, or throws + * MethodNotAllowed when a path matches but the method does not. + */ +final class Router implements RouterInterface +{ + /** + * @var Route[] + */ + protected routes = []; + + public function add(string pattern, string actionClass, array methods = []) -> + { + var route; + + let route = new Route(pattern, actionClass, methods), + this->routes[] = route; + + return route; + } + + public function delete(string pattern, string actionClass) -> + { + return this->add(pattern, actionClass, ["DELETE"]); + } + + public function get(string pattern, string actionClass) -> + { + return this->add(pattern, actionClass, ["GET"]); + } + + public function group(string prefix, configure) -> + { + var group; + + let group = new Group(prefix, this); + call_user_func(configure, group); + + return group; + } + + public function match( request) -> | null + { + var uri, method, route, params, methodMismatch; + + let uri = request->getURI(true), + method = request->getMethod(), + methodMismatch = false; + + for route in this->routes { + let params = route->matches(uri); + + if params !== false { + if route->allowsMethod(method) { + return new RouterMatch( + route->getAction(), + params, + route->getMiddleware(), + route->getName() + ); + } + + let methodMismatch = true; + } + } + + if methodMismatch { + throw new MethodNotAllowed("The request method is not allowed for the matched route."); + } + + return null; + } + + public function patch(string pattern, string actionClass) -> + { + return this->add(pattern, actionClass, ["PATCH"]); + } + + public function post(string pattern, string actionClass) -> + { + return this->add(pattern, actionClass, ["POST"]); + } + + public function put(string pattern, string actionClass) -> + { + return this->add(pattern, actionClass, ["PUT"]); + } +} diff --git a/phalcon/ADR/Router/RouterMatch.zep b/phalcon/ADR/Router/RouterMatch.zep new file mode 100644 index 0000000000..eda91e2aad --- /dev/null +++ b/phalcon/ADR/Router/RouterMatch.zep @@ -0,0 +1,70 @@ + +/** + * 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\Router; + +use Phalcon\Contracts\ADR\Router\RouterMatch as RouterMatchInterface; + +/** + * Immutable result of a successful route match. + */ +final class RouterMatch implements RouterMatchInterface +{ + /** + * @var string + */ + protected action; + + /** + * @var array + */ + protected attributes; + + /** + * @var array + */ + protected middleware; + + /** + * @var string|null + */ + protected name; + + public function __construct(string action, array attributes = [], array middleware = [], var name = null) + { + let this->action = action, + this->attributes = attributes, + this->middleware = middleware, + this->name = name; + } + + public function getAction() -> string + { + return this->action; + } + + public function getAttributes() -> array + { + return this->attributes; + } + + public function getMiddleware() -> array + { + return this->middleware; + } + + public function getName() -> string | null + { + return this->name; + } +} diff --git a/phalcon/ADR/Router/Traits/HasMiddleware.zep b/phalcon/ADR/Router/Traits/HasMiddleware.zep new file mode 100644 index 0000000000..46df432d5a --- /dev/null +++ b/phalcon/ADR/Router/Traits/HasMiddleware.zep @@ -0,0 +1,40 @@ + +/** + * 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\Router\Traits; + +/** + * Shared middleware accumulator for Route and Group: stores a list of middleware + * class names, appended to and read back as an array. + */ +trait HasMiddleware +{ + /** + * @var array + */ + protected middleware = []; + + public function getMiddleware() -> array + { + return this->middleware; + } + + public function pushMiddleware(array classes) -> void + { + var item; + + for item in classes { + let this->middleware[] = item; + } + } +} diff --git a/phalcon/Contracts/ADR/Router/Group.zep b/phalcon/Contracts/ADR/Router/Group.zep new file mode 100644 index 0000000000..b4b4217738 --- /dev/null +++ b/phalcon/Contracts/ADR/Router/Group.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\Router; + +/** + * A group of routes sharing a path prefix and middleware. Group middleware is + * flattened onto each route as it is registered. + */ +interface Group +{ + public function withMiddleware(string... classes) -> ; +} diff --git a/phalcon/Contracts/ADR/Router/Route.zep b/phalcon/Contracts/ADR/Router/Route.zep new file mode 100644 index 0000000000..6832766c58 --- /dev/null +++ b/phalcon/Contracts/ADR/Router/Route.zep @@ -0,0 +1,25 @@ + +/** + * 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\Router; + +/** + * A registered route. Fluent, mutating configuration returned from the router's + * registration methods. + */ +interface Route +{ + public function withMiddleware(string... classes) -> ; + + public function withName(string name) -> ; +} diff --git a/phalcon/Contracts/ADR/Router/Router.zep b/phalcon/Contracts/ADR/Router/Router.zep new file mode 100644 index 0000000000..497d6e763c --- /dev/null +++ b/phalcon/Contracts/ADR/Router/Router.zep @@ -0,0 +1,40 @@ + +/** + * 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\Router; + +use Closure; +use Phalcon\Http\RequestInterface; + +/** + * Maps a request to an Action. Routes are registered by pattern and HTTP method + * and matched against the incoming request. + */ +interface Router +{ + public function add(string pattern, string actionClass, array methods = []) -> ; + + public function delete(string pattern, string actionClass) -> ; + + public function get(string pattern, string actionClass) -> ; + + public function group(string prefix, configure) -> ; + + public function match( request) -> | null; + + public function patch(string pattern, string actionClass) -> ; + + public function post(string pattern, string actionClass) -> ; + + public function put(string pattern, string actionClass) -> ; +} diff --git a/phalcon/Contracts/ADR/Router/RouterMatch.zep b/phalcon/Contracts/ADR/Router/RouterMatch.zep new file mode 100644 index 0000000000..1847549eb5 --- /dev/null +++ b/phalcon/Contracts/ADR/Router/RouterMatch.zep @@ -0,0 +1,29 @@ + +/** + * 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\Router; + +/** + * The result of matching a request against the router: the Action class, the + * extracted route attributes, the route's middleware and its optional name. + */ +interface RouterMatch +{ + public function getAction() -> string; + + public function getAttributes() -> array; + + public function getMiddleware() -> array; + + public function getName() -> string | null; +} diff --git a/tests/unit/ADR/Router/Route/AllowsMethodTest.php b/tests/unit/ADR/Router/Route/AllowsMethodTest.php new file mode 100644 index 0000000000..25583d33a9 --- /dev/null +++ b/tests/unit/ADR/Router/Route/AllowsMethodTest.php @@ -0,0 +1,34 @@ + + * + * 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\Router\Route; + +use Phalcon\ADR\Router\Route; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; + +final class AllowsMethodTest extends AbstractUnitTestCase +{ + /** + * Unit Tests Phalcon\ADR\Router\Route :: allowsMethod() + */ + public function testAdrRouterRouteAllowsMethod(): void + { + $route = new Route('/posts', 'ListAction', ['GET']); + $this->assertTrue($route->allowsMethod('GET')); + $this->assertFalse($route->allowsMethod('POST')); + + // empty method list allows any verb + $any = new Route('/posts', 'ListAction'); + $this->assertTrue($any->allowsMethod('DELETE')); + } +} diff --git a/tests/unit/ADR/Router/Route/MatchesTest.php b/tests/unit/ADR/Router/Route/MatchesTest.php new file mode 100644 index 0000000000..0782d043b4 --- /dev/null +++ b/tests/unit/ADR/Router/Route/MatchesTest.php @@ -0,0 +1,42 @@ + + * + * 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\Router\Route; + +use Phalcon\ADR\Router\Route; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; + +final class MatchesTest extends AbstractUnitTestCase +{ + /** + * Unit Tests Phalcon\ADR\Router\Route :: matches() extracts named parameters + */ + public function testAdrRouterRouteMatchesExtractsParameters(): void + { + $route = new Route('/posts/{id}', 'ShowAction', ['GET']); + + $this->assertSame(['id' => '42'], $route->matches('/posts/42')); + $this->assertFalse($route->matches('/users/42')); + } + + /** + * Unit Tests Phalcon\ADR\Router\Route :: matches() honors a regex constraint + */ + public function testAdrRouterRouteMatchesHonorsConstraint(): void + { + $route = new Route('/posts/{id:[0-9]+}', 'ShowAction', ['GET']); + + $this->assertSame(['id' => '42'], $route->matches('/posts/42')); + $this->assertFalse($route->matches('/posts/abc')); + } +} diff --git a/tests/unit/ADR/Router/Router/GroupTest.php b/tests/unit/ADR/Router/Router/GroupTest.php new file mode 100644 index 0000000000..541f0eb619 --- /dev/null +++ b/tests/unit/ADR/Router/Router/GroupTest.php @@ -0,0 +1,49 @@ + + * + * 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\Router\Router; + +use Phalcon\ADR\Router\Group; +use Phalcon\ADR\Router\Router; +use Phalcon\Http\Request; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; + +final class GroupTest extends AbstractUnitTestCase +{ + protected function tearDown(): void + { + unset($_SERVER['REQUEST_URI'], $_SERVER['REQUEST_METHOD']); + + parent::tearDown(); + } + + /** + * Unit Tests Phalcon\ADR\Router\Router :: group() prefixes routes and flattens middleware + */ + public function testAdrRouterRouterGroupPrefixesAndFlattensMiddleware(): void + { + $_SERVER['REQUEST_URI'] = '/admin/users'; + $_SERVER['REQUEST_METHOD'] = 'GET'; + + $router = new Router(); + $router->group('/admin', function (Group $group) { + $group->withMiddleware('AuthMiddleware'); + $group->get('/users', 'ListUsersAction'); + }); + + $match = $router->match(new Request()); + + $this->assertSame('ListUsersAction', $match->getAction()); + $this->assertSame(['AuthMiddleware'], $match->getMiddleware()); + } +} diff --git a/tests/unit/ADR/Router/Router/MatchTest.php b/tests/unit/ADR/Router/Router/MatchTest.php new file mode 100644 index 0000000000..12da21c92c --- /dev/null +++ b/tests/unit/ADR/Router/Router/MatchTest.php @@ -0,0 +1,79 @@ + + * + * 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\Router\Router; + +use Phalcon\ADR\Router\Exceptions\MethodNotAllowed; +use Phalcon\ADR\Router\Router; +use Phalcon\Contracts\ADR\Router\RouterMatch; +use Phalcon\Http\Request; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; + +final class MatchTest extends AbstractUnitTestCase +{ + protected function tearDown(): void + { + unset($_SERVER['REQUEST_URI'], $_SERVER['REQUEST_METHOD']); + + parent::tearDown(); + } + + /** + * Unit Tests Phalcon\ADR\Router\Router :: match() returns a match + */ + public function testAdrRouterRouterMatchReturnsMatch(): void + { + $_SERVER['REQUEST_URI'] = '/posts/42'; + $_SERVER['REQUEST_METHOD'] = 'GET'; + + $router = new Router(); + $router->get('/posts/{id}', 'ShowAction')->withName('posts.show'); + + $match = $router->match(new Request()); + + $this->assertInstanceOf(RouterMatch::class, $match); + $this->assertSame('ShowAction', $match->getAction()); + $this->assertSame(['id' => '42'], $match->getAttributes()); + $this->assertSame('posts.show', $match->getName()); + } + + /** + * Unit Tests Phalcon\ADR\Router\Router :: match() returns null when nothing matches + */ + public function testAdrRouterRouterMatchReturnsNull(): void + { + $_SERVER['REQUEST_URI'] = '/nope'; + $_SERVER['REQUEST_METHOD'] = 'GET'; + + $router = new Router(); + $router->get('/posts/{id}', 'ShowAction'); + + $this->assertNull($router->match(new Request())); + } + + /** + * Unit Tests Phalcon\ADR\Router\Router :: match() throws on a method mismatch + */ + public function testAdrRouterRouterMatchThrowsMethodNotAllowed(): void + { + $_SERVER['REQUEST_URI'] = '/posts/42'; + $_SERVER['REQUEST_METHOD'] = 'DELETE'; + + $router = new Router(); + $router->get('/posts/{id}', 'ShowAction'); + + $this->expectException(MethodNotAllowed::class); + + $router->match(new Request()); + } +} diff --git a/tests/unit/ADR/Router/RouterMatch/GettersTest.php b/tests/unit/ADR/Router/RouterMatch/GettersTest.php new file mode 100644 index 0000000000..65d4251a4c --- /dev/null +++ b/tests/unit/ADR/Router/RouterMatch/GettersTest.php @@ -0,0 +1,33 @@ + + * + * 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\Router\RouterMatch; + +use Phalcon\ADR\Router\RouterMatch; +use Phalcon\Talon\PHPUnit\AbstractUnitTestCase; + +final class GettersTest extends AbstractUnitTestCase +{ + /** + * Unit Tests Phalcon\ADR\Router\RouterMatch :: getAction()/getAttributes()/getMiddleware()/getName() + */ + public function testAdrRouterRouterMatchGetters(): void + { + $match = new RouterMatch('ShowAction', ['id' => '42'], ['AuthMiddleware'], 'posts.show'); + + $this->assertSame('ShowAction', $match->getAction()); + $this->assertSame(['id' => '42'], $match->getAttributes()); + $this->assertSame(['AuthMiddleware'], $match->getMiddleware()); + $this->assertSame('posts.show', $match->getName()); + } +} From a5166496ad0e3e3ad42ce45e829b6dbdf69bea5b Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Fri, 17 Jul 2026 19:58:26 -0500 Subject: [PATCH 6/6] [#17341] - refreshing ext Assisted-by: Claude Code --- ext/config.m4 | 30 +- ext/config.w32 | 11 +- ext/phalcon.c | 56 ++- ext/phalcon.h | 28 +- ext/phalcon/11__closure.zep.c | 2 +- ext/phalcon/13__closure.zep.c | 2 +- ext/phalcon/14__closure.zep.c | 2 +- ext/phalcon/15__closure.zep.c | 2 +- ext/phalcon/acl/adapter/storage.zep.c | 54 +-- ext/phalcon/acl/component.zep.c | 4 +- ext/phalcon/acl/role.zep.c | 4 +- ext/phalcon/adr/dispatcher.zep.c | 312 +++++++++++++ ext/phalcon/adr/dispatcher.zep.h | 36 ++ ext/phalcon/adr/eventfulhandler.zep.c | 123 +++++ ext/phalcon/adr/eventfulhandler.zep.h | 22 + ext/phalcon/adr/events/event.zep.c | 76 ++++ ext/phalcon/adr/events/event.zep.h | 14 + ext/phalcon/adr/input/input.zep.c | 12 +- .../adr/middleware/corsmiddleware.zep.c | 388 ++++++++++++++++ .../adr/middleware/corsmiddleware.zep.h | 36 ++ .../middleware/methodoverridemiddleware.zep.c | 150 ++++++ .../middleware/methodoverridemiddleware.zep.h | 20 + .../adr/middleware/requestidmiddleware.zep.c | 90 ++++ .../adr/middleware/requestidmiddleware.zep.h | 16 + .../adr/middleware/timingmiddleware.zep.c | 87 ++++ .../adr/middleware/timingmiddleware.zep.h | 16 + ext/phalcon/adr/payload/payload.zep.c | 24 +- ext/phalcon/adr/pipeline.zep.c | 169 +++++++ ext/phalcon/adr/pipeline.zep.h | 23 + .../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 +- .../router/exceptions/methodnotallowed.zep.c | 37 ++ .../router/exceptions/methodnotallowed.zep.h | 5 + .../adr/router/exceptions/routenotfound.zep.c | 37 ++ .../adr/router/exceptions/routenotfound.zep.h | 5 + ext/phalcon/adr/router/group.zep.c | 418 +++++++++++++++++ ext/phalcon/adr/router/group.zep.h | 81 ++++ ext/phalcon/adr/router/route.zep.c | 388 ++++++++++++++++ ext/phalcon/adr/router/route.zep.h | 73 +++ ext/phalcon/adr/router/router.zep.c | 430 ++++++++++++++++++ ext/phalcon/adr/router/router.zep.h | 69 +++ ext/phalcon/adr/router/routermatch.zep.c | 154 +++++++ ext/phalcon/adr/router/routermatch.zep.h | 38 ++ .../adr/router/traits/hasmiddleware.zep.c | 109 +++++ .../adr/router/traits/hasmiddleware.zep.h | 21 + ext/phalcon/annotations/adapter/apcu.zep.c | 10 +- ext/phalcon/annotations/adapter/memory.zep.c | 2 +- ext/phalcon/annotations/adapter/stream.zep.c | 10 +- ext/phalcon/annotations/annotation.zep.c | 22 +- ext/phalcon/annotations/collection.zep.c | 26 +- ext/phalcon/annotations/reader.zep.c | 20 +- ext/phalcon/annotations/reflection.zep.c | 14 +- ext/phalcon/assets/collection.zep.c | 60 +-- ext/phalcon/assets/manager.zep.c | 120 ++--- .../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 | 28 +- 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 +- ext/phalcon/autoload/loader.zep.c | 126 ++--- 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 | 50 +- 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 | 136 +++--- ext/phalcon/container/containerfactory.zep.c | 4 +- .../processor/closureprocessor.zep.c | 4 +- .../processor/objectprocessor.zep.c | 4 +- .../processor/parameterprocessor.zep.c | 4 +- .../processor/stringprocessor.zep.c | 6 +- .../definition/servicedefinition.zep.c | 116 ++--- .../container/resolver/lazy/arrayvalues.zep.c | 14 +- .../container/resolver/lazy/call.zep.c | 4 +- .../container/resolver/lazy/callableget.zep.c | 2 +- .../container/resolver/lazy/callablenew.zep.c | 2 +- .../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 | 18 +- ext/phalcon/contracts/adr/dispatcher.zep.c | 37 ++ ext/phalcon/contracts/adr/dispatcher.zep.h | 15 + ext/phalcon/contracts/adr/router/group.zep.c | 37 ++ ext/phalcon/contracts/adr/router/group.zep.h | 13 + ext/phalcon/contracts/adr/router/route.zep.c | 38 ++ ext/phalcon/contracts/adr/router/route.zep.h | 18 + ext/phalcon/contracts/adr/router/router.zep.c | 44 ++ ext/phalcon/contracts/adr/router/router.zep.h | 56 +++ .../contracts/adr/router/routermatch.zep.c | 40 ++ .../contracts/adr/router/routermatch.zep.h | 24 + 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 | 72 +-- ext/phalcon/db/index.zep.c | 28 +- ext/phalcon/db/profiler.zep.c | 36 +- ext/phalcon/db/profiler/item.zep.c | 14 +- ext/phalcon/db/rawvalue.zep.c | 6 +- ext/phalcon/db/reference.zep.c | 24 +- ext/phalcon/db/result/pdoresult.zep.c | 58 +-- ext/phalcon/di/factorydefault/cli.zep.c | 2 +- ext/phalcon/di/service.zep.c | 36 +- ext/phalcon/domain/payload/payload.zep.c | 12 +- ext/phalcon/encryption/crypt.zep.c | 90 ++-- 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 | 12 +- .../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 | 68 +-- .../traits/validatorcompositetrait.zep.c | 2 +- .../validation/validator/callback.zep.c | 12 +- .../validation/validator/confirmation.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 | 16 +- 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 | 10 +- 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/preload.zep.c | 6 +- ext/phalcon/html/helper/title.zep.c | 38 +- ext/phalcon/html/helper/voidtag.zep.c | 4 +- ext/phalcon/html/tagfactory.zep.c | 28 +- ext/phalcon/http/cookie.zep.c | 144 +++--- ext/phalcon/http/request.zep.c | 66 +-- ext/phalcon/http/request/file.zep.c | 24 +- ext/phalcon/http/response.zep.c | 70 +-- ext/phalcon/http/response/cookies.zep.c | 48 +- ext/phalcon/http/response/headers.zep.c | 20 +- ext/phalcon/image/adapter/gd.zep.c | 266 +++++------ ext/phalcon/image/adapter/imagick.zep.c | 250 +++++----- 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 | 326 ++++++------- ext/phalcon/mvc/model/binder.zep.c | 14 +- ext/phalcon/mvc/model/criteria.zep.c | 54 +-- ext/phalcon/mvc/model/manager.zep.c | 160 +++---- 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 | 320 ++++++------- 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/annotations.zep.c | 28 +- ext/phalcon/mvc/router/group.zep.c | 16 +- ext/phalcon/mvc/router/route.zep.c | 38 +- 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 | 24 +- .../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 | 8 +- .../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 | 14 +- .../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 | 36 +- ext/phalcon/session/bag.zep.c | 30 +- ext/phalcon/session/manager.zep.c | 20 +- ext/phalcon/storage/adapterfactory.zep.c | 4 +- ext/phalcon/storage/serializer/base64.zep.c | 14 +- ext/phalcon/storage/serializer/json.zep.c | 16 +- ext/phalcon/storage/serializer/php.zep.c | 16 +- .../collection/readonlycollection.zep.c | 18 +- ext/phalcon/support/debug.zep.c | 50 +- ext/phalcon/support/debug/dump.zep.c | 26 +- .../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 | 2 +- ext/phalcon/support/helper/arr/group.zep.c | 2 +- ext/phalcon/support/helper/arr/isunique.zep.c | 2 +- ext/phalcon/support/helper/str/dynamic.zep.c | 2 +- ext/phalcon/support/helperfactory.zep.c | 4 +- ext/phalcon/time/clock/frozenclock.zep.c | 10 +- ext/phalcon/time/clock/systemclock.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 +- 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 +- 344 files changed, 7710 insertions(+), 3858 deletions(-) create mode 100644 ext/phalcon/adr/dispatcher.zep.c create mode 100644 ext/phalcon/adr/dispatcher.zep.h create mode 100644 ext/phalcon/adr/eventfulhandler.zep.c create mode 100644 ext/phalcon/adr/eventfulhandler.zep.h create mode 100644 ext/phalcon/adr/events/event.zep.c create mode 100644 ext/phalcon/adr/events/event.zep.h create mode 100644 ext/phalcon/adr/middleware/corsmiddleware.zep.c create mode 100644 ext/phalcon/adr/middleware/corsmiddleware.zep.h create mode 100644 ext/phalcon/adr/middleware/methodoverridemiddleware.zep.c create mode 100644 ext/phalcon/adr/middleware/methodoverridemiddleware.zep.h create mode 100644 ext/phalcon/adr/middleware/requestidmiddleware.zep.c create mode 100644 ext/phalcon/adr/middleware/requestidmiddleware.zep.h create mode 100644 ext/phalcon/adr/middleware/timingmiddleware.zep.c create mode 100644 ext/phalcon/adr/middleware/timingmiddleware.zep.h create mode 100644 ext/phalcon/adr/pipeline.zep.c create mode 100644 ext/phalcon/adr/pipeline.zep.h create mode 100644 ext/phalcon/adr/router/exceptions/methodnotallowed.zep.c create mode 100644 ext/phalcon/adr/router/exceptions/methodnotallowed.zep.h create mode 100644 ext/phalcon/adr/router/exceptions/routenotfound.zep.c create mode 100644 ext/phalcon/adr/router/exceptions/routenotfound.zep.h create mode 100644 ext/phalcon/adr/router/group.zep.c create mode 100644 ext/phalcon/adr/router/group.zep.h create mode 100644 ext/phalcon/adr/router/route.zep.c create mode 100644 ext/phalcon/adr/router/route.zep.h create mode 100644 ext/phalcon/adr/router/router.zep.c create mode 100644 ext/phalcon/adr/router/router.zep.h create mode 100644 ext/phalcon/adr/router/routermatch.zep.c create mode 100644 ext/phalcon/adr/router/routermatch.zep.h create mode 100644 ext/phalcon/adr/router/traits/hasmiddleware.zep.c create mode 100644 ext/phalcon/adr/router/traits/hasmiddleware.zep.h create mode 100644 ext/phalcon/contracts/adr/dispatcher.zep.c create mode 100644 ext/phalcon/contracts/adr/dispatcher.zep.h create mode 100644 ext/phalcon/contracts/adr/router/group.zep.c create mode 100644 ext/phalcon/contracts/adr/router/group.zep.h create mode 100644 ext/phalcon/contracts/adr/router/route.zep.c create mode 100644 ext/phalcon/contracts/adr/router/route.zep.h create mode 100644 ext/phalcon/contracts/adr/router/router.zep.c create mode 100644 ext/phalcon/contracts/adr/router/router.zep.h create mode 100644 ext/phalcon/contracts/adr/router/routermatch.zep.c create mode 100644 ext/phalcon/contracts/adr/router/routermatch.zep.h diff --git a/ext/config.m4 b/ext/config.m4 index bfad6fbda6..0c614fd571 100644 --- a/ext/config.m4 +++ b/ext/config.m4 @@ -102,9 +102,11 @@ 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 + phalcon/contracts/adr/middleware.zep.c phalcon/contracts/acl/adapter/adapter.zep.c phalcon/contracts/assets/filter.zep.c phalcon/contracts/auth/access/access.zep.c @@ -131,6 +133,7 @@ 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 @@ -141,6 +144,7 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/auth/adapter/config/abstractadapterconfig.zep.c phalcon/cli/console/exception.zep.c phalcon/cli/router/exception.zep.c + phalcon/contracts/adr/handler.zep.c phalcon/contracts/auth/guard/guard.zep.c phalcon/contracts/auth/guard/guardconfig.zep.c phalcon/contracts/cache/cache.zep.c @@ -174,7 +178,6 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/storage/adapter/redis.zep.c phalcon/support/abstractlocator.zep.c phalcon/translate/adapter/abstractadapter.zep.c - phalcon/adr/exceptions/adrthrowable.zep.c phalcon/adr/responder/abstractformattedresponder.zep.c phalcon/acl/abstractelement.zep.c phalcon/acl/adapter/abstractadapter.zep.c @@ -243,7 +246,6 @@ 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/exceptions/exception.zep.c phalcon/acl/adapter/memory.zep.c phalcon/acl/componentinterface.zep.c phalcon/acl/roleinterface.zep.c @@ -253,8 +255,12 @@ 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/handler.zep.c + phalcon/contracts/adr/dispatcher.zep.c phalcon/contracts/adr/payload/payload.zep.c + phalcon/contracts/adr/router/group.zep.c + phalcon/contracts/adr/router/route.zep.c + phalcon/contracts/adr/router/router.zep.c + phalcon/contracts/adr/router/routermatch.zep.c phalcon/contracts/acl/adapter/persistable.zep.c phalcon/contracts/acl/componentaware.zep.c phalcon/contracts/acl/roleaware.zep.c @@ -348,11 +354,19 @@ 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/dispatcher.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/middleware/corsmiddleware.zep.c + phalcon/adr/middleware/methodoverridemiddleware.zep.c + phalcon/adr/middleware/requestidmiddleware.zep.c + phalcon/adr/middleware/timingmiddleware.zep.c phalcon/adr/payload/payload.zep.c phalcon/adr/payload/payloadfactory.zep.c phalcon/adr/payload/status.zep.c + phalcon/adr/pipeline.zep.c phalcon/adr/responder/formatresponder.zep.c phalcon/adr/responder/formatter/jsonformatter.zep.c phalcon/adr/responder/formatter/textformatter.zep.c @@ -362,6 +376,13 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/adr/responder/statusmapper.zep.c phalcon/adr/responder/statusresponder.zep.c phalcon/adr/responder/textresponder.zep.c + phalcon/adr/router/exceptions/methodnotallowed.zep.c + phalcon/adr/router/exceptions/routenotfound.zep.c + phalcon/adr/router/group.zep.c + phalcon/adr/router/route.zep.c + phalcon/adr/router/router.zep.c + phalcon/adr/router/routermatch.zep.c + phalcon/adr/router/traits/hasmiddleware.zep.c phalcon/acl/adapter/storage.zep.c phalcon/acl/component.zep.c phalcon/acl/componentawareinterface.zep.c @@ -536,7 +557,6 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/container/resolver/resolver.zep.c phalcon/contracts/adr/action.zep.c phalcon/contracts/adr/domain.zep.c - phalcon/contracts/adr/middleware.zep.c phalcon/contracts/auth/authremember.zep.c phalcon/contracts/auth/remembertoken.zep.c phalcon/contracts/container/ioc/ioctypealiases.zep.c @@ -1510,7 +1530,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/exceptions phalcon/adr/input phalcon/adr/payload phalcon/adr/responder phalcon/adr/responder/formatter 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/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/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 PHP_ADD_BUILD_DIR([$ext_builddir/$dir]) done PHP_SUBST(PHALCON_SHARED_LIBADD) diff --git a/ext/config.w32 b/ext/config.w32 index 877bf28d80..bc49032c27 100644 --- a/ext/config.w32 +++ b/ext/config.w32 @@ -79,9 +79,11 @@ 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/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"); @@ -118,7 +120,6 @@ if (PHP_PHALCON != "no") { ADD_SOURCES(configure_module_dirname + "/phalcon/mvc/url", "exception.zep.c urlinterface.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/mvc/view/engine", "engineinterface.zep.c abstractengine.zep.c php.zep.c volt.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/mvc", "viewbaseinterface.zep.c entityinterface.zep.c routerinterface.zep.c controllerinterface.zep.c dispatcherinterface.zep.c modelinterface.zep.c router.zep.c viewinterface.zep.c application.zep.c controller.zep.c dispatcher.zep.c micro.zep.c model.zep.c moduledefinitioninterface.zep.c url.zep.c view.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/auth/guard", "abstractguard.zep.c guardlocator.zep.c session.zep.c token.zep.c userremember.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/auth/guard/config", "abstractguardconfig.zep.c sessionguardconfig.zep.c tokenguardconfig.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/autoload", "exception.zep.c loader.zep.c", "phalcon"); @@ -143,8 +144,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/contracts/adr", "handler.zep.c action.zep.c domain.zep.c middleware.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"); ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/http", "attributerequestinterface.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/contracts/messages", "messages.zep.c", "phalcon"); @@ -160,9 +161,15 @@ 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/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"); ADD_SOURCES(configure_module_dirname + "/phalcon/adr/payload", "payload.zep.c payloadfactory.zep.c status.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/adr/responder/formatter", "jsonformatter.zep.c textformatter.zep.c", "phalcon"); + ADD_SOURCES(configure_module_dirname + "/phalcon/adr/router/exceptions", "methodnotallowed.zep.c routenotfound.zep.c", "phalcon"); + ADD_SOURCES(configure_module_dirname + "/phalcon/adr/router", "group.zep.c route.zep.c router.zep.c routermatch.zep.c", "phalcon"); + ADD_SOURCES(configure_module_dirname + "/phalcon/adr/router/traits", "hasmiddleware.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/acl/exceptions", "accessrulenotfound.zep.c circularinheritanceerror.zep.c elementnotfound.zep.c forbiddenwildcard.zep.c invalidaccesslist.zep.c invalidcomponentimplementation.zep.c invalidroleimplementation.zep.c invalidroletype.zep.c invalidsnapshot.zep.c missingfunctionparameters.zep.c parametertypemismatch.zep.c rolenotfoundexception.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/acl/traits", "itemtrait.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/annotations/exceptions", "annotationnotfound.zep.c annotationsdirectorynotwritable.zep.c cannotreadannotationdata.zep.c unknownannotationexpression.zep.c", "phalcon"); diff --git a/ext/phalcon.c b/ext/phalcon.c index 307bc2003a..bba91fc8b7 100644 --- a/ext/phalcon.c +++ b/ext/phalcon.c @@ -67,9 +67,11 @@ 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; +zend_class_entry *phalcon_contracts_adr_middleware_ce; zend_class_entry *phalcon_contracts_assets_filter_ce; zend_class_entry *phalcon_contracts_auth_access_access_ce; zend_class_entry *phalcon_contracts_auth_adapter_adapterconfig_ce; @@ -86,6 +88,7 @@ zend_class_entry *phalcon_logger_adapter_adapterinterface_ce; zend_class_entry *phalcon_translate_adapter_adapterinterface_ce; zend_class_entry *phalcon_acl_adapter_adapterinterface_ce; zend_class_entry *phalcon_assets_filterinterface_ce; +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; @@ -107,7 +110,6 @@ zend_class_entry *phalcon_mvc_model_behaviorinterface_ce; zend_class_entry *phalcon_mvc_model_resultsetinterface_ce; zend_class_entry *phalcon_mvc_view_engine_engineinterface_ce; zend_class_entry *phalcon_mvc_viewbaseinterface_ce; -zend_class_entry *phalcon_adr_exceptions_adrthrowable_ce; zend_class_entry *phalcon_cache_cacheinterface_ce; zend_class_entry *phalcon_cli_taskinterface_ce; zend_class_entry *phalcon_contracts_acl_component_ce; @@ -152,8 +154,12 @@ 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_handler_ce; +zend_class_entry *phalcon_contracts_adr_dispatcher_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; +zend_class_entry *phalcon_contracts_adr_router_router_ce; +zend_class_entry *phalcon_contracts_adr_router_routermatch_ce; zend_class_entry *phalcon_contracts_auth_adapter_rememberadapter_ce; zend_class_entry *phalcon_contracts_auth_authuser_ce; zend_class_entry *phalcon_contracts_auth_guard_basicauth_ce; @@ -222,12 +228,12 @@ zend_class_entry *phalcon_session_managerinterface_ce; zend_class_entry *phalcon_acl_componentawareinterface_ce; zend_class_entry *phalcon_acl_roleawareinterface_ce; zend_class_entry *phalcon_acl_traits_itemtrait_ce; +zend_class_entry *phalcon_adr_router_traits_hasmiddleware_ce; zend_class_entry *phalcon_assets_traits_attributestrait_ce; zend_class_entry *phalcon_assets_traits_sourcetargettrait_ce; zend_class_entry *phalcon_auth_adapter_config_traits_modelconfigtrait_ce; zend_class_entry *phalcon_contracts_adr_action_ce; zend_class_entry *phalcon_contracts_adr_domain_ce; -zend_class_entry *phalcon_contracts_adr_middleware_ce; zend_class_entry *phalcon_contracts_auth_authremember_ce; zend_class_entry *phalcon_contracts_auth_remembertoken_ce; zend_class_entry *phalcon_contracts_container_ioc_ioctypealiases_ce; @@ -338,6 +344,7 @@ 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; @@ -392,7 +399,6 @@ 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_exceptions_exception_ce; zend_class_entry *phalcon_cache_abstractcache_ce; zend_class_entry *phalcon_cli_task_ce; zend_class_entry *phalcon_di_factorydefault_ce; @@ -530,11 +536,19 @@ 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_dispatcher_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_middleware_corsmiddleware_ce; +zend_class_entry *phalcon_adr_middleware_methodoverridemiddleware_ce; +zend_class_entry *phalcon_adr_middleware_requestidmiddleware_ce; +zend_class_entry *phalcon_adr_middleware_timingmiddleware_ce; zend_class_entry *phalcon_adr_payload_payload_ce; zend_class_entry *phalcon_adr_payload_payloadfactory_ce; zend_class_entry *phalcon_adr_payload_status_ce; +zend_class_entry *phalcon_adr_pipeline_ce; zend_class_entry *phalcon_adr_responder_formatresponder_ce; zend_class_entry *phalcon_adr_responder_formatter_jsonformatter_ce; zend_class_entry *phalcon_adr_responder_formatter_textformatter_ce; @@ -544,6 +558,12 @@ zend_class_entry *phalcon_adr_responder_redirectresponder_ce; zend_class_entry *phalcon_adr_responder_statusmapper_ce; zend_class_entry *phalcon_adr_responder_statusresponder_ce; zend_class_entry *phalcon_adr_responder_textresponder_ce; +zend_class_entry *phalcon_adr_router_exceptions_methodnotallowed_ce; +zend_class_entry *phalcon_adr_router_exceptions_routenotfound_ce; +zend_class_entry *phalcon_adr_router_group_ce; +zend_class_entry *phalcon_adr_router_route_ce; +zend_class_entry *phalcon_adr_router_router_ce; +zend_class_entry *phalcon_adr_router_routermatch_ce; zend_class_entry *phalcon_annotations_adapter_apcu_ce; zend_class_entry *phalcon_annotations_adapter_memory_ce; zend_class_entry *phalcon_annotations_adapter_stream_ce; @@ -1596,8 +1616,10 @@ 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); ZEPHIR_INIT(Phalcon_Contracts_Acl_Adapter_Adapter); ZEPHIR_INIT(Phalcon_Contracts_Assets_Filter); ZEPHIR_INIT(Phalcon_Contracts_Auth_Access_Access); @@ -1615,6 +1637,7 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(Phalcon_Translate_Adapter_AdapterInterface); ZEPHIR_INIT(Phalcon_Acl_Adapter_AdapterInterface); ZEPHIR_INIT(Phalcon_Assets_FilterInterface); + ZEPHIR_INIT(Phalcon_Contracts_ADR_Handler); ZEPHIR_INIT(Phalcon_Contracts_Auth_Guard_Guard); ZEPHIR_INIT(Phalcon_Contracts_Auth_Guard_GuardConfig); ZEPHIR_INIT(Phalcon_Contracts_Cache_Cache); @@ -1636,7 +1659,6 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(Phalcon_Mvc_Model_ResultsetInterface); ZEPHIR_INIT(Phalcon_Mvc_ViewBaseInterface); ZEPHIR_INIT(Phalcon_Mvc_View_Engine_EngineInterface); - ZEPHIR_INIT(Phalcon_ADR_Exceptions_ADRThrowable); ZEPHIR_INIT(Phalcon_Cache_CacheInterface); ZEPHIR_INIT(Phalcon_Cli_TaskInterface); ZEPHIR_INIT(Phalcon_Contracts_ADR_Responder_Formatter_Formatter); @@ -1678,8 +1700,12 @@ 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_Handler); + ZEPHIR_INIT(Phalcon_Contracts_ADR_Dispatcher); ZEPHIR_INIT(Phalcon_Contracts_ADR_Payload_Payload); + ZEPHIR_INIT(Phalcon_Contracts_ADR_Router_Group); + ZEPHIR_INIT(Phalcon_Contracts_ADR_Router_Route); + ZEPHIR_INIT(Phalcon_Contracts_ADR_Router_Router); + ZEPHIR_INIT(Phalcon_Contracts_ADR_Router_RouterMatch); ZEPHIR_INIT(Phalcon_Contracts_Acl_Adapter_Persistable); ZEPHIR_INIT(Phalcon_Contracts_Acl_ComponentAware); ZEPHIR_INIT(Phalcon_Contracts_Acl_RoleAware); @@ -1748,6 +1774,7 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(Phalcon_Paginator_RepositoryInterface); ZEPHIR_INIT(Phalcon_Session_BagInterface); ZEPHIR_INIT(Phalcon_Session_ManagerInterface); + ZEPHIR_INIT(Phalcon_ADR_Router_Traits_HasMiddleware); ZEPHIR_INIT(Phalcon_Acl_ComponentAwareInterface); ZEPHIR_INIT(Phalcon_Acl_RoleAwareInterface); ZEPHIR_INIT(Phalcon_Acl_Traits_ItemTrait); @@ -1756,7 +1783,6 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(Phalcon_Auth_Adapter_Config_Traits_ModelConfigTrait); ZEPHIR_INIT(Phalcon_Contracts_ADR_Action); ZEPHIR_INIT(Phalcon_Contracts_ADR_Domain); - ZEPHIR_INIT(Phalcon_Contracts_ADR_Middleware); ZEPHIR_INIT(Phalcon_Contracts_Auth_AuthRemember); ZEPHIR_INIT(Phalcon_Contracts_Auth_RememberToken); ZEPHIR_INIT(Phalcon_Contracts_Container_Ioc_IocTypeAliases); @@ -1867,6 +1893,7 @@ 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); @@ -1920,7 +1947,6 @@ 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_Exceptions_Exception); ZEPHIR_INIT(Phalcon_Acl_Adapter_Memory); ZEPHIR_INIT(Phalcon_Cache_AbstractCache); ZEPHIR_INIT(Phalcon_Cli_Task); @@ -1949,11 +1975,19 @@ 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_Dispatcher); + 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_Middleware_CorsMiddleware); + ZEPHIR_INIT(Phalcon_ADR_Middleware_MethodOverrideMiddleware); + ZEPHIR_INIT(Phalcon_ADR_Middleware_RequestIdMiddleware); + ZEPHIR_INIT(Phalcon_ADR_Middleware_TimingMiddleware); ZEPHIR_INIT(Phalcon_ADR_Payload_Payload); ZEPHIR_INIT(Phalcon_ADR_Payload_PayloadFactory); ZEPHIR_INIT(Phalcon_ADR_Payload_Status); + ZEPHIR_INIT(Phalcon_ADR_Pipeline); ZEPHIR_INIT(Phalcon_ADR_Responder_FormatResponder); ZEPHIR_INIT(Phalcon_ADR_Responder_Formatter_JsonFormatter); ZEPHIR_INIT(Phalcon_ADR_Responder_Formatter_TextFormatter); @@ -1963,6 +1997,12 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(Phalcon_ADR_Responder_StatusMapper); ZEPHIR_INIT(Phalcon_ADR_Responder_StatusResponder); ZEPHIR_INIT(Phalcon_ADR_Responder_TextResponder); + ZEPHIR_INIT(Phalcon_ADR_Router_Exceptions_MethodNotAllowed); + ZEPHIR_INIT(Phalcon_ADR_Router_Exceptions_RouteNotFound); + ZEPHIR_INIT(Phalcon_ADR_Router_Group); + ZEPHIR_INIT(Phalcon_ADR_Router_Route); + ZEPHIR_INIT(Phalcon_ADR_Router_Router); + ZEPHIR_INIT(Phalcon_ADR_Router_RouterMatch); ZEPHIR_INIT(Phalcon_Acl_Adapter_Storage); ZEPHIR_INIT(Phalcon_Acl_Component); ZEPHIR_INIT(Phalcon_Acl_Enum); diff --git a/ext/phalcon.h b/ext/phalcon.h index 110b2d679f..ecefe8f3fa 100644 --- a/ext/phalcon.h +++ b/ext/phalcon.h @@ -97,9 +97,11 @@ #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" +#include "phalcon/contracts/adr/middleware.zep.h" #include "phalcon/contracts/acl/adapter/adapter.zep.h" #include "phalcon/contracts/assets/filter.zep.h" #include "phalcon/contracts/auth/access/access.zep.h" @@ -126,6 +128,7 @@ #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" @@ -136,6 +139,7 @@ #include "phalcon/auth/adapter/config/abstractadapterconfig.zep.h" #include "phalcon/cli/console/exception.zep.h" #include "phalcon/cli/router/exception.zep.h" +#include "phalcon/contracts/adr/handler.zep.h" #include "phalcon/contracts/auth/guard/guard.zep.h" #include "phalcon/contracts/auth/guard/guardconfig.zep.h" #include "phalcon/contracts/cache/cache.zep.h" @@ -169,7 +173,6 @@ #include "phalcon/storage/adapter/redis.zep.h" #include "phalcon/support/abstractlocator.zep.h" #include "phalcon/translate/adapter/abstractadapter.zep.h" -#include "phalcon/adr/exceptions/adrthrowable.zep.h" #include "phalcon/adr/responder/abstractformattedresponder.zep.h" #include "phalcon/acl/abstractelement.zep.h" #include "phalcon/acl/adapter/abstractadapter.zep.h" @@ -238,7 +241,6 @@ #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/exceptions/exception.zep.h" #include "phalcon/acl/adapter/memory.zep.h" #include "phalcon/acl/componentinterface.zep.h" #include "phalcon/acl/roleinterface.zep.h" @@ -248,8 +250,12 @@ #include "phalcon/cli/router/routeinterface.zep.h" #include "phalcon/cli/routerinterface.zep.h" #include "phalcon/cli/task.zep.h" -#include "phalcon/contracts/adr/handler.zep.h" +#include "phalcon/contracts/adr/dispatcher.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" +#include "phalcon/contracts/adr/router/router.zep.h" +#include "phalcon/contracts/adr/router/routermatch.zep.h" #include "phalcon/contracts/acl/adapter/persistable.zep.h" #include "phalcon/contracts/acl/componentaware.zep.h" #include "phalcon/contracts/acl/roleaware.zep.h" @@ -343,11 +349,19 @@ #include "phalcon/support/collection/exception.zep.h" #include "phalcon/support/debug/exception.zep.h" #include "phalcon/time/clock/exception.zep.h" +#include "phalcon/adr/dispatcher.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/middleware/corsmiddleware.zep.h" +#include "phalcon/adr/middleware/methodoverridemiddleware.zep.h" +#include "phalcon/adr/middleware/requestidmiddleware.zep.h" +#include "phalcon/adr/middleware/timingmiddleware.zep.h" #include "phalcon/adr/payload/payload.zep.h" #include "phalcon/adr/payload/payloadfactory.zep.h" #include "phalcon/adr/payload/status.zep.h" +#include "phalcon/adr/pipeline.zep.h" #include "phalcon/adr/responder/formatresponder.zep.h" #include "phalcon/adr/responder/formatter/jsonformatter.zep.h" #include "phalcon/adr/responder/formatter/textformatter.zep.h" @@ -357,6 +371,13 @@ #include "phalcon/adr/responder/statusmapper.zep.h" #include "phalcon/adr/responder/statusresponder.zep.h" #include "phalcon/adr/responder/textresponder.zep.h" +#include "phalcon/adr/router/exceptions/methodnotallowed.zep.h" +#include "phalcon/adr/router/exceptions/routenotfound.zep.h" +#include "phalcon/adr/router/group.zep.h" +#include "phalcon/adr/router/route.zep.h" +#include "phalcon/adr/router/router.zep.h" +#include "phalcon/adr/router/routermatch.zep.h" +#include "phalcon/adr/router/traits/hasmiddleware.zep.h" #include "phalcon/acl/adapter/storage.zep.h" #include "phalcon/acl/component.zep.h" #include "phalcon/acl/componentawareinterface.zep.h" @@ -531,7 +552,6 @@ #include "phalcon/container/resolver/resolver.zep.h" #include "phalcon/contracts/adr/action.zep.h" #include "phalcon/contracts/adr/domain.zep.h" -#include "phalcon/contracts/adr/middleware.zep.h" #include "phalcon/contracts/auth/authremember.zep.h" #include "phalcon/contracts/auth/remembertoken.zep.h" #include "phalcon/contracts/container/ioc/ioctypealiases.zep.h" diff --git a/ext/phalcon/11__closure.zep.c b/ext/phalcon/11__closure.zep.c index db3afc6676..9e2ac5be8f 100644 --- a/ext/phalcon/11__closure.zep.c +++ b/ext/phalcon/11__closure.zep.c @@ -38,7 +38,7 @@ PHP_METHOD(phalcon_11__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, 371, container); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 383, container); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/13__closure.zep.c b/ext/phalcon/13__closure.zep.c index b5670799d7..65f34cb72f 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, 371, container); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 383, container); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/14__closure.zep.c b/ext/phalcon/14__closure.zep.c index 6d4908b35a..b10e724d76 100644 --- a/ext/phalcon/14__closure.zep.c +++ b/ext/phalcon/14__closure.zep.c @@ -43,7 +43,7 @@ PHP_METHOD(phalcon_14__closure, __invoke) 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_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1334, PH_NOISY_CC | PH_READONLY); + 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); diff --git a/ext/phalcon/15__closure.zep.c b/ext/phalcon/15__closure.zep.c index ae167644e3..ee325d73d8 100644 --- a/ext/phalcon/15__closure.zep.c +++ b/ext/phalcon/15__closure.zep.c @@ -43,7 +43,7 @@ PHP_METHOD(phalcon_15__closure, __invoke) 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, 1335, PH_NOISY_CC | PH_READONLY); + 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); diff --git a/ext/phalcon/acl/adapter/storage.zep.c b/ext/phalcon/acl/adapter/storage.zep.c index 28ef5c1f92..57ebbb2123 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, 334, storage); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 335, &key_zv); + 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_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, 334, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 335, PH_NOISY_CC | PH_READONLY); + 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_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, 298, &data); + ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "normalizetoarray", NULL, 312, &data); zephir_check_call_status(); ZEPHIR_CPY_WRT(&data, &_2$$3); } @@ -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, 336, &_35); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 363, &_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, 337, &_36); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 338, &rebuiltComponents); + 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_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, 339, &_37); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 340, &rebuiltRoles); + 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_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, 341, &_38); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 368, &_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, 342, &_39); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 369, &_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, 343, &_40); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 370, &_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, 336, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 363, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&access, &_0); ZEPHIR_INIT_VAR(&_1); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 344, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 371, 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, 338, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 365, 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, 340, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12, this_ptr, _zephir_prop_3, 367, 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, 334, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_21, this_ptr, _zephir_prop_5, 335, PH_NOISY_CC | PH_READONLY); + 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_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, 337, PH_NOISY_CC); + zephir_read_property_cached(&_23, this_ptr, _zephir_prop_6, 364, 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, 339, PH_NOISY_CC); + zephir_read_property_cached(&_23, this_ptr, _zephir_prop_7, 366, 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, 341, PH_NOISY_CC); + zephir_read_property_cached(&_23, this_ptr, _zephir_prop_8, 368, 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, 342, PH_NOISY_CC); + zephir_read_property_cached(&_23, this_ptr, _zephir_prop_9, 369, 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, 343, PH_NOISY_CC); + zephir_read_property_cached(&_23, this_ptr, _zephir_prop_10, 370, 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, 299, value); + ZEPHIR_CALL_FUNCTION(&_0$$3, "get_object_vars", NULL, 313, 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, 298, &item); + ZEPHIR_CALL_METHOD(&_4$$5, this_ptr, "normalizetoarray", &_5, 312, &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, 298, &item); + ZEPHIR_CALL_METHOD(&_8$$6, this_ptr, "normalizetoarray", &_5, 312, &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 98431e8a5e..9b85a052a2 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, 345, &name_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 346, &description_zv); + 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_MM_RESTORE(); } diff --git a/ext/phalcon/acl/role.zep.c b/ext/phalcon/acl/role.zep.c index be08e45212..615fb27a4f 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, 347, &name_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 348, &description_zv); + 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_MM_RESTORE(); } diff --git a/ext/phalcon/adr/dispatcher.zep.c b/ext/phalcon/adr/dispatcher.zep.c new file mode 100644 index 0000000000..66308e15b8 --- /dev/null +++ b/ext/phalcon/adr/dispatcher.zep.c @@ -0,0 +1,312 @@ + +#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/operators.h" +#include "kernel/fcall.h" +#include "kernel/exception.h" +#include "kernel/concat.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/ + */ +/** + * Resolves the Action (and middleware) through the container, wraps it in the + * pipeline and runs it, firing the `pipeline:*` events. Global middleware is + * resolved once and cached; only route middleware resolves per request. + * + * The container resolution is the one deliberate Service Locator: it uses the + * resolve-only `IocContainer` contract, so a container swap is a two-method + * adapter. Everything else is constructor-injected. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Dispatcher) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\ADR, Dispatcher, phalcon, adr_dispatcher, phalcon_adr_dispatcher_method_entry, ZEND_ACC_FINAL_CLASS); + + /** + * @var IocContainer + */ + zend_declare_property_null(phalcon_adr_dispatcher_ce, SL("container"), ZEND_ACC_PROTECTED); + /** + * @var Manager + */ + zend_declare_property_null(phalcon_adr_dispatcher_ce, SL("events"), ZEND_ACC_PROTECTED); + /** + * @var array + */ + zend_declare_property_null(phalcon_adr_dispatcher_ce, SL("globalMiddleware"), ZEND_ACC_PROTECTED); + /** + * @var array|null + */ + zend_declare_property_null(phalcon_adr_dispatcher_ce, SL("resolvedGlobal"), ZEND_ACC_PROTECTED); + zend_class_implements(phalcon_adr_dispatcher_ce, 1, phalcon_contracts_adr_dispatcher_ce); + return SUCCESS; +} + +PHP_METHOD(Phalcon_ADR_Dispatcher, __construct) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zval globalMiddleware; + zval *container, container_sub, *events, events_sub, *globalMiddleware_param = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&container_sub); + ZVAL_UNDEF(&events_sub); + ZVAL_UNDEF(&globalMiddleware); + static zend_string *_zephir_prop_0 = NULL; + static zend_string *_zephir_prop_1 = NULL; + static zend_string *_zephir_prop_2 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("container", 9, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("events", 6, 1); + } + if (UNEXPECTED(!_zephir_prop_2)) { + _zephir_prop_2 = zend_string_init("globalMiddleware", 16, 1); + } + + ZEND_PARSE_PARAMETERS_START(2, 3) + Z_PARAM_OBJECT_OF_CLASS(container, phalcon_contracts_container_ioc_ioccontainer_ce) + Z_PARAM_OBJECT_OF_CLASS(events, phalcon_contracts_events_manager_ce) + Z_PARAM_OPTIONAL + ZEPHIR_Z_PARAM_ARRAY(globalMiddleware, globalMiddleware_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, 1, &container, &events, &globalMiddleware_param); + if (!globalMiddleware_param) { + ZEPHIR_INIT_VAR(&globalMiddleware); + array_init(&globalMiddleware); + } 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_MM_RESTORE(); +} + +PHP_METHOD(Phalcon_ADR_Dispatcher, dispatch) +{ + zval _2$$3; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval routeMiddleware; + zval actionClass_zv, *request, request_sub, *routeMiddleware_param = NULL, action, middleware, terminal, pipeline, response, _0, _3, _4, _5, _6, _7, _8, _1$$3; + zend_string *actionClass = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&actionClass_zv); + ZVAL_UNDEF(&request_sub); + ZVAL_UNDEF(&action); + ZVAL_UNDEF(&middleware); + ZVAL_UNDEF(&terminal); + ZVAL_UNDEF(&pipeline); + ZVAL_UNDEF(&response); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_3); + ZVAL_UNDEF(&_4); + ZVAL_UNDEF(&_5); + ZVAL_UNDEF(&_6); + ZVAL_UNDEF(&_7); + ZVAL_UNDEF(&_8); + ZVAL_UNDEF(&_1$$3); + ZVAL_UNDEF(&routeMiddleware); + ZVAL_UNDEF(&_2$$3); + 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("container", 9, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("events", 6, 1); + } + + ZEND_PARSE_PARAMETERS_START(2, 3) + Z_PARAM_STR(actionClass) + Z_PARAM_OBJECT_OF_CLASS(request, phalcon_contracts_http_attributerequestinterface_ce) + Z_PARAM_OPTIONAL + ZEPHIR_Z_PARAM_ARRAY(routeMiddleware, routeMiddleware_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__); + request = ZEND_CALL_ARG(execute_data, 2); + if (ZEND_NUM_ARGS() > 2) { + routeMiddleware_param = ZEND_CALL_ARG(execute_data, 3); + } + zephir_memory_observe(&actionClass_zv); + ZVAL_STR_COPY(&actionClass_zv, actionClass); + if (!routeMiddleware_param) { + ZEPHIR_INIT_VAR(&routeMiddleware); + array_init(&routeMiddleware); + } else { + zephir_get_arrval(&routeMiddleware, routeMiddleware_param); + } + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 328, 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))) { + ZEPHIR_INIT_VAR(&_1$$3); + object_init_ex(&_1$$3, phalcon_adr_exceptions_notanaction_ce); + ZEPHIR_INIT_VAR(&_2$$3); + ZEPHIR_CONCAT_SVS(&_2$$3, "Class '", &actionClass_zv, "' is not an ADR Action."); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 8, &_2$$3); + zephir_check_call_status(); + zephir_throw_exception_debug(&_1$$3, "phalcon/ADR/Dispatcher.zep", 69); + ZEPHIR_MM_RESTORE(); + return; + } + ZEPHIR_CALL_METHOD(&_3, this_ptr, "resolveglobal", NULL, 294); + zephir_check_call_status(); + ZEPHIR_CALL_METHOD(&_4, this_ptr, "resolveall", NULL, 295, &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_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_check_call_status(); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 329, 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_check_call_status(); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 329, 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); + zephir_check_call_status(); + RETURN_CCTOR(&response); +} + +PHP_METHOD(Phalcon_ADR_Dispatcher, resolveAll) +{ + zend_bool _4; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *classes_param = NULL, result, className, *_0, _3, _1$$3, _2$$3, _5$$4, _6$$4; + zval classes; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&classes); + ZVAL_UNDEF(&result); + ZVAL_UNDEF(&className); + ZVAL_UNDEF(&_3); + ZVAL_UNDEF(&_1$$3); + ZVAL_UNDEF(&_2$$3); + ZVAL_UNDEF(&_5$$4); + ZVAL_UNDEF(&_6$$4); + static zend_string *_zephir_prop_0 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("container", 9, 1); + } + + ZEND_PARSE_PARAMETERS_START(1, 1) + ZEPHIR_Z_PARAM_ARRAY(classes, classes_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, 1, 0, &classes_param); + zephir_get_arrval(&classes, classes_param); + ZEPHIR_INIT_VAR(&result); + array_init(&result); + zephir_is_iterable(&classes, 0, "phalcon/ADR/Dispatcher.zep", 94); + if (Z_TYPE_P(&classes) == IS_ARRAY) { + ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&classes), _0) + { + 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_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); + } ZEND_HASH_FOREACH_END(); + } else { + ZEPHIR_CALL_METHOD(NULL, &classes, "rewind", NULL, 0); + zephir_check_call_status(); + _4 = 1; + while (1) { + if (_4) { + _4 = 0; + } else { + ZEPHIR_CALL_METHOD(NULL, &classes, "next", NULL, 0); + zephir_check_call_status(); + } + ZEPHIR_CALL_METHOD(&_3, &classes, "valid", NULL, 0); + zephir_check_call_status(); + if (!zend_is_true(&_3)) { + break; + } + 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_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); + } + } + ZEPHIR_INIT_NVAR(&className); + RETURN_CCTOR(&result); +} + +PHP_METHOD(Phalcon_ADR_Dispatcher, resolveGlobal) +{ + zval _0, _1$$3, _2$$3; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1$$3); + ZVAL_UNDEF(&_2$$3); + 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("resolvedGlobal", 14, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("globalMiddleware", 16, 1); + } + 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); + 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_check_call_status(); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 331, &_1$$3); + } + RETURN_MM_MEMBER_TYPED(getThis(), "resolvedGlobal", IS_ARRAY); +} + diff --git a/ext/phalcon/adr/dispatcher.zep.h b/ext/phalcon/adr/dispatcher.zep.h new file mode 100644 index 0000000000..e24f695138 --- /dev/null +++ b/ext/phalcon/adr/dispatcher.zep.h @@ -0,0 +1,36 @@ + +extern zend_class_entry *phalcon_adr_dispatcher_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Dispatcher); + +PHP_METHOD(Phalcon_ADR_Dispatcher, __construct); +PHP_METHOD(Phalcon_ADR_Dispatcher, dispatch); +PHP_METHOD(Phalcon_ADR_Dispatcher, resolveAll); +PHP_METHOD(Phalcon_ADR_Dispatcher, resolveGlobal); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_adr_dispatcher___construct, 0, 0, 2) + ZEND_ARG_OBJ_INFO(0, container, Phalcon\\Contracts\\Container\\Ioc\\IocContainer, 0) + ZEND_ARG_OBJ_INFO(0, events, Phalcon\\Contracts\\Events\\Manager, 0) +ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, globalMiddleware, IS_ARRAY, 0, "[]") +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_dispatcher_dispatch, 0, 2, Phalcon\\Http\\ResponseInterface, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) + ZEND_ARG_OBJ_INFO(0, request, Phalcon\\Contracts\\Http\\AttributeRequestInterface, 0) +ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, routeMiddleware, IS_ARRAY, 0, "[]") +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_dispatcher_resolveall, 0, 1, IS_ARRAY, 0) + ZEND_ARG_ARRAY_INFO(0, classes, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_dispatcher_resolveglobal, 0, 0, IS_ARRAY, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_adr_dispatcher_method_entry) { + PHP_ME(Phalcon_ADR_Dispatcher, __construct, arginfo_phalcon_adr_dispatcher___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) + PHP_ME(Phalcon_ADR_Dispatcher, dispatch, arginfo_phalcon_adr_dispatcher_dispatch, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Dispatcher, resolveAll, arginfo_phalcon_adr_dispatcher_resolveall, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_ADR_Dispatcher, resolveGlobal, arginfo_phalcon_adr_dispatcher_resolveglobal, ZEND_ACC_PROTECTED) + PHP_FE_END +}; diff --git a/ext/phalcon/adr/eventfulhandler.zep.c b/ext/phalcon/adr/eventfulhandler.zep.c new file mode 100644 index 0000000000..9d2e3d1129 --- /dev/null +++ b/ext/phalcon/adr/eventfulhandler.zep.c @@ -0,0 +1,123 @@ + +#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" + + +/** + * 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/ + */ +/** + * The terminal handler of the pipeline: fires the `adr:*` events around the + * Action's execution. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_EventfulHandler) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\ADR, EventfulHandler, phalcon, adr_eventfulhandler, phalcon_adr_eventfulhandler_method_entry, ZEND_ACC_FINAL_CLASS); + + /** + * @var Action + */ + zend_declare_property_null(phalcon_adr_eventfulhandler_ce, SL("action"), ZEND_ACC_PROTECTED); + /** + * @var Manager + */ + zend_declare_property_null(phalcon_adr_eventfulhandler_ce, SL("events"), ZEND_ACC_PROTECTED); + zend_class_implements(phalcon_adr_eventfulhandler_ce, 1, phalcon_contracts_adr_handler_ce); + return SUCCESS; +} + +PHP_METHOD(Phalcon_ADR_EventfulHandler, __construct) +{ + zval *action, action_sub, *events, events_sub; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&action_sub); + ZVAL_UNDEF(&events_sub); + 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("action", 6, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("events", 6, 1); + } + + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_OBJECT_OF_CLASS(action, phalcon_contracts_adr_action_ce) + 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); +} + +PHP_METHOD(Phalcon_ADR_EventfulHandler, __invoke) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *request, request_sub, response, _0, _1, _2, _3, _4, _5; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&request_sub); + ZVAL_UNDEF(&response); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); + ZVAL_UNDEF(&_3); + ZVAL_UNDEF(&_4); + ZVAL_UNDEF(&_5); + 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("events", 6, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("action", 6, 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, 333, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 332, 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_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_INIT_NVAR(&_2); + ZVAL_STRING(&_2, "adr:afterExecuteAction"); + ZEPHIR_CALL_METHOD(NULL, &_4, "fire", NULL, 0, &_2, &_5, &response); + zephir_check_call_status(); + RETURN_CCTOR(&response); +} + diff --git a/ext/phalcon/adr/eventfulhandler.zep.h b/ext/phalcon/adr/eventfulhandler.zep.h new file mode 100644 index 0000000000..9366535e28 --- /dev/null +++ b/ext/phalcon/adr/eventfulhandler.zep.h @@ -0,0 +1,22 @@ + +extern zend_class_entry *phalcon_adr_eventfulhandler_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_EventfulHandler); + +PHP_METHOD(Phalcon_ADR_EventfulHandler, __construct); +PHP_METHOD(Phalcon_ADR_EventfulHandler, __invoke); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_adr_eventfulhandler___construct, 0, 0, 2) + ZEND_ARG_OBJ_INFO(0, action, Phalcon\\Contracts\\ADR\\Action, 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_eventfulhandler___invoke, 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_eventfulhandler_method_entry) { + PHP_ME(Phalcon_ADR_EventfulHandler, __construct, arginfo_phalcon_adr_eventfulhandler___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) + PHP_ME(Phalcon_ADR_EventfulHandler, __invoke, arginfo_phalcon_adr_eventfulhandler___invoke, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/phalcon/adr/events/event.zep.c b/ext/phalcon/adr/events/event.zep.c new file mode 100644 index 0000000000..47a39b72ed --- /dev/null +++ b/ext/phalcon/adr/events/event.zep.c @@ -0,0 +1,76 @@ + +#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" + + +/** + * 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/ + */ +/** + * The ADR event vocabulary, fired through the native events manager. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Events_Event) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\ADR\\Events, Event, phalcon, adr_events_event, phalcon_adr_events_event_method_entry, 0); + + /** + * @var string + */ + zephir_declare_class_constant_string(phalcon_adr_events_event_ce, SL("ADR_AFTER_EXECUTE_ACTION"), "adr:afterExecuteAction"); + + /** + * @var string + */ + zephir_declare_class_constant_string(phalcon_adr_events_event_ce, SL("ADR_BEFORE_EXECUTE_ACTION"), "adr:beforeExecuteAction"); + + /** + * @var string + */ + zephir_declare_class_constant_string(phalcon_adr_events_event_ce, SL("APPLICATION_AFTER_HANDLE"), "application:afterHandle"); + + /** + * @var string + */ + zephir_declare_class_constant_string(phalcon_adr_events_event_ce, SL("APPLICATION_BEFORE_HANDLE"), "application:beforeHandle"); + + /** + * @var string + */ + zephir_declare_class_constant_string(phalcon_adr_events_event_ce, SL("PIPELINE_AFTER_DISPATCH"), "pipeline:afterDispatch"); + + /** + * @var string + */ + zephir_declare_class_constant_string(phalcon_adr_events_event_ce, SL("PIPELINE_BEFORE_DISPATCH"), "pipeline:beforeDispatch"); + + return SUCCESS; +} + +/** + * Instantiation not allowed. + */ +PHP_METHOD(Phalcon_ADR_Events_Event, __construct) +{ + +} + diff --git a/ext/phalcon/adr/events/event.zep.h b/ext/phalcon/adr/events/event.zep.h new file mode 100644 index 0000000000..982f67ee07 --- /dev/null +++ b/ext/phalcon/adr/events/event.zep.h @@ -0,0 +1,14 @@ + +extern zend_class_entry *phalcon_adr_events_event_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Events_Event); + +PHP_METHOD(Phalcon_ADR_Events_Event, __construct); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_adr_events_event___construct, 0, 0, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_adr_events_event_method_entry) { +PHP_ME(Phalcon_ADR_Events_Event, __construct, arginfo_phalcon_adr_events_event___construct, ZEND_ACC_FINAL|ZEND_ACC_PRIVATE|ZEND_ACC_CTOR) + PHP_FE_END +}; diff --git a/ext/phalcon/adr/input/input.zep.c b/ext/phalcon/adr/input/input.zep.c index 8b950c6a5e..5c9f68384f 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, 328, &data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 334, &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, 294, &data); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 299, &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, 294, &_5); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 299, &_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, 328, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 334, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_1, &key_zv)) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 328, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 334, 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, 328, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 334, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &key_zv)); } diff --git a/ext/phalcon/adr/middleware/corsmiddleware.zep.c b/ext/phalcon/adr/middleware/corsmiddleware.zep.c new file mode 100644 index 0000000000..3d1f93b62b --- /dev/null +++ b/ext/phalcon/adr/middleware/corsmiddleware.zep.c @@ -0,0 +1,388 @@ + +#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/array.h" +#include "kernel/object.h" +#include "kernel/operators.h" +#include "kernel/fcall.h" +#include "kernel/string.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/ + */ +/** + * CORS middleware. Inert by default: it emits nothing until an origin allowlist + * is configured, and only for requests whose `Origin` is on it. The allowed + * origin is always echoed back explicitly, so credentials are never paired with + * a wildcard origin. Preflight `OPTIONS` requests are answered directly. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Middleware_CorsMiddleware) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\ADR\\Middleware, CorsMiddleware, phalcon, adr_middleware_corsmiddleware, phalcon_adr_middleware_corsmiddleware_method_entry, 0); + + /** + * @var bool + */ + zend_declare_property_bool(phalcon_adr_middleware_corsmiddleware_ce, SL("allowCredentials"), 0, ZEND_ACC_PROTECTED); + /** + * @var array + */ + zend_declare_property_null(phalcon_adr_middleware_corsmiddleware_ce, SL("allowedHeaders"), ZEND_ACC_PROTECTED); + /** + * @var array + */ + zend_declare_property_null(phalcon_adr_middleware_corsmiddleware_ce, SL("allowedMethods"), ZEND_ACC_PROTECTED); + /** + * @var array + */ + zend_declare_property_null(phalcon_adr_middleware_corsmiddleware_ce, SL("allowedOrigins"), ZEND_ACC_PROTECTED); + /** + * @var int + */ + zend_declare_property_long(phalcon_adr_middleware_corsmiddleware_ce, SL("maxAge"), 0, ZEND_ACC_PROTECTED); + zend_class_implements(phalcon_adr_middleware_corsmiddleware_ce, 1, phalcon_contracts_adr_middleware_ce); + return SUCCESS; +} + +PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, __construct) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zval *config_param = NULL, _0, _1, _2, _3, _4, _5, _6, _7, _8; + zval config; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&config); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); + ZVAL_UNDEF(&_3); + ZVAL_UNDEF(&_4); + ZVAL_UNDEF(&_5); + ZVAL_UNDEF(&_6); + ZVAL_UNDEF(&_7); + ZVAL_UNDEF(&_8); + 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; + static zend_string *_zephir_prop_4 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("allowedOrigins", 14, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("allowedMethods", 14, 1); + } + if (UNEXPECTED(!_zephir_prop_2)) { + _zephir_prop_2 = zend_string_init("allowedHeaders", 14, 1); + } + if (UNEXPECTED(!_zephir_prop_3)) { + _zephir_prop_3 = zend_string_init("allowCredentials", 16, 1); + } + if (UNEXPECTED(!_zephir_prop_4)) { + _zephir_prop_4 = zend_string_init("maxAge", 6, 1); + } + + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + ZEPHIR_Z_PARAM_ARRAY(config, config_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, 0, 1, &config_param); + if (!config_param) { + ZEPHIR_INIT_VAR(&config); + array_init(&config); + } else { + zephir_get_arrval(&config, config_param); + } + ZEPHIR_INIT_VAR(&_0); + if (zephir_array_isset_value_string(&config, SL("origins"))) { + ZEPHIR_OBS_NVAR(&_0); + zephir_array_fetch_string(&_0, &config, SL("origins"), PH_NOISY, "phalcon/ADR/Middleware/CorsMiddleware.zep", 57); + } else { + ZEPHIR_INIT_NVAR(&_0); + array_init(&_0); + } + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 335, &_0); + ZEPHIR_INIT_VAR(&_1); + if (zephir_array_isset_value_string(&config, SL("methods"))) { + ZEPHIR_OBS_NVAR(&_1); + zephir_array_fetch_string(&_1, &config, SL("methods"), PH_NOISY, "phalcon/ADR/Middleware/CorsMiddleware.zep", 58); + } else { + ZEPHIR_INIT_VAR(&_2); + zephir_create_array(&_2, 6, 0); + ZEPHIR_INIT_VAR(&_3); + ZVAL_STRING(&_3, "GET"); + zephir_array_fast_append(&_2, &_3); + ZEPHIR_INIT_NVAR(&_3); + ZVAL_STRING(&_3, "POST"); + zephir_array_fast_append(&_2, &_3); + ZEPHIR_INIT_NVAR(&_3); + ZVAL_STRING(&_3, "PUT"); + zephir_array_fast_append(&_2, &_3); + ZEPHIR_INIT_NVAR(&_3); + ZVAL_STRING(&_3, "PATCH"); + zephir_array_fast_append(&_2, &_3); + ZEPHIR_INIT_NVAR(&_3); + ZVAL_STRING(&_3, "DELETE"); + zephir_array_fast_append(&_2, &_3); + ZEPHIR_INIT_NVAR(&_3); + ZVAL_STRING(&_3, "OPTIONS"); + zephir_array_fast_append(&_2, &_3); + ZEPHIR_CPY_WRT(&_1, &_2); + } + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 336, &_1); + ZEPHIR_INIT_VAR(&_4); + if (zephir_array_isset_value_string(&config, SL("headers"))) { + ZEPHIR_OBS_NVAR(&_4); + zephir_array_fetch_string(&_4, &config, SL("headers"), PH_NOISY, "phalcon/ADR/Middleware/CorsMiddleware.zep", 59); + } else { + ZEPHIR_INIT_VAR(&_5); + zephir_create_array(&_5, 2, 0); + ZEPHIR_INIT_NVAR(&_3); + ZVAL_STRING(&_3, "Content-Type"); + zephir_array_fast_append(&_5, &_3); + ZEPHIR_INIT_NVAR(&_3); + ZVAL_STRING(&_3, "Authorization"); + zephir_array_fast_append(&_5, &_3); + ZEPHIR_CPY_WRT(&_4, &_5); + } + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 337, &_4); + ZEPHIR_INIT_VAR(&_6); + if (zephir_array_isset_value_string(&config, SL("credentials"))) { + zephir_memory_observe(&_7); + zephir_array_fetch_string(&_7, &config, SL("credentials"), PH_NOISY, "phalcon/ADR/Middleware/CorsMiddleware.zep", 60); + ZEPHIR_INIT_NVAR(&_6); + ZVAL_BOOL(&_6, zephir_get_boolval(&_7)); + } else { + ZEPHIR_INIT_NVAR(&_6); + ZVAL_BOOL(&_6, 0); + } + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 338, &_6); + ZEPHIR_INIT_VAR(&_8); + if (zephir_array_isset_value_string(&config, SL("maxAge"))) { + ZEPHIR_OBS_NVAR(&_7); + zephir_array_fetch_string(&_7, &config, SL("maxAge"), PH_NOISY, "phalcon/ADR/Middleware/CorsMiddleware.zep", 61); + ZEPHIR_INIT_NVAR(&_8); + ZVAL_LONG(&_8, zephir_get_intval(&_7)); + } else { + ZEPHIR_INIT_NVAR(&_8); + ZVAL_LONG(&_8, 0); + } + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 339, &_8); + ZEPHIR_MM_RESTORE(); +} + +PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, __invoke) +{ + zval _12$$5; + zend_bool _1; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *request, request_sub, *next, next_sub, origin, response, _0, _2, _3, _4, _5$$4, _6$$4, _7$$4, _8$$4, _9$$4, _10$$4, _11$$5, _13$$5; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&request_sub); + ZVAL_UNDEF(&next_sub); + ZVAL_UNDEF(&origin); + ZVAL_UNDEF(&response); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_2); + ZVAL_UNDEF(&_3); + ZVAL_UNDEF(&_4); + ZVAL_UNDEF(&_5$$4); + ZVAL_UNDEF(&_6$$4); + ZVAL_UNDEF(&_7$$4); + ZVAL_UNDEF(&_8$$4); + ZVAL_UNDEF(&_9$$4); + ZVAL_UNDEF(&_10$$4); + ZVAL_UNDEF(&_11$$5); + ZVAL_UNDEF(&_13$$5); + ZVAL_UNDEF(&_12$$5); + static zend_string *_zephir_prop_0 = NULL; + static zend_string *_zephir_prop_1 = NULL; + static zend_string *_zephir_prop_2 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("allowedMethods", 14, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("allowedHeaders", 14, 1); + } + if (UNEXPECTED(!_zephir_prop_2)) { + _zephir_prop_2 = zend_string_init("maxAge", 6, 1); + } + + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_OBJECT_OF_CLASS(request, phalcon_contracts_http_attributerequestinterface_ce) + Z_PARAM_OBJECT_OF_CLASS(next, phalcon_contracts_adr_handler_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, 2, 0, &request, &next); + ZEPHIR_INIT_VAR(&_0); + ZVAL_STRING(&_0, "Origin"); + ZEPHIR_CALL_METHOD(&origin, request, "getheader", NULL, 0, &_0); + zephir_check_call_status(); + _1 = ZEPHIR_IS_EMPTY(&origin); + if (!(_1)) { + ZEPHIR_CALL_METHOD(&_2, this_ptr, "isallowed", NULL, 0, &origin); + zephir_check_call_status(); + _1 = !zephir_is_true(&_2); + } + if (_1) { + ZEPHIR_RETURN_CALL_METHOD(next, "__invoke", NULL, 0, request); + zephir_check_call_status(); + RETURN_MM(); + } + ZEPHIR_CALL_METHOD(&_3, request, "getmethod", NULL, 0); + zephir_check_call_status(); + ZEPHIR_INIT_VAR(&_4); + ZVAL_STRING(&_4, "OPTIONS"); + if (ZEPHIR_IS_IDENTICAL(&_4, &_3)) { + ZEPHIR_INIT_VAR(&response); + object_init_ex(&response, phalcon_http_response_ce); + ZEPHIR_CALL_METHOD(NULL, &response, "__construct", NULL, 300); + zephir_check_call_status(); + ZVAL_LONG(&_5$$4, 204); + ZEPHIR_CALL_METHOD(NULL, &response, "setstatuscode", NULL, 301, &_5$$4); + zephir_check_call_status(); + 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_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_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_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_check_call_status(); + zephir_read_property_cached(&_10$$4, this_ptr, _zephir_prop_2, 339, 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_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_check_call_status(); + } + RETURN_CCTOR(&response); + } + ZEPHIR_CALL_METHOD(&response, next, "__invoke", NULL, 0, request); + zephir_check_call_status(); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "applyheaders", NULL, 0, &response, &origin); + zephir_check_call_status(); + RETURN_CCTOR(&response); +} + +PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, applyHeaders) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zend_string *origin = NULL; + zval *response, response_sub, origin_zv, _0, _1, _2$$3, _3$$3; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&response_sub); + ZVAL_UNDEF(&origin_zv); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2$$3); + ZVAL_UNDEF(&_3$$3); + static zend_string *_zephir_prop_0 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("allowCredentials", 16, 1); + } + + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_OBJECT_OF_CLASS(response, phalcon_http_responseinterface_ce) + Z_PARAM_STR(origin) + ZEND_PARSE_PARAMETERS_END(); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + response = ZEND_CALL_ARG(execute_data, 1); + zephir_memory_observe(&origin_zv); + ZVAL_STR_COPY(&origin_zv, origin); + ZEPHIR_INIT_VAR(&_0); + 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); + if (zephir_is_true(&_1)) { + ZEPHIR_INIT_VAR(&_2$$3); + ZVAL_STRING(&_2$$3, "Access-Control-Allow-Credentials"); + ZEPHIR_INIT_VAR(&_3$$3); + ZVAL_STRING(&_3$$3, "true"); + ZEPHIR_CALL_METHOD(NULL, response, "setheader", NULL, 0, &_2$$3, &_3$$3); + zephir_check_call_status(); + } + ZEPHIR_MM_RESTORE(); +} + +PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, isAllowed) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval origin_zv, __$true, _0, _1, _2, _3; + zend_string *origin = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&origin_zv); + ZVAL_BOOL(&__$true, 1); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); + ZVAL_UNDEF(&_3); + static zend_string *_zephir_prop_0 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("allowedOrigins", 14, 1); + } + + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(origin) + 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_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_INIT_VAR(&_1); + ZVAL_STRING(&_1, "*"); + ZEPHIR_CALL_FUNCTION(&_2, "in_array", NULL, 87, &_1, &_0, &__$true); + zephir_check_call_status(); + 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_RETURN_CALL_FUNCTION("in_array", NULL, 87, &origin_zv, &_3, &__$true); + zephir_check_call_status(); + RETURN_MM(); +} + diff --git a/ext/phalcon/adr/middleware/corsmiddleware.zep.h b/ext/phalcon/adr/middleware/corsmiddleware.zep.h new file mode 100644 index 0000000000..31146cfc70 --- /dev/null +++ b/ext/phalcon/adr/middleware/corsmiddleware.zep.h @@ -0,0 +1,36 @@ + +extern zend_class_entry *phalcon_adr_middleware_corsmiddleware_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Middleware_CorsMiddleware); + +PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, __construct); +PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, __invoke); +PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, applyHeaders); +PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, isAllowed); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_adr_middleware_corsmiddleware___construct, 0, 0, 0) +ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, config, IS_ARRAY, 0, "[]") +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_middleware_corsmiddleware___invoke, 0, 2, Phalcon\\Http\\ResponseInterface, 0) + ZEND_ARG_OBJ_INFO(0, request, Phalcon\\Contracts\\Http\\AttributeRequestInterface, 0) + ZEND_ARG_OBJ_INFO(0, next, Phalcon\\Contracts\\ADR\\Handler, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_middleware_corsmiddleware_applyheaders, 0, 2, IS_VOID, 0) + + ZEND_ARG_OBJ_INFO(0, response, Phalcon\\Http\\ResponseInterface, 0) + ZEND_ARG_TYPE_INFO(0, origin, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_middleware_corsmiddleware_isallowed, 0, 1, _IS_BOOL, 0) + ZEND_ARG_TYPE_INFO(0, origin, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_adr_middleware_corsmiddleware_method_entry) { + PHP_ME(Phalcon_ADR_Middleware_CorsMiddleware, __construct, arginfo_phalcon_adr_middleware_corsmiddleware___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) + PHP_ME(Phalcon_ADR_Middleware_CorsMiddleware, __invoke, arginfo_phalcon_adr_middleware_corsmiddleware___invoke, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Middleware_CorsMiddleware, applyHeaders, arginfo_phalcon_adr_middleware_corsmiddleware_applyheaders, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_ADR_Middleware_CorsMiddleware, isAllowed, arginfo_phalcon_adr_middleware_corsmiddleware_isallowed, ZEND_ACC_PROTECTED) + PHP_FE_END +}; diff --git a/ext/phalcon/adr/middleware/methodoverridemiddleware.zep.c b/ext/phalcon/adr/middleware/methodoverridemiddleware.zep.c new file mode 100644 index 0000000000..92d579e172 --- /dev/null +++ b/ext/phalcon/adr/middleware/methodoverridemiddleware.zep.c @@ -0,0 +1,150 @@ + +#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/string.h" +#include "kernel/object.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/ + */ +/** + * Thin enabler for the native `_method` override. + * + * `Request::getMethod()` already honors `X-HTTP-Method-Override` and, when the + * parameter-override flag is on, the `_method` field. This middleware only + * turns that flag on, and only for a `POST` request whose `_method` names a + * safe verb (`PUT`/`PATCH`/`DELETE`), so `_method` cannot spoof an arbitrary + * method. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Middleware_MethodOverrideMiddleware) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\ADR\\Middleware, MethodOverrideMiddleware, phalcon, adr_middleware_methodoverridemiddleware, phalcon_adr_middleware_methodoverridemiddleware_method_entry, 0); + + /** + * @var array + */ + zend_declare_property_null(phalcon_adr_middleware_methodoverridemiddleware_ce, SL("allowed"), ZEND_ACC_PROTECTED); + phalcon_adr_middleware_methodoverridemiddleware_ce->create_object = zephir_init_properties_Phalcon_ADR_Middleware_MethodOverrideMiddleware; + + zend_class_implements(phalcon_adr_middleware_methodoverridemiddleware_ce, 1, phalcon_contracts_adr_middleware_ce); + return SUCCESS; +} + +PHP_METHOD(Phalcon_ADR_Middleware_MethodOverrideMiddleware, __invoke) +{ + zval _4$$3; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *request, request_sub, *next, next_sub, __$true, spoofed, _0, _1, _2$$3, _3$$3, _5$$3, _6$$3, _7$$4; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&request_sub); + ZVAL_UNDEF(&next_sub); + ZVAL_BOOL(&__$true, 1); + ZVAL_UNDEF(&spoofed); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2$$3); + ZVAL_UNDEF(&_3$$3); + ZVAL_UNDEF(&_5$$3); + ZVAL_UNDEF(&_6$$3); + ZVAL_UNDEF(&_7$$4); + ZVAL_UNDEF(&_4$$3); + static zend_string *_zephir_prop_0 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("allowed", 7, 1); + } + + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_OBJECT_OF_CLASS(request, phalcon_contracts_http_attributerequestinterface_ce) + Z_PARAM_OBJECT_OF_CLASS(next, phalcon_contracts_adr_handler_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, 2, 0, &request, &next); + ZEPHIR_CALL_METHOD(&_0, request, "getmethod", NULL, 0); + zephir_check_call_status(); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "POST"); + if (ZEPHIR_IS_IDENTICAL(&_1, &_0)) { + ZEPHIR_INIT_VAR(&_3$$3); + ZVAL_STRING(&_3$$3, "_method"); + ZEPHIR_CALL_METHOD(&_2$$3, request, "getpost", NULL, 0, &_3$$3); + zephir_check_call_status(); + 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_CALL_FUNCTION(&_6$$3, "in_array", NULL, 87, &spoofed, &_5$$3, &__$true); + zephir_check_call_status(); + if (zephir_is_true(&_6$$3)) { + ZVAL_BOOL(&_7$$4, 1); + ZEPHIR_CALL_METHOD(NULL, request, "sethttpmethodparameteroverride", NULL, 0, &_7$$4); + zephir_check_call_status(); + } + } + ZEPHIR_RETURN_CALL_METHOD(next, "__invoke", NULL, 0, request); + zephir_check_call_status(); + RETURN_MM(); +} + +zend_object *zephir_init_properties_Phalcon_ADR_Middleware_MethodOverrideMiddleware(zend_class_entry *class_type) +{ + zval _1$$3; + zval _0, _2$$3; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_2$$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__); + + { + zval local_this_ptr, *this_ptr = &local_this_ptr; + ZEPHIR_CREATE_OBJECT(this_ptr, class_type); + zephir_read_property_ex(&_0, this_ptr, ZEND_STRL("allowed"), PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_0) == IS_NULL) { + ZEPHIR_INIT_VAR(&_1$$3); + zephir_create_array(&_1$$3, 3, 0); + ZEPHIR_INIT_VAR(&_2$$3); + ZVAL_STRING(&_2$$3, "DELETE"); + zephir_array_fast_append(&_1$$3, &_2$$3); + ZEPHIR_INIT_NVAR(&_2$$3); + ZVAL_STRING(&_2$$3, "PATCH"); + zephir_array_fast_append(&_1$$3, &_2$$3); + ZEPHIR_INIT_NVAR(&_2$$3); + ZVAL_STRING(&_2$$3, "PUT"); + zephir_array_fast_append(&_1$$3, &_2$$3); + zephir_update_property_zval_ex(this_ptr, ZEND_STRL("allowed"), &_1$$3); + } + ZEPHIR_MM_RESTORE(); + return Z_OBJ_P(this_ptr); + } +} + diff --git a/ext/phalcon/adr/middleware/methodoverridemiddleware.zep.h b/ext/phalcon/adr/middleware/methodoverridemiddleware.zep.h new file mode 100644 index 0000000000..4ca08cccb3 --- /dev/null +++ b/ext/phalcon/adr/middleware/methodoverridemiddleware.zep.h @@ -0,0 +1,20 @@ + +extern zend_class_entry *phalcon_adr_middleware_methodoverridemiddleware_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Middleware_MethodOverrideMiddleware); + +PHP_METHOD(Phalcon_ADR_Middleware_MethodOverrideMiddleware, __invoke); +zend_object *zephir_init_properties_Phalcon_ADR_Middleware_MethodOverrideMiddleware(zend_class_entry *class_type); + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_middleware_methodoverridemiddleware___invoke, 0, 2, Phalcon\\Http\\ResponseInterface, 0) + ZEND_ARG_OBJ_INFO(0, request, Phalcon\\Contracts\\Http\\AttributeRequestInterface, 0) + ZEND_ARG_OBJ_INFO(0, next, Phalcon\\Contracts\\ADR\\Handler, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_adr_middleware_methodoverridemiddleware_zephir_init_properties_phalcon_adr_middleware_methodoverridemiddleware, 0, 0, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_adr_middleware_methodoverridemiddleware_method_entry) { + PHP_ME(Phalcon_ADR_Middleware_MethodOverrideMiddleware, __invoke, arginfo_phalcon_adr_middleware_methodoverridemiddleware___invoke, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/phalcon/adr/middleware/requestidmiddleware.zep.c b/ext/phalcon/adr/middleware/requestidmiddleware.zep.c new file mode 100644 index 0000000000..61995cb043 --- /dev/null +++ b/ext/phalcon/adr/middleware/requestidmiddleware.zep.c @@ -0,0 +1,90 @@ + +#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/operators.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/ + */ +/** + * Ensures every request carries an `X-Request-Id`, reusing an incoming one or + * generating it, exposing it on the request attributes and the response. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Middleware_RequestIdMiddleware) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\ADR\\Middleware, RequestIdMiddleware, phalcon, adr_middleware_requestidmiddleware, phalcon_adr_middleware_requestidmiddleware_method_entry, 0); + + zend_class_implements(phalcon_adr_middleware_requestidmiddleware_ce, 1, phalcon_contracts_adr_middleware_ce); + return SUCCESS; +} + +PHP_METHOD(Phalcon_ADR_Middleware_RequestIdMiddleware, __invoke) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *request, request_sub, *next, next_sub, id, response, _0, _3, _1$$3, _2$$3; + + ZVAL_UNDEF(&request_sub); + ZVAL_UNDEF(&next_sub); + ZVAL_UNDEF(&id); + ZVAL_UNDEF(&response); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_3); + ZVAL_UNDEF(&_1$$3); + ZVAL_UNDEF(&_2$$3); + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_OBJECT_OF_CLASS(request, phalcon_contracts_http_attributerequestinterface_ce) + Z_PARAM_OBJECT_OF_CLASS(next, phalcon_contracts_adr_handler_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, 2, 0, &request, &next); + 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, 16); + ZEPHIR_CALL_FUNCTION(&_2$$3, "random_bytes", NULL, 303, &_1$$3); + zephir_check_call_status(); + ZEPHIR_CALL_FUNCTION(&id, "bin2hex", NULL, 304, &_2$$3); + zephir_check_call_status(); + } + ZEPHIR_CALL_METHOD(&_3, request, "getattributes", NULL, 0); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_0); + ZVAL_STRING(&_0, "requestId"); + ZEPHIR_CALL_METHOD(NULL, &_3, "set", NULL, 0, &_0, &id); + zephir_check_call_status(); + ZEPHIR_CALL_METHOD(&response, next, "__invoke", NULL, 0, request); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_0); + ZVAL_STRING(&_0, "X-Request-Id"); + ZEPHIR_CALL_METHOD(NULL, &response, "setheader", NULL, 0, &_0, &id); + zephir_check_call_status(); + RETURN_CCTOR(&response); +} + diff --git a/ext/phalcon/adr/middleware/requestidmiddleware.zep.h b/ext/phalcon/adr/middleware/requestidmiddleware.zep.h new file mode 100644 index 0000000000..1f96292e2d --- /dev/null +++ b/ext/phalcon/adr/middleware/requestidmiddleware.zep.h @@ -0,0 +1,16 @@ + +extern zend_class_entry *phalcon_adr_middleware_requestidmiddleware_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Middleware_RequestIdMiddleware); + +PHP_METHOD(Phalcon_ADR_Middleware_RequestIdMiddleware, __invoke); + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_middleware_requestidmiddleware___invoke, 0, 2, Phalcon\\Http\\ResponseInterface, 0) + ZEND_ARG_OBJ_INFO(0, request, Phalcon\\Contracts\\Http\\AttributeRequestInterface, 0) + ZEND_ARG_OBJ_INFO(0, next, Phalcon\\Contracts\\ADR\\Handler, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_adr_middleware_requestidmiddleware_method_entry) { + PHP_ME(Phalcon_ADR_Middleware_RequestIdMiddleware, __invoke, arginfo_phalcon_adr_middleware_requestidmiddleware___invoke, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/phalcon/adr/middleware/timingmiddleware.zep.c b/ext/phalcon/adr/middleware/timingmiddleware.zep.c new file mode 100644 index 0000000000..d218a3d418 --- /dev/null +++ b/ext/phalcon/adr/middleware/timingmiddleware.zep.c @@ -0,0 +1,87 @@ + +#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/time.h" +#include "kernel/memory.h" +#include "kernel/fcall.h" +#include "kernel/operators.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/ + */ +/** + * Adds an `X-Response-Time` header measuring how long the rest of the pipeline + * took to produce the response. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Middleware_TimingMiddleware) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\ADR\\Middleware, TimingMiddleware, phalcon, adr_middleware_timingmiddleware, phalcon_adr_middleware_timingmiddleware_method_entry, 0); + + zend_class_implements(phalcon_adr_middleware_timingmiddleware_ce, 1, phalcon_contracts_adr_middleware_ce); + return SUCCESS; +} + +PHP_METHOD(Phalcon_ADR_Middleware_TimingMiddleware, __invoke) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *request, request_sub, *next, next_sub, __$true, start, response, elapsed, _0, _1, _2; + + ZVAL_UNDEF(&request_sub); + ZVAL_UNDEF(&next_sub); + ZVAL_BOOL(&__$true, 1); + ZVAL_UNDEF(&start); + ZVAL_UNDEF(&response); + ZVAL_UNDEF(&elapsed); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_OBJECT_OF_CLASS(request, phalcon_contracts_http_attributerequestinterface_ce) + Z_PARAM_OBJECT_OF_CLASS(next, phalcon_contracts_adr_handler_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, 2, 0, &request, &next); + ZEPHIR_INIT_VAR(&start); + zephir_microtime(&start, &__$true); + ZEPHIR_CALL_METHOD(&response, next, "__invoke", NULL, 0, request); + zephir_check_call_status(); + ZEPHIR_INIT_VAR(&_0); + zephir_microtime(&_0, &__$true); + ZEPHIR_INIT_VAR(&_1); + zephir_sub_function(&_1, &_0, &start); + ZEPHIR_INIT_VAR(&elapsed); + ZVAL_DOUBLE(&elapsed, (zephir_get_numberval(&_1) * 1000.0)); + ZEPHIR_INIT_NVAR(&_0); + ZVAL_STRING(&_0, "%.2fms"); + ZEPHIR_CALL_FUNCTION(&_2, "sprintf", NULL, 145, &_0, &elapsed); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_0); + ZVAL_STRING(&_0, "X-Response-Time"); + ZEPHIR_CALL_METHOD(NULL, &response, "setheader", NULL, 0, &_0, &_2); + zephir_check_call_status(); + RETURN_CCTOR(&response); +} + diff --git a/ext/phalcon/adr/middleware/timingmiddleware.zep.h b/ext/phalcon/adr/middleware/timingmiddleware.zep.h new file mode 100644 index 0000000000..5c1053955f --- /dev/null +++ b/ext/phalcon/adr/middleware/timingmiddleware.zep.h @@ -0,0 +1,16 @@ + +extern zend_class_entry *phalcon_adr_middleware_timingmiddleware_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Middleware_TimingMiddleware); + +PHP_METHOD(Phalcon_ADR_Middleware_TimingMiddleware, __invoke); + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_middleware_timingmiddleware___invoke, 0, 2, Phalcon\\Http\\ResponseInterface, 0) + ZEND_ARG_OBJ_INFO(0, request, Phalcon\\Contracts\\Http\\AttributeRequestInterface, 0) + ZEND_ARG_OBJ_INFO(0, next, Phalcon\\Contracts\\ADR\\Handler, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_adr_middleware_timingmiddleware_method_entry) { + PHP_ME(Phalcon_ADR_Middleware_TimingMiddleware, __invoke, arginfo_phalcon_adr_middleware_timingmiddleware___invoke, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/phalcon/adr/payload/payload.zep.c b/ext/phalcon/adr/payload/payload.zep.c index 39fd22c298..6da0d39f40 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, 295, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_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, 295, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_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, 295, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_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, 295, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_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, 295, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_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, 295, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_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, 295, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_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, 295, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_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, 295, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_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, 295, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_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, 295, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_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, 295, &_2); + ZEPHIR_CALL_METHOD(&_1, &_0, "withstatus", NULL, 305, &_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 new file mode 100644 index 0000000000..37b697a39a --- /dev/null +++ b/ext/phalcon/adr/pipeline.zep.c @@ -0,0 +1,169 @@ + +#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/operators.h" +#include "kernel/memory.h" +#include "kernel/fcall.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/ + */ +/** + * Self-recursive middleware runner. It is itself a Handler: it carries an index + * and hands a new Pipeline (advanced by one) forward as the `next` handler, so + * `next` is always a real Handler - no anonymous classes or callables. + * + * When the middleware is exhausted it invokes the terminal handler (the Action). + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Pipeline) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\ADR, Pipeline, phalcon, adr_pipeline, phalcon_adr_pipeline_method_entry, ZEND_ACC_FINAL_CLASS); + + /** + * @var int + */ + zend_declare_property_null(phalcon_adr_pipeline_ce, SL("index"), ZEND_ACC_PROTECTED); + /** + * @var array + */ + zend_declare_property_null(phalcon_adr_pipeline_ce, SL("middleware"), ZEND_ACC_PROTECTED); + /** + * @var Handler + */ + zend_declare_property_null(phalcon_adr_pipeline_ce, SL("terminal"), ZEND_ACC_PROTECTED); + zend_class_implements(phalcon_adr_pipeline_ce, 1, phalcon_contracts_adr_handler_ce); + return SUCCESS; +} + +PHP_METHOD(Phalcon_ADR_Pipeline, __construct) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long index; + zval *middleware_param = NULL, *terminal, terminal_sub, *index_param = NULL, _0; + zval middleware; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&middleware); + ZVAL_UNDEF(&terminal_sub); + ZVAL_UNDEF(&_0); + static zend_string *_zephir_prop_0 = NULL; + static zend_string *_zephir_prop_1 = NULL; + static zend_string *_zephir_prop_2 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("middleware", 10, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("terminal", 8, 1); + } + if (UNEXPECTED(!_zephir_prop_2)) { + _zephir_prop_2 = zend_string_init("index", 5, 1); + } + + ZEND_PARSE_PARAMETERS_START(2, 3) + ZEPHIR_Z_PARAM_ARRAY(middleware, middleware_param) + Z_PARAM_OBJECT_OF_CLASS(terminal, phalcon_contracts_adr_handler_ce) + Z_PARAM_OPTIONAL + Z_PARAM_LONG(index) + 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, 1, &middleware_param, &terminal, &index_param); + zephir_get_arrval(&middleware, middleware_param); + if (!index_param) { + 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); + ZVAL_UNDEF(&_0); + ZVAL_LONG(&_0, index); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 343, &_0); + ZEPHIR_MM_RESTORE(); +} + +PHP_METHOD(Phalcon_ADR_Pipeline, __invoke) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *request, request_sub, mw, next, _0, _1, _3, _4, _5, _6, _7, _8, _2$$3; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&request_sub); + ZVAL_UNDEF(&mw); + ZVAL_UNDEF(&next); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_3); + ZVAL_UNDEF(&_4); + ZVAL_UNDEF(&_5); + ZVAL_UNDEF(&_6); + ZVAL_UNDEF(&_7); + ZVAL_UNDEF(&_8); + ZVAL_UNDEF(&_2$$3); + static zend_string *_zephir_prop_0 = NULL; + static zend_string *_zephir_prop_1 = NULL; + static zend_string *_zephir_prop_2 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("index", 5, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("middleware", 10, 1); + } + if (UNEXPECTED(!_zephir_prop_2)) { + _zephir_prop_2 = zend_string_init("terminal", 8, 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, 343, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 341, 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_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_memory_observe(&mw); + zephir_memory_observe(&_4); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 343, 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); + ZVAL_LONG(&_8, (zephir_get_numberval(&_7) + 1)); + ZEPHIR_CALL_METHOD(NULL, &next, "__construct", NULL, 297, &_5, &_6, &_8); + zephir_check_call_status(); + ZEPHIR_RETURN_CALL_METHOD(&mw, "__invoke", NULL, 0, request, &next); + zephir_check_call_status(); + RETURN_MM(); +} + diff --git a/ext/phalcon/adr/pipeline.zep.h b/ext/phalcon/adr/pipeline.zep.h new file mode 100644 index 0000000000..f87dfddf07 --- /dev/null +++ b/ext/phalcon/adr/pipeline.zep.h @@ -0,0 +1,23 @@ + +extern zend_class_entry *phalcon_adr_pipeline_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Pipeline); + +PHP_METHOD(Phalcon_ADR_Pipeline, __construct); +PHP_METHOD(Phalcon_ADR_Pipeline, __invoke); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_adr_pipeline___construct, 0, 0, 2) + ZEND_ARG_ARRAY_INFO(0, middleware, 0) + ZEND_ARG_OBJ_INFO(0, terminal, Phalcon\\Contracts\\ADR\\Handler, 0) + ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, index, IS_LONG, 0, "0") +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_pipeline___invoke, 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_pipeline_method_entry) { + PHP_ME(Phalcon_ADR_Pipeline, __construct, arginfo_phalcon_adr_pipeline___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) + PHP_ME(Phalcon_ADR_Pipeline, __invoke, arginfo_phalcon_adr_pipeline___invoke, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/phalcon/adr/responder/formatresponder.zep.c b/ext/phalcon/adr/responder/formatresponder.zep.c index 3d3dca458c..2402ae1e86 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, 329, &formatters); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 344, &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, 329, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 344, 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, 329, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 344, 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, 329, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$8, this_ptr, _zephir_prop_0, 344, 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 a99dc026c4..40acb1c9ee 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, 330, &url_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 345, &url_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, status); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 331, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 346, &_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, 296, &url_zv, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 306, &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, 296, &url_zv, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 306, &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, 296, &url_zv, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 306, &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 be6ff76d8a..e750d44a96 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, 332, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 347, &_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, 332, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 347, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_1, &status_zv)) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 332, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 347, 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 6b8f958aca..0a00f5d84f 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, 297); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 307); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 333, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 348, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 333, mapper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 348, 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, 333, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 348, 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/exceptions/methodnotallowed.zep.c b/ext/phalcon/adr/router/exceptions/methodnotallowed.zep.c new file mode 100644 index 0000000000..a5fbbeb73d --- /dev/null +++ b/ext/phalcon/adr/router/exceptions/methodnotallowed.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 +#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 a route matches the path but not the request method. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Router_Exceptions_MethodNotAllowed) +{ + ZEPHIR_REGISTER_CLASS_EX(Phalcon\\ADR\\Router\\Exceptions, MethodNotAllowed, phalcon, adr_router_exceptions_methodnotallowed, phalcon_adr_exceptions_exception_ce, NULL, 0); + + return SUCCESS; +} + diff --git a/ext/phalcon/adr/router/exceptions/methodnotallowed.zep.h b/ext/phalcon/adr/router/exceptions/methodnotallowed.zep.h new file mode 100644 index 0000000000..9bd55c1adb --- /dev/null +++ b/ext/phalcon/adr/router/exceptions/methodnotallowed.zep.h @@ -0,0 +1,5 @@ + +extern zend_class_entry *phalcon_adr_router_exceptions_methodnotallowed_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Router_Exceptions_MethodNotAllowed); + diff --git a/ext/phalcon/adr/router/exceptions/routenotfound.zep.c b/ext/phalcon/adr/router/exceptions/routenotfound.zep.c new file mode 100644 index 0000000000..e1463297e1 --- /dev/null +++ b/ext/phalcon/adr/router/exceptions/routenotfound.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 +#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 no route matches the request. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Router_Exceptions_RouteNotFound) +{ + ZEPHIR_REGISTER_CLASS_EX(Phalcon\\ADR\\Router\\Exceptions, RouteNotFound, phalcon, adr_router_exceptions_routenotfound, phalcon_adr_exceptions_exception_ce, NULL, 0); + + return SUCCESS; +} + diff --git a/ext/phalcon/adr/router/exceptions/routenotfound.zep.h b/ext/phalcon/adr/router/exceptions/routenotfound.zep.h new file mode 100644 index 0000000000..cd9c295a44 --- /dev/null +++ b/ext/phalcon/adr/router/exceptions/routenotfound.zep.h @@ -0,0 +1,5 @@ + +extern zend_class_entry *phalcon_adr_router_exceptions_routenotfound_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Router_Exceptions_RouteNotFound); + diff --git a/ext/phalcon/adr/router/group.zep.c b/ext/phalcon/adr/router/group.zep.c new file mode 100644 index 0000000000..274b989d4c --- /dev/null +++ b/ext/phalcon/adr/router/group.zep.c @@ -0,0 +1,418 @@ + +#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/concat.h" +#include "kernel/memory.h" +#include "kernel/operators.h" +#include "kernel/array.h" +#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/ + */ +/** + * A group of routes sharing a path prefix and middleware. Routes registered + * through the group get the prefix prepended and the group's middleware + * flattened onto them (set middleware before adding routes). + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Router_Group) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\ADR\\Router, Group, phalcon, adr_router_group, phalcon_adr_router_group_method_entry, 0); + + /** + * @var string + */ + zend_declare_property_null(phalcon_adr_router_group_ce, SL("prefix"), ZEND_ACC_PROTECTED); + /** + * @var Router + */ + zend_declare_property_null(phalcon_adr_router_group_ce, SL("router"), ZEND_ACC_PROTECTED); + /** + * @var array + */ + zend_declare_property_null(phalcon_adr_router_group_ce, SL("middleware"), ZEND_ACC_PROTECTED); + phalcon_adr_router_group_ce->create_object = zephir_init_properties_Phalcon_ADR_Router_Group; + + zend_class_implements(phalcon_adr_router_group_ce, 1, phalcon_contracts_adr_router_group_ce); + return SUCCESS; +} + +PHP_METHOD(Phalcon_ADR_Router_Group, __construct) +{ + zval prefix_zv, *router, router_sub; + zend_string *prefix = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&prefix_zv); + ZVAL_UNDEF(&router_sub); + 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("prefix", 6, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("router", 6, 1); + } + + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(prefix) + Z_PARAM_OBJECT_OF_CLASS(router, phalcon_adr_router_router_ce) + 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); +} + +PHP_METHOD(Phalcon_ADR_Router_Group, add) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval methods; + zval pattern_zv, actionClass_zv, *methods_param = NULL, route, _0, _1, _2, _3; + zend_string *pattern = NULL, *actionClass = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&pattern_zv); + ZVAL_UNDEF(&actionClass_zv); + ZVAL_UNDEF(&route); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); + ZVAL_UNDEF(&_3); + ZVAL_UNDEF(&methods); + static zend_string *_zephir_prop_0 = NULL; + static zend_string *_zephir_prop_1 = NULL; + static zend_string *_zephir_prop_2 = 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("prefix", 6, 1); + } + if (UNEXPECTED(!_zephir_prop_2)) { + _zephir_prop_2 = zend_string_init("middleware", 10, 1); + } + + ZEND_PARSE_PARAMETERS_START(2, 3) + Z_PARAM_STR(pattern) + Z_PARAM_STR(actionClass) + Z_PARAM_OPTIONAL + ZEPHIR_Z_PARAM_ARRAY(methods, methods_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__); + if (ZEND_NUM_ARGS() > 2) { + methods_param = ZEND_CALL_ARG(execute_data, 3); + } + zephir_memory_observe(&pattern_zv); + ZVAL_STR_COPY(&pattern_zv, pattern); + zephir_memory_observe(&actionClass_zv); + ZVAL_STR_COPY(&actionClass_zv, actionClass); + if (!methods_param) { + ZEPHIR_INIT_VAR(&methods); + array_init(&methods); + } 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_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_CALL_METHOD(NULL, &route, "pushmiddleware", NULL, 0, &_3); + zephir_check_call_status(); + RETURN_CCTOR(&route); +} + +PHP_METHOD(Phalcon_ADR_Router_Group, delete) +{ + zval _0; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval pattern_zv, actionClass_zv, _1; + zend_string *pattern = NULL, *actionClass = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&pattern_zv); + ZVAL_UNDEF(&actionClass_zv); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_0); + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(pattern) + Z_PARAM_STR(actionClass) + 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_memory_observe(&pattern_zv); + ZVAL_STR_COPY(&pattern_zv, pattern); + zephir_memory_observe(&actionClass_zv); + ZVAL_STR_COPY(&actionClass_zv, actionClass); + ZEPHIR_INIT_VAR(&_0); + zephir_create_array(&_0, 1, 0); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "DELETE"); + zephir_array_fast_append(&_0, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 0, &pattern_zv, &actionClass_zv, &_0); + zephir_check_call_status(); + RETURN_MM(); +} + +PHP_METHOD(Phalcon_ADR_Router_Group, get) +{ + zval _0; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval pattern_zv, actionClass_zv, _1; + zend_string *pattern = NULL, *actionClass = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&pattern_zv); + ZVAL_UNDEF(&actionClass_zv); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_0); + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(pattern) + Z_PARAM_STR(actionClass) + 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_memory_observe(&pattern_zv); + ZVAL_STR_COPY(&pattern_zv, pattern); + zephir_memory_observe(&actionClass_zv); + ZVAL_STR_COPY(&actionClass_zv, actionClass); + ZEPHIR_INIT_VAR(&_0); + zephir_create_array(&_0, 1, 0); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "GET"); + zephir_array_fast_append(&_0, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 0, &pattern_zv, &actionClass_zv, &_0); + zephir_check_call_status(); + RETURN_MM(); +} + +PHP_METHOD(Phalcon_ADR_Router_Group, patch) +{ + zval _0; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval pattern_zv, actionClass_zv, _1; + zend_string *pattern = NULL, *actionClass = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&pattern_zv); + ZVAL_UNDEF(&actionClass_zv); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_0); + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(pattern) + Z_PARAM_STR(actionClass) + 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_memory_observe(&pattern_zv); + ZVAL_STR_COPY(&pattern_zv, pattern); + zephir_memory_observe(&actionClass_zv); + ZVAL_STR_COPY(&actionClass_zv, actionClass); + ZEPHIR_INIT_VAR(&_0); + zephir_create_array(&_0, 1, 0); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "PATCH"); + zephir_array_fast_append(&_0, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 0, &pattern_zv, &actionClass_zv, &_0); + zephir_check_call_status(); + RETURN_MM(); +} + +PHP_METHOD(Phalcon_ADR_Router_Group, post) +{ + zval _0; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval pattern_zv, actionClass_zv, _1; + zend_string *pattern = NULL, *actionClass = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&pattern_zv); + ZVAL_UNDEF(&actionClass_zv); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_0); + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(pattern) + Z_PARAM_STR(actionClass) + 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_memory_observe(&pattern_zv); + ZVAL_STR_COPY(&pattern_zv, pattern); + zephir_memory_observe(&actionClass_zv); + ZVAL_STR_COPY(&actionClass_zv, actionClass); + ZEPHIR_INIT_VAR(&_0); + zephir_create_array(&_0, 1, 0); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "POST"); + zephir_array_fast_append(&_0, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 0, &pattern_zv, &actionClass_zv, &_0); + zephir_check_call_status(); + RETURN_MM(); +} + +PHP_METHOD(Phalcon_ADR_Router_Group, put) +{ + zval _0; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval pattern_zv, actionClass_zv, _1; + zend_string *pattern = NULL, *actionClass = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&pattern_zv); + ZVAL_UNDEF(&actionClass_zv); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_0); + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(pattern) + Z_PARAM_STR(actionClass) + 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_memory_observe(&pattern_zv); + ZVAL_STR_COPY(&pattern_zv, pattern); + zephir_memory_observe(&actionClass_zv); + ZVAL_STR_COPY(&actionClass_zv, actionClass); + ZEPHIR_INIT_VAR(&_0); + zephir_create_array(&_0, 1, 0); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "PUT"); + zephir_array_fast_append(&_0, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 0, &pattern_zv, &actionClass_zv, &_0); + zephir_check_call_status(); + RETURN_MM(); +} + +PHP_METHOD(Phalcon_ADR_Router_Group, withMiddleware) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval classes; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&classes); + ZEND_PARSE_PARAMETERS_START(0, -1) + 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_INIT_VAR(&classes); + zephir_get_args_from(&classes, 0); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "pushmiddleware", NULL, 0, &classes); + zephir_check_call_status(); + RETURN_THIS(); +} + +PHP_METHOD(Phalcon_ADR_Router_Group, getMiddleware) +{ + + RETURN_MEMBER_TYPED(getThis(), "middleware", IS_ARRAY); +} + +PHP_METHOD(Phalcon_ADR_Router_Group, pushMiddleware) +{ + zend_bool _2; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *classes_param = NULL, item, *_0, _1; + zval classes; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&classes); + ZVAL_UNDEF(&item); + ZVAL_UNDEF(&_1); + ZEND_PARSE_PARAMETERS_START(1, 1) + ZEPHIR_Z_PARAM_ARRAY(classes, classes_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, 1, 0, &classes_param); + zephir_get_arrval(&classes, classes_param); + zephir_is_iterable(&classes, 0, "phalcon/ADR/Router/Traits/HasMiddleware.zep", 39); + if (Z_TYPE_P(&classes) == IS_ARRAY) { + ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&classes), _0) + { + ZEPHIR_INIT_NVAR(&item); + ZVAL_COPY(&item, _0); + zephir_update_property_array_append(this_ptr, SL("middleware"), &item); + } ZEND_HASH_FOREACH_END(); + } else { + ZEPHIR_CALL_METHOD(NULL, &classes, "rewind", NULL, 0); + zephir_check_call_status(); + _2 = 1; + while (1) { + if (_2) { + _2 = 0; + } else { + ZEPHIR_CALL_METHOD(NULL, &classes, "next", NULL, 0); + zephir_check_call_status(); + } + ZEPHIR_CALL_METHOD(&_1, &classes, "valid", NULL, 0); + zephir_check_call_status(); + if (!zend_is_true(&_1)) { + break; + } + ZEPHIR_CALL_METHOD(&item, &classes, "current", NULL, 0); + zephir_check_call_status(); + zephir_update_property_array_append(this_ptr, SL("middleware"), &item); + } + } + ZEPHIR_INIT_NVAR(&item); + ZEPHIR_MM_RESTORE(); +} + +zend_object *zephir_init_properties_Phalcon_ADR_Router_Group(zend_class_entry *class_type) +{ + zval _0, _1$$3; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1$$3); + + + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + + { + zval local_this_ptr, *this_ptr = &local_this_ptr; + ZEPHIR_CREATE_OBJECT(this_ptr, class_type); + zephir_read_property_ex(&_0, this_ptr, ZEND_STRL("middleware"), PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_0) == IS_NULL) { + ZEPHIR_INIT_VAR(&_1$$3); + array_init(&_1$$3); + zephir_update_property_zval_ex(this_ptr, ZEND_STRL("middleware"), &_1$$3); + } + ZEPHIR_MM_RESTORE(); + return Z_OBJ_P(this_ptr); + } +} + diff --git a/ext/phalcon/adr/router/group.zep.h b/ext/phalcon/adr/router/group.zep.h new file mode 100644 index 0000000000..34f5aa645f --- /dev/null +++ b/ext/phalcon/adr/router/group.zep.h @@ -0,0 +1,81 @@ + +extern zend_class_entry *phalcon_adr_router_group_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Router_Group); + +PHP_METHOD(Phalcon_ADR_Router_Group, __construct); +PHP_METHOD(Phalcon_ADR_Router_Group, add); +PHP_METHOD(Phalcon_ADR_Router_Group, delete); +PHP_METHOD(Phalcon_ADR_Router_Group, get); +PHP_METHOD(Phalcon_ADR_Router_Group, patch); +PHP_METHOD(Phalcon_ADR_Router_Group, post); +PHP_METHOD(Phalcon_ADR_Router_Group, put); +PHP_METHOD(Phalcon_ADR_Router_Group, withMiddleware); +PHP_METHOD(Phalcon_ADR_Router_Group, getMiddleware); +PHP_METHOD(Phalcon_ADR_Router_Group, pushMiddleware); +zend_object *zephir_init_properties_Phalcon_ADR_Router_Group(zend_class_entry *class_type); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_adr_router_group___construct, 0, 0, 2) + ZEND_ARG_TYPE_INFO(0, prefix, IS_STRING, 0) + ZEND_ARG_OBJ_INFO(0, router, Phalcon\\ADR\\Router\\Router, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_router_group_add, 0, 2, Phalcon\\Contracts\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, methods, IS_ARRAY, 0, "[]") +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_router_group_delete, 0, 2, Phalcon\\Contracts\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_router_group_get, 0, 2, Phalcon\\Contracts\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_router_group_patch, 0, 2, Phalcon\\Contracts\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_router_group_post, 0, 2, Phalcon\\Contracts\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_router_group_put, 0, 2, Phalcon\\Contracts\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_router_group_withmiddleware, 0, 0, Phalcon\\Contracts\\ADR\\Router\\Group, 0) + ZEND_ARG_VARIADIC_TYPE_INFO(0, classes, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_router_group_getmiddleware, 0, 0, IS_ARRAY, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_router_group_pushmiddleware, 0, 1, IS_VOID, 0) + + ZEND_ARG_ARRAY_INFO(0, classes, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_adr_router_group_zephir_init_properties_phalcon_adr_router_group, 0, 0, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_adr_router_group_method_entry) { + PHP_ME(Phalcon_ADR_Router_Group, __construct, arginfo_phalcon_adr_router_group___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) + PHP_ME(Phalcon_ADR_Router_Group, add, arginfo_phalcon_adr_router_group_add, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Group, delete, arginfo_phalcon_adr_router_group_delete, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Group, get, arginfo_phalcon_adr_router_group_get, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Group, patch, arginfo_phalcon_adr_router_group_patch, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Group, post, arginfo_phalcon_adr_router_group_post, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Group, put, arginfo_phalcon_adr_router_group_put, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Group, withMiddleware, arginfo_phalcon_adr_router_group_withmiddleware, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Group, getMiddleware, arginfo_phalcon_adr_router_group_getmiddleware, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Group, pushMiddleware, arginfo_phalcon_adr_router_group_pushmiddleware, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/phalcon/adr/router/route.zep.c b/ext/phalcon/adr/router/route.zep.c new file mode 100644 index 0000000000..e10e1da8b3 --- /dev/null +++ b/ext/phalcon/adr/router/route.zep.c @@ -0,0 +1,388 @@ + +#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/string.h" +#include "kernel/array.h" +#include "kernel/main.h" +#include "kernel/concat.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/ + */ +/** + * A route registered with the router. Compiles a `/posts/{id}` style pattern to + * a regular expression (with `{name:regex}` constraints supported) and matches + * the request path against it, extracting the named parameters. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Router_Route) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\ADR\\Router, Route, phalcon, adr_router_route, phalcon_adr_router_route_method_entry, 0); + + /** + * @var string + */ + zend_declare_property_null(phalcon_adr_router_route_ce, SL("action"), ZEND_ACC_PROTECTED); + /** + * @var string + */ + zend_declare_property_null(phalcon_adr_router_route_ce, SL("compiled"), ZEND_ACC_PROTECTED); + /** + * @var array + */ + zend_declare_property_null(phalcon_adr_router_route_ce, SL("methods"), ZEND_ACC_PROTECTED); + /** + * @var string|null + */ + zend_declare_property_null(phalcon_adr_router_route_ce, SL("name"), ZEND_ACC_PROTECTED); + /** + * @var array + */ + zend_declare_property_null(phalcon_adr_router_route_ce, SL("middleware"), ZEND_ACC_PROTECTED); + phalcon_adr_router_route_ce->create_object = zephir_init_properties_Phalcon_ADR_Router_Route; + + zend_class_implements(phalcon_adr_router_route_ce, 1, phalcon_contracts_adr_router_route_ce); + return SUCCESS; +} + +PHP_METHOD(Phalcon_ADR_Router_Route, __construct) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval methods; + zval pattern_zv, action_zv, *methods_param = NULL, _0; + zend_string *pattern = NULL, *action = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&pattern_zv); + ZVAL_UNDEF(&action_zv); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&methods); + static zend_string *_zephir_prop_0 = NULL; + static zend_string *_zephir_prop_1 = NULL; + static zend_string *_zephir_prop_2 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("action", 6, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("methods", 7, 1); + } + if (UNEXPECTED(!_zephir_prop_2)) { + _zephir_prop_2 = zend_string_init("compiled", 8, 1); + } + + ZEND_PARSE_PARAMETERS_START(2, 3) + Z_PARAM_STR(pattern) + Z_PARAM_STR(action) + Z_PARAM_OPTIONAL + ZEPHIR_Z_PARAM_ARRAY(methods, methods_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__); + if (ZEND_NUM_ARGS() > 2) { + methods_param = ZEND_CALL_ARG(execute_data, 3); + } + zephir_memory_observe(&pattern_zv); + ZVAL_STR_COPY(&pattern_zv, pattern); + zephir_memory_observe(&action_zv); + ZVAL_STR_COPY(&action_zv, action); + if (!methods_param) { + ZEPHIR_INIT_VAR(&methods); + array_init(&methods); + } 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_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_MM_RESTORE(); +} + +PHP_METHOD(Phalcon_ADR_Router_Route, allowsMethod) +{ + zend_bool _1; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval method_zv, __$true, _0, _2, _3; + zend_string *method = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&method_zv); + ZVAL_BOOL(&__$true, 1); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_2); + ZVAL_UNDEF(&_3); + static zend_string *_zephir_prop_0 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("methods", 7, 1); + } + + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(method) + 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_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); + _1 = ZEPHIR_IS_EMPTY(&_0); + if (!(_1)) { + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 353, 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); + } + RETURN_MM_BOOL(_1); +} + +PHP_METHOD(Phalcon_ADR_Router_Route, getAction) +{ + + RETURN_MEMBER_TYPED(getThis(), "action", IS_STRING); +} + +PHP_METHOD(Phalcon_ADR_Router_Route, getName) +{ + + RETURN_MEMBER(getThis(), "name"); +} + +PHP_METHOD(Phalcon_ADR_Router_Route, matches) +{ + zend_ulong _3; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval uri_zv, matches, params, key, value, _0, _1, *_2; + zend_string *uri = NULL, *_4; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&uri_zv); + ZVAL_UNDEF(&matches); + ZVAL_UNDEF(¶ms); + ZVAL_UNDEF(&key); + ZVAL_UNDEF(&value); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + static zend_string *_zephir_prop_0 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("compiled", 8, 1); + } + + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(uri) + 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_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_INIT_VAR(&_1); + zephir_preg_match(&_1, &_0, &uri_zv, &matches, 0, 0 , 0 ); + if (!(zephir_is_true(&_1))) { + RETURN_MM_BOOL(0); + } + ZEPHIR_INIT_VAR(¶ms); + array_init(¶ms); + zephir_is_iterable(&matches, 0, "phalcon/ADR/Router/Route.zep", 85); + ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&matches), _3, _4, _2) + { + ZEPHIR_INIT_NVAR(&key); + if (_4 != NULL) { + ZVAL_STR_COPY(&key, _4); + } else { + ZVAL_LONG(&key, _3); + } + ZEPHIR_INIT_NVAR(&value); + ZVAL_COPY(&value, _2); + if (Z_TYPE_P(&key) == IS_STRING) { + zephir_array_update_zval(¶ms, &key, &value, PH_COPY | PH_SEPARATE); + } + } ZEND_HASH_FOREACH_END(); + ZEPHIR_INIT_NVAR(&value); + ZEPHIR_INIT_NVAR(&key); + RETURN_CCTOR(¶ms); +} + +PHP_METHOD(Phalcon_ADR_Router_Route, withMiddleware) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval classes; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&classes); + ZEND_PARSE_PARAMETERS_START(0, -1) + 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_INIT_VAR(&classes); + zephir_get_args_from(&classes, 0); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "pushmiddleware", NULL, 0, &classes); + zephir_check_call_status(); + RETURN_THIS(); +} + +PHP_METHOD(Phalcon_ADR_Router_Route, withName) +{ + zval name_zv; + zend_string *name = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&name_zv); + static zend_string *_zephir_prop_0 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("name", 4, 1); + } + + ZEND_PARSE_PARAMETERS_START(1, 1) + 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); + RETURN_THISW(); +} + +PHP_METHOD(Phalcon_ADR_Router_Route, compile) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval pattern_zv, compiled, _0, _1, _2; + zend_string *pattern = NULL; + + ZVAL_UNDEF(&pattern_zv); + ZVAL_UNDEF(&compiled); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(pattern) + 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_memory_observe(&pattern_zv); + ZVAL_STR_COPY(&pattern_zv, pattern); + ZEPHIR_INIT_VAR(&_0); + ZVAL_STRING(&_0, "#\\{([a-zA-Z_][a-zA-Z0-9_]*):([^{}]+)\\}#"); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "(?<$1>$2)"); + ZEPHIR_CALL_FUNCTION(&compiled, "preg_replace", NULL, 90, &_0, &_1, &pattern_zv); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_0); + ZVAL_STRING(&_0, "#\\{([a-zA-Z_][a-zA-Z0-9_]*)\\}#"); + ZEPHIR_INIT_NVAR(&_1); + ZVAL_STRING(&_1, "(?<$1>[^/]+)"); + ZEPHIR_CALL_FUNCTION(&_2, "preg_replace", NULL, 90, &_0, &_1, &compiled); + zephir_check_call_status(); + ZEPHIR_CPY_WRT(&compiled, &_2); + ZEPHIR_CONCAT_SVS(return_value, "#^", &compiled, "$#"); + RETURN_MM(); +} + +PHP_METHOD(Phalcon_ADR_Router_Route, getMiddleware) +{ + + RETURN_MEMBER_TYPED(getThis(), "middleware", IS_ARRAY); +} + +PHP_METHOD(Phalcon_ADR_Router_Route, pushMiddleware) +{ + zend_bool _2; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *classes_param = NULL, item, *_0, _1; + zval classes; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&classes); + ZVAL_UNDEF(&item); + ZVAL_UNDEF(&_1); + ZEND_PARSE_PARAMETERS_START(1, 1) + ZEPHIR_Z_PARAM_ARRAY(classes, classes_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, 1, 0, &classes_param); + zephir_get_arrval(&classes, classes_param); + zephir_is_iterable(&classes, 0, "phalcon/ADR/Router/Traits/HasMiddleware.zep", 39); + if (Z_TYPE_P(&classes) == IS_ARRAY) { + ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&classes), _0) + { + ZEPHIR_INIT_NVAR(&item); + ZVAL_COPY(&item, _0); + zephir_update_property_array_append(this_ptr, SL("middleware"), &item); + } ZEND_HASH_FOREACH_END(); + } else { + ZEPHIR_CALL_METHOD(NULL, &classes, "rewind", NULL, 0); + zephir_check_call_status(); + _2 = 1; + while (1) { + if (_2) { + _2 = 0; + } else { + ZEPHIR_CALL_METHOD(NULL, &classes, "next", NULL, 0); + zephir_check_call_status(); + } + ZEPHIR_CALL_METHOD(&_1, &classes, "valid", NULL, 0); + zephir_check_call_status(); + if (!zend_is_true(&_1)) { + break; + } + ZEPHIR_CALL_METHOD(&item, &classes, "current", NULL, 0); + zephir_check_call_status(); + zephir_update_property_array_append(this_ptr, SL("middleware"), &item); + } + } + ZEPHIR_INIT_NVAR(&item); + ZEPHIR_MM_RESTORE(); +} + +zend_object *zephir_init_properties_Phalcon_ADR_Router_Route(zend_class_entry *class_type) +{ + zval _0, _1$$3; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1$$3); + + + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + + { + zval local_this_ptr, *this_ptr = &local_this_ptr; + ZEPHIR_CREATE_OBJECT(this_ptr, class_type); + zephir_read_property_ex(&_0, this_ptr, ZEND_STRL("middleware"), PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_0) == IS_NULL) { + ZEPHIR_INIT_VAR(&_1$$3); + array_init(&_1$$3); + zephir_update_property_zval_ex(this_ptr, ZEND_STRL("middleware"), &_1$$3); + } + ZEPHIR_MM_RESTORE(); + return Z_OBJ_P(this_ptr); + } +} + diff --git a/ext/phalcon/adr/router/route.zep.h b/ext/phalcon/adr/router/route.zep.h new file mode 100644 index 0000000000..0a59fe45a1 --- /dev/null +++ b/ext/phalcon/adr/router/route.zep.h @@ -0,0 +1,73 @@ + +extern zend_class_entry *phalcon_adr_router_route_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Router_Route); + +PHP_METHOD(Phalcon_ADR_Router_Route, __construct); +PHP_METHOD(Phalcon_ADR_Router_Route, allowsMethod); +PHP_METHOD(Phalcon_ADR_Router_Route, getAction); +PHP_METHOD(Phalcon_ADR_Router_Route, getName); +PHP_METHOD(Phalcon_ADR_Router_Route, matches); +PHP_METHOD(Phalcon_ADR_Router_Route, withMiddleware); +PHP_METHOD(Phalcon_ADR_Router_Route, withName); +PHP_METHOD(Phalcon_ADR_Router_Route, compile); +PHP_METHOD(Phalcon_ADR_Router_Route, getMiddleware); +PHP_METHOD(Phalcon_ADR_Router_Route, pushMiddleware); +zend_object *zephir_init_properties_Phalcon_ADR_Router_Route(zend_class_entry *class_type); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_adr_router_route___construct, 0, 0, 2) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, action, IS_STRING, 0) +ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, methods, IS_ARRAY, 0, "[]") +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_router_route_allowsmethod, 0, 1, _IS_BOOL, 0) + ZEND_ARG_TYPE_INFO(0, method, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_router_route_getaction, 0, 0, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_router_route_getname, 0, 0, IS_STRING, 1) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_phalcon_adr_router_route_matches, 0, 1, MAY_BE_ARRAY|MAY_BE_BOOL) + ZEND_ARG_TYPE_INFO(0, uri, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_router_route_withmiddleware, 0, 0, Phalcon\\Contracts\\ADR\\Router\\Route, 0) + ZEND_ARG_VARIADIC_TYPE_INFO(0, classes, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_router_route_withname, 0, 1, Phalcon\\Contracts\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_router_route_compile, 0, 1, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_router_route_getmiddleware, 0, 0, IS_ARRAY, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_router_route_pushmiddleware, 0, 1, IS_VOID, 0) + + ZEND_ARG_ARRAY_INFO(0, classes, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_adr_router_route_zephir_init_properties_phalcon_adr_router_route, 0, 0, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_adr_router_route_method_entry) { + PHP_ME(Phalcon_ADR_Router_Route, __construct, arginfo_phalcon_adr_router_route___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) + PHP_ME(Phalcon_ADR_Router_Route, allowsMethod, arginfo_phalcon_adr_router_route_allowsmethod, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Route, getAction, arginfo_phalcon_adr_router_route_getaction, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Route, getName, arginfo_phalcon_adr_router_route_getname, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Route, matches, arginfo_phalcon_adr_router_route_matches, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Route, withMiddleware, arginfo_phalcon_adr_router_route_withmiddleware, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Route, withName, arginfo_phalcon_adr_router_route_withname, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Route, compile, arginfo_phalcon_adr_router_route_compile, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_ADR_Router_Route, getMiddleware, arginfo_phalcon_adr_router_route_getmiddleware, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Route, pushMiddleware, arginfo_phalcon_adr_router_route_pushmiddleware, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/phalcon/adr/router/router.zep.c b/ext/phalcon/adr/router/router.zep.c new file mode 100644 index 0000000000..391b5fe7a5 --- /dev/null +++ b/ext/phalcon/adr/router/router.zep.c @@ -0,0 +1,430 @@ + +#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/object.h" +#include "kernel/operators.h" +#include "kernel/array.h" +#include "Zend/zend_closures.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/ + */ +/** + * The ADR router. Routes are registered by pattern + HTTP method (verb helpers + * or `add()`), optionally grouped, and matched against the request. `match()` + * returns a RouterMatch, `null` when nothing matches, or throws + * MethodNotAllowed when a path matches but the method does not. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Router_Router) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\ADR\\Router, Router, phalcon, adr_router_router, phalcon_adr_router_router_method_entry, ZEND_ACC_FINAL_CLASS); + + /** + * @var Route[] + */ + zend_declare_property_null(phalcon_adr_router_router_ce, SL("routes"), ZEND_ACC_PROTECTED); + phalcon_adr_router_router_ce->create_object = zephir_init_properties_Phalcon_ADR_Router_Router; + + zend_class_implements(phalcon_adr_router_router_ce, 1, phalcon_contracts_adr_router_router_ce); + return SUCCESS; +} + +PHP_METHOD(Phalcon_ADR_Router_Router, add) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval methods; + zval pattern_zv, actionClass_zv, *methods_param = NULL, route; + zend_string *pattern = NULL, *actionClass = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&pattern_zv); + ZVAL_UNDEF(&actionClass_zv); + ZVAL_UNDEF(&route); + ZVAL_UNDEF(&methods); + ZEND_PARSE_PARAMETERS_START(2, 3) + Z_PARAM_STR(pattern) + Z_PARAM_STR(actionClass) + Z_PARAM_OPTIONAL + ZEPHIR_Z_PARAM_ARRAY(methods, methods_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__); + if (ZEND_NUM_ARGS() > 2) { + methods_param = ZEND_CALL_ARG(execute_data, 3); + } + zephir_memory_observe(&pattern_zv); + ZVAL_STR_COPY(&pattern_zv, pattern); + zephir_memory_observe(&actionClass_zv); + ZVAL_STR_COPY(&actionClass_zv, actionClass); + if (!methods_param) { + ZEPHIR_INIT_VAR(&methods); + array_init(&methods); + } else { + zephir_get_arrval(&methods, methods_param); + } + 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_check_call_status(); + zephir_update_property_array_append(this_ptr, SL("routes"), &route); + RETURN_CCTOR(&route); +} + +PHP_METHOD(Phalcon_ADR_Router_Router, delete) +{ + zval _0; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval pattern_zv, actionClass_zv, _1; + zend_string *pattern = NULL, *actionClass = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&pattern_zv); + ZVAL_UNDEF(&actionClass_zv); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_0); + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(pattern) + Z_PARAM_STR(actionClass) + 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_memory_observe(&pattern_zv); + ZVAL_STR_COPY(&pattern_zv, pattern); + zephir_memory_observe(&actionClass_zv); + ZVAL_STR_COPY(&actionClass_zv, actionClass); + ZEPHIR_INIT_VAR(&_0); + zephir_create_array(&_0, 1, 0); + 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_check_call_status(); + RETURN_MM(); +} + +PHP_METHOD(Phalcon_ADR_Router_Router, get) +{ + zval _0; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval pattern_zv, actionClass_zv, _1; + zend_string *pattern = NULL, *actionClass = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&pattern_zv); + ZVAL_UNDEF(&actionClass_zv); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_0); + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(pattern) + Z_PARAM_STR(actionClass) + 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_memory_observe(&pattern_zv); + ZVAL_STR_COPY(&pattern_zv, pattern); + zephir_memory_observe(&actionClass_zv); + ZVAL_STR_COPY(&actionClass_zv, actionClass); + ZEPHIR_INIT_VAR(&_0); + zephir_create_array(&_0, 1, 0); + 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_check_call_status(); + RETURN_MM(); +} + +PHP_METHOD(Phalcon_ADR_Router_Router, group) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval prefix_zv, *configure, configure_sub, group; + zend_string *prefix = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&prefix_zv); + ZVAL_UNDEF(&configure_sub); + ZVAL_UNDEF(&group); + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(prefix) + Z_PARAM_OBJECT_OF_CLASS(configure, zend_ce_closure) + ZEND_PARSE_PARAMETERS_END(); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + configure = ZEND_CALL_ARG(execute_data, 2); + zephir_memory_observe(&prefix_zv); + 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_check_call_status(); + ZEPHIR_CALL_FUNCTION(NULL, "call_user_func", NULL, 80, configure, &group); + zephir_check_call_status(); + RETURN_CCTOR(&group); +} + +PHP_METHOD(Phalcon_ADR_Router_Router, match) +{ + zend_bool methodMismatch = 0, _8; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zephir_fcall_cache_entry *_6 = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *request, request_sub, uri, method, route, params, _0, *_1, _7, _2$$4, _3$$5, _4$$5, _5$$5, _9$$7, _10$$8, _11$$8, _12$$8; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&request_sub); + ZVAL_UNDEF(&uri); + ZVAL_UNDEF(&method); + ZVAL_UNDEF(&route); + ZVAL_UNDEF(¶ms); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_7); + ZVAL_UNDEF(&_2$$4); + ZVAL_UNDEF(&_3$$5); + ZVAL_UNDEF(&_4$$5); + ZVAL_UNDEF(&_5$$5); + ZVAL_UNDEF(&_9$$7); + ZVAL_UNDEF(&_10$$8); + ZVAL_UNDEF(&_11$$8); + ZVAL_UNDEF(&_12$$8); + static zend_string *_zephir_prop_0 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("routes", 6, 1); + } + + 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); + ZVAL_BOOL(&_0, 1); + ZEPHIR_CALL_METHOD(&uri, request, "geturi", NULL, 0, &_0); + zephir_check_call_status(); + 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_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) + { + ZEPHIR_INIT_NVAR(&route); + ZVAL_COPY(&route, _1); + ZEPHIR_CALL_METHOD(¶ms, &route, "matches", NULL, 0, &uri); + zephir_check_call_status(); + if (!ZEPHIR_IS_FALSE_IDENTICAL(¶ms)) { + ZEPHIR_CALL_METHOD(&_2$$4, &route, "allowsmethod", NULL, 0, &method); + zephir_check_call_status(); + if (zephir_is_true(&_2$$4)) { + object_init_ex(return_value, phalcon_adr_router_routermatch_ce); + ZEPHIR_CALL_METHOD(&_3$$5, &route, "getaction", NULL, 0); + zephir_check_call_status(); + ZEPHIR_CALL_METHOD(&_4$$5, &route, "getmiddleware", NULL, 0); + 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_check_call_status(); + RETURN_MM(); + } + methodMismatch = 1; + } + } ZEND_HASH_FOREACH_END(); + } else { + ZEPHIR_CALL_METHOD(NULL, &_0, "rewind", NULL, 0); + zephir_check_call_status(); + _8 = 1; + while (1) { + if (_8) { + _8 = 0; + } else { + ZEPHIR_CALL_METHOD(NULL, &_0, "next", NULL, 0); + zephir_check_call_status(); + } + ZEPHIR_CALL_METHOD(&_7, &_0, "valid", NULL, 0); + zephir_check_call_status(); + if (!zend_is_true(&_7)) { + break; + } + ZEPHIR_CALL_METHOD(&route, &_0, "current", NULL, 0); + zephir_check_call_status(); + ZEPHIR_CALL_METHOD(¶ms, &route, "matches", NULL, 0, &uri); + zephir_check_call_status(); + if (!ZEPHIR_IS_FALSE_IDENTICAL(¶ms)) { + ZEPHIR_CALL_METHOD(&_9$$7, &route, "allowsmethod", NULL, 0, &method); + zephir_check_call_status(); + if (zephir_is_true(&_9$$7)) { + object_init_ex(return_value, phalcon_adr_router_routermatch_ce); + ZEPHIR_CALL_METHOD(&_10$$8, &route, "getaction", NULL, 0); + zephir_check_call_status(); + ZEPHIR_CALL_METHOD(&_11$$8, &route, "getmiddleware", NULL, 0); + 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_check_call_status(); + RETURN_MM(); + } + methodMismatch = 1; + } + } + } + ZEPHIR_INIT_NVAR(&route); + if (methodMismatch) { + ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_adr_router_exceptions_methodnotallowed_ce, "The request method is not allowed for the matched route.", "phalcon/ADR/Router/Router.zep", 91); + return; + } + RETURN_MM_NULL(); +} + +PHP_METHOD(Phalcon_ADR_Router_Router, patch) +{ + zval _0; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval pattern_zv, actionClass_zv, _1; + zend_string *pattern = NULL, *actionClass = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&pattern_zv); + ZVAL_UNDEF(&actionClass_zv); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_0); + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(pattern) + Z_PARAM_STR(actionClass) + 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_memory_observe(&pattern_zv); + ZVAL_STR_COPY(&pattern_zv, pattern); + zephir_memory_observe(&actionClass_zv); + ZVAL_STR_COPY(&actionClass_zv, actionClass); + ZEPHIR_INIT_VAR(&_0); + zephir_create_array(&_0, 1, 0); + 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_check_call_status(); + RETURN_MM(); +} + +PHP_METHOD(Phalcon_ADR_Router_Router, post) +{ + zval _0; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval pattern_zv, actionClass_zv, _1; + zend_string *pattern = NULL, *actionClass = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&pattern_zv); + ZVAL_UNDEF(&actionClass_zv); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_0); + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(pattern) + Z_PARAM_STR(actionClass) + 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_memory_observe(&pattern_zv); + ZVAL_STR_COPY(&pattern_zv, pattern); + zephir_memory_observe(&actionClass_zv); + ZVAL_STR_COPY(&actionClass_zv, actionClass); + ZEPHIR_INIT_VAR(&_0); + zephir_create_array(&_0, 1, 0); + 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_check_call_status(); + RETURN_MM(); +} + +PHP_METHOD(Phalcon_ADR_Router_Router, put) +{ + zval _0; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval pattern_zv, actionClass_zv, _1; + zend_string *pattern = NULL, *actionClass = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&pattern_zv); + ZVAL_UNDEF(&actionClass_zv); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_0); + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(pattern) + Z_PARAM_STR(actionClass) + 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_memory_observe(&pattern_zv); + ZVAL_STR_COPY(&pattern_zv, pattern); + zephir_memory_observe(&actionClass_zv); + ZVAL_STR_COPY(&actionClass_zv, actionClass); + ZEPHIR_INIT_VAR(&_0); + zephir_create_array(&_0, 1, 0); + 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_check_call_status(); + RETURN_MM(); +} + +zend_object *zephir_init_properties_Phalcon_ADR_Router_Router(zend_class_entry *class_type) +{ + zval _0, _1$$3; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1$$3); + + + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + + { + zval local_this_ptr, *this_ptr = &local_this_ptr; + ZEPHIR_CREATE_OBJECT(this_ptr, class_type); + zephir_read_property_ex(&_0, this_ptr, ZEND_STRL("routes"), PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_0) == IS_NULL) { + ZEPHIR_INIT_VAR(&_1$$3); + array_init(&_1$$3); + zephir_update_property_zval_ex(this_ptr, ZEND_STRL("routes"), &_1$$3); + } + ZEPHIR_MM_RESTORE(); + return Z_OBJ_P(this_ptr); + } +} + diff --git a/ext/phalcon/adr/router/router.zep.h b/ext/phalcon/adr/router/router.zep.h new file mode 100644 index 0000000000..a456b52434 --- /dev/null +++ b/ext/phalcon/adr/router/router.zep.h @@ -0,0 +1,69 @@ + +extern zend_class_entry *phalcon_adr_router_router_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Router_Router); + +PHP_METHOD(Phalcon_ADR_Router_Router, add); +PHP_METHOD(Phalcon_ADR_Router_Router, delete); +PHP_METHOD(Phalcon_ADR_Router_Router, get); +PHP_METHOD(Phalcon_ADR_Router_Router, group); +PHP_METHOD(Phalcon_ADR_Router_Router, match); +PHP_METHOD(Phalcon_ADR_Router_Router, patch); +PHP_METHOD(Phalcon_ADR_Router_Router, post); +PHP_METHOD(Phalcon_ADR_Router_Router, put); +zend_object *zephir_init_properties_Phalcon_ADR_Router_Router(zend_class_entry *class_type); + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_router_router_add, 0, 2, Phalcon\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, methods, IS_ARRAY, 0, "[]") +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_router_router_delete, 0, 2, Phalcon\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_router_router_get, 0, 2, Phalcon\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_router_router_group, 0, 2, Phalcon\\ADR\\Router\\Group, 0) + ZEND_ARG_TYPE_INFO(0, prefix, IS_STRING, 0) + ZEND_ARG_OBJ_INFO(0, configure, Closure, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_router_router_match, 0, 1, Phalcon\\Contracts\\ADR\\Router\\RouterMatch, 1) + ZEND_ARG_OBJ_INFO(0, request, Phalcon\\Http\\RequestInterface, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_router_router_patch, 0, 2, Phalcon\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_router_router_post, 0, 2, Phalcon\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_adr_router_router_put, 0, 2, Phalcon\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_adr_router_router_zephir_init_properties_phalcon_adr_router_router, 0, 0, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_adr_router_router_method_entry) { + PHP_ME(Phalcon_ADR_Router_Router, add, arginfo_phalcon_adr_router_router_add, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Router, delete, arginfo_phalcon_adr_router_router_delete, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Router, get, arginfo_phalcon_adr_router_router_get, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Router, group, arginfo_phalcon_adr_router_router_group, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Router, match, arginfo_phalcon_adr_router_router_match, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Router, patch, arginfo_phalcon_adr_router_router_patch, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Router, post, arginfo_phalcon_adr_router_router_post, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Router, put, arginfo_phalcon_adr_router_router_put, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/phalcon/adr/router/routermatch.zep.c b/ext/phalcon/adr/router/routermatch.zep.c new file mode 100644 index 0000000000..7e2f3f6646 --- /dev/null +++ b/ext/phalcon/adr/router/routermatch.zep.c @@ -0,0 +1,154 @@ + +#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/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/ + */ +/** + * Immutable result of a successful route match. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Router_RouterMatch) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\ADR\\Router, RouterMatch, phalcon, adr_router_routermatch, phalcon_adr_router_routermatch_method_entry, ZEND_ACC_FINAL_CLASS); + + /** + * @var string + */ + zend_declare_property_null(phalcon_adr_router_routermatch_ce, SL("action"), ZEND_ACC_PROTECTED); + /** + * @var array + */ + zend_declare_property_null(phalcon_adr_router_routermatch_ce, SL("attributes"), ZEND_ACC_PROTECTED); + /** + * @var array + */ + zend_declare_property_null(phalcon_adr_router_routermatch_ce, SL("middleware"), ZEND_ACC_PROTECTED); + /** + * @var string|null + */ + zend_declare_property_null(phalcon_adr_router_routermatch_ce, SL("name"), ZEND_ACC_PROTECTED); + zend_class_implements(phalcon_adr_router_routermatch_ce, 1, phalcon_contracts_adr_router_routermatch_ce); + return SUCCESS; +} + +PHP_METHOD(Phalcon_ADR_Router_RouterMatch, __construct) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zval attributes, middleware; + zval action_zv, *attributes_param = NULL, *middleware_param = NULL, *name = NULL, name_sub, __$null; + zend_string *action = NULL; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&action_zv); + ZVAL_UNDEF(&name_sub); + ZVAL_NULL(&__$null); + ZVAL_UNDEF(&attributes); + ZVAL_UNDEF(&middleware); + 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("action", 6, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("attributes", 10, 1); + } + if (UNEXPECTED(!_zephir_prop_2)) { + _zephir_prop_2 = zend_string_init("middleware", 10, 1); + } + if (UNEXPECTED(!_zephir_prop_3)) { + _zephir_prop_3 = zend_string_init("name", 4, 1); + } + + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 4) + Z_PARAM_STR(action) + Z_PARAM_OPTIONAL + ZEPHIR_Z_PARAM_ARRAY(attributes, attributes_param) + ZEPHIR_Z_PARAM_ARRAY(middleware, middleware_param) + Z_PARAM_ZVAL_OR_NULL(name) + ZEND_PARSE_PARAMETERS_END(); + ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); + zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); + if (ZEND_NUM_ARGS() > 1) { + attributes_param = ZEND_CALL_ARG(execute_data, 2); + } + if (ZEND_NUM_ARGS() > 2) { + middleware_param = ZEND_CALL_ARG(execute_data, 3); + } + if (ZEND_NUM_ARGS() > 3) { + name = ZEND_CALL_ARG(execute_data, 4); + } + ZVAL_STR(&action_zv, action); + if (!attributes_param) { + ZEPHIR_INIT_VAR(&attributes); + array_init(&attributes); + } else { + zephir_get_arrval(&attributes, attributes_param); + } + if (!middleware_param) { + ZEPHIR_INIT_VAR(&middleware); + array_init(&middleware); + } else { + zephir_get_arrval(&middleware, middleware_param); + } + if (!name) { + 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_MM_RESTORE(); +} + +PHP_METHOD(Phalcon_ADR_Router_RouterMatch, getAction) +{ + + RETURN_MEMBER_TYPED(getThis(), "action", IS_STRING); +} + +PHP_METHOD(Phalcon_ADR_Router_RouterMatch, getAttributes) +{ + + RETURN_MEMBER_TYPED(getThis(), "attributes", IS_ARRAY); +} + +PHP_METHOD(Phalcon_ADR_Router_RouterMatch, getMiddleware) +{ + + RETURN_MEMBER_TYPED(getThis(), "middleware", IS_ARRAY); +} + +PHP_METHOD(Phalcon_ADR_Router_RouterMatch, getName) +{ + + RETURN_MEMBER(getThis(), "name"); +} + diff --git a/ext/phalcon/adr/router/routermatch.zep.h b/ext/phalcon/adr/router/routermatch.zep.h new file mode 100644 index 0000000000..50bdd4f38a --- /dev/null +++ b/ext/phalcon/adr/router/routermatch.zep.h @@ -0,0 +1,38 @@ + +extern zend_class_entry *phalcon_adr_router_routermatch_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Router_RouterMatch); + +PHP_METHOD(Phalcon_ADR_Router_RouterMatch, __construct); +PHP_METHOD(Phalcon_ADR_Router_RouterMatch, getAction); +PHP_METHOD(Phalcon_ADR_Router_RouterMatch, getAttributes); +PHP_METHOD(Phalcon_ADR_Router_RouterMatch, getMiddleware); +PHP_METHOD(Phalcon_ADR_Router_RouterMatch, getName); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_adr_router_routermatch___construct, 0, 0, 1) + ZEND_ARG_TYPE_INFO(0, action, IS_STRING, 0) +ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, attributes, IS_ARRAY, 0, "[]") +ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, middleware, IS_ARRAY, 0, "[]") + ZEND_ARG_INFO(0, name) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_router_routermatch_getaction, 0, 0, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_router_routermatch_getattributes, 0, 0, IS_ARRAY, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_router_routermatch_getmiddleware, 0, 0, IS_ARRAY, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_router_routermatch_getname, 0, 0, IS_STRING, 1) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_adr_router_routermatch_method_entry) { + PHP_ME(Phalcon_ADR_Router_RouterMatch, __construct, arginfo_phalcon_adr_router_routermatch___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) + PHP_ME(Phalcon_ADR_Router_RouterMatch, getAction, arginfo_phalcon_adr_router_routermatch_getaction, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_RouterMatch, getAttributes, arginfo_phalcon_adr_router_routermatch_getattributes, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_RouterMatch, getMiddleware, arginfo_phalcon_adr_router_routermatch_getmiddleware, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_RouterMatch, getName, arginfo_phalcon_adr_router_routermatch_getname, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/phalcon/adr/router/traits/hasmiddleware.zep.c b/ext/phalcon/adr/router/traits/hasmiddleware.zep.c new file mode 100644 index 0000000000..c2a5c960c6 --- /dev/null +++ b/ext/phalcon/adr/router/traits/hasmiddleware.zep.c @@ -0,0 +1,109 @@ + +#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/ + */ +/** + * Shared middleware accumulator for Route and Group: stores a list of middleware + * class names, appended to and read back as an array. + */ +ZEPHIR_INIT_CLASS(Phalcon_ADR_Router_Traits_HasMiddleware) +{ + ZEPHIR_REGISTER_TRAIT(Phalcon\\ADR\\Router\\Traits, HasMiddleware, phalcon, adr_router_traits_hasmiddleware, phalcon_adr_router_traits_hasmiddleware_method_entry); + + /** + * @var array + */ + { + zval _zc0; + array_init_size(&_zc0, 1); + zephir_declare_property_array(phalcon_adr_router_traits_hasmiddleware_ce, SL("middleware"), &_zc0, ZEND_ACC_PROTECTED); + } + + return SUCCESS; +} + +PHP_METHOD(Phalcon_ADR_Router_Traits_HasMiddleware, getMiddleware) +{ + + RETURN_MEMBER_TYPED(getThis(), "middleware", IS_ARRAY); +} + +PHP_METHOD(Phalcon_ADR_Router_Traits_HasMiddleware, pushMiddleware) +{ + zend_bool _2; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *classes_param = NULL, item, *_0, _1; + zval classes; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&classes); + ZVAL_UNDEF(&item); + ZVAL_UNDEF(&_1); + ZEND_PARSE_PARAMETERS_START(1, 1) + ZEPHIR_Z_PARAM_ARRAY(classes, classes_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, 1, 0, &classes_param); + zephir_get_arrval(&classes, classes_param); + zephir_is_iterable(&classes, 0, "phalcon/ADR/Router/Traits/HasMiddleware.zep", 39); + if (Z_TYPE_P(&classes) == IS_ARRAY) { + ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&classes), _0) + { + ZEPHIR_INIT_NVAR(&item); + ZVAL_COPY(&item, _0); + zephir_update_property_array_append(this_ptr, SL("middleware"), &item); + } ZEND_HASH_FOREACH_END(); + } else { + ZEPHIR_CALL_METHOD(NULL, &classes, "rewind", NULL, 0); + zephir_check_call_status(); + _2 = 1; + while (1) { + if (_2) { + _2 = 0; + } else { + ZEPHIR_CALL_METHOD(NULL, &classes, "next", NULL, 0); + zephir_check_call_status(); + } + ZEPHIR_CALL_METHOD(&_1, &classes, "valid", NULL, 0); + zephir_check_call_status(); + if (!zend_is_true(&_1)) { + break; + } + ZEPHIR_CALL_METHOD(&item, &classes, "current", NULL, 0); + zephir_check_call_status(); + zephir_update_property_array_append(this_ptr, SL("middleware"), &item); + } + } + ZEPHIR_INIT_NVAR(&item); + ZEPHIR_MM_RESTORE(); +} + diff --git a/ext/phalcon/adr/router/traits/hasmiddleware.zep.h b/ext/phalcon/adr/router/traits/hasmiddleware.zep.h new file mode 100644 index 0000000000..b831696196 --- /dev/null +++ b/ext/phalcon/adr/router/traits/hasmiddleware.zep.h @@ -0,0 +1,21 @@ + +extern zend_class_entry *phalcon_adr_router_traits_hasmiddleware_ce; + +ZEPHIR_INIT_CLASS(Phalcon_ADR_Router_Traits_HasMiddleware); + +PHP_METHOD(Phalcon_ADR_Router_Traits_HasMiddleware, getMiddleware); +PHP_METHOD(Phalcon_ADR_Router_Traits_HasMiddleware, pushMiddleware); + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_router_traits_hasmiddleware_getmiddleware, 0, 0, IS_ARRAY, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_adr_router_traits_hasmiddleware_pushmiddleware, 0, 1, IS_VOID, 0) + + ZEND_ARG_ARRAY_INFO(0, classes, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_adr_router_traits_hasmiddleware_method_entry) { + PHP_ME(Phalcon_ADR_Router_Traits_HasMiddleware, getMiddleware, arginfo_phalcon_adr_router_traits_hasmiddleware_getmiddleware, ZEND_ACC_PUBLIC) + PHP_ME(Phalcon_ADR_Router_Traits_HasMiddleware, pushMiddleware, arginfo_phalcon_adr_router_traits_hasmiddleware_pushmiddleware, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/phalcon/annotations/adapter/apcu.zep.c b/ext/phalcon/annotations/adapter/apcu.zep.c index 71d7489c04..42ee04fff0 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, 349, &prefix); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 376, &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, 350, &ttl); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 377, &ttl); } ZEPHIR_MM_RESTORE(); } @@ -132,7 +132,7 @@ 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, 349, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 376, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); ZEPHIR_CONCAT_SVV(&_2, "_PHAN", &_1, &key_zv); zephir_fast_strtolower(&_0, &_2); @@ -177,11 +177,11 @@ 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, 349, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 376, 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, 350, PH_NOISY_CC | PH_READONLY); + 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_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/annotations/adapter/memory.zep.c b/ext/phalcon/annotations/adapter/memory.zep.c index b4148464ee..e4ac78232b 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, 351, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 378, 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 4c38e1c8d2..10c52dc69a 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, 352, &annotationsDir); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 379, &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, 352, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 379, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "_"); @@ -165,7 +165,7 @@ PHP_METHOD(Phalcon_Annotations_Adapter_Stream, read) 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, 300); + ZEPHIR_CALL_METHOD(NULL, &_8$$5, "__construct", NULL, 314); 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, 352, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 379, 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, 301); + ZEPHIR_CALL_METHOD(NULL, &_5$$3, "__construct", NULL, 315); 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 b2f2e13465..cc4b0b96bd 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, 353, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 380, &_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, 354, &arguments); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 355, &exprArguments); + 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_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, 354, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 381, 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, 302, &_2$$8); + ZEPHIR_CALL_METHOD(&resolvedItem, this_ptr, "getexpression", &_3, 316, &_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, 302, &_6$$11); + ZEPHIR_CALL_METHOD(&resolvedItem, this_ptr, "getexpression", &_3, 316, &_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, 303, &expr); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 317, &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, 304, &type); + ZEPHIR_CALL_METHOD(NULL, &_7$$15, "__construct", NULL, 318, &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, 354, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 381, 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, 354, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 381, 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, 354, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 381, 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 24472bfbf1..e00d3dbbd4 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, 303, &annotationData); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", &_2, 317, &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, 303, &annotationData); + ZEPHIR_CALL_METHOD(NULL, &_5$$4, "__construct", &_2, 317, &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, 356, &annotations); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 383, &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, 356, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 383, 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, 356, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 357, PH_NOISY_CC | PH_READONLY); + 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); 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, 356, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 383, 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, 305, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_6, "__construct", NULL, 319, &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, 356, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 383, 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, 356, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 383, 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, 357, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 384, &_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, 356, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 357, PH_NOISY_CC | PH_READONLY); + 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); 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 c1c4f234c9..a297eb8852 100644 --- a/ext/phalcon/annotations/reader.zep.c +++ b/ext/phalcon/annotations/reader.zep.c @@ -108,13 +108,13 @@ PHP_METHOD(Phalcon_Annotations_Reader, parse) object_init_ex(&reflection, zephir_get_internal_ce(SL("reflectionclass"))); ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 233, &className_zv); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&comment, &reflection, "getdoccomment", NULL, 306); + ZEPHIR_CALL_METHOD(&comment, &reflection, "getdoccomment", NULL, 320); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&comment)) { ZEPHIR_INIT_VAR(&classAnnotations); - ZEPHIR_CALL_METHOD(&_0$$3, &reflection, "getfilename", NULL, 307); + ZEPHIR_CALL_METHOD(&_0$$3, &reflection, "getfilename", NULL, 321); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_1$$3, &reflection, "getstartline", NULL, 308); + ZEPHIR_CALL_METHOD(&_1$$3, &reflection, "getstartline", NULL, 322); 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, 309); + ZEPHIR_CALL_METHOD(&constants, &reflection, "getconstants", NULL, 323); 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, 310, &constant); + ZEPHIR_CALL_METHOD(&constantReflection, &reflection, "getreflectionconstant", &_3, 324, &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, 307); + ZEPHIR_CALL_METHOD(&_4$$7, &reflection, "getfilename", NULL, 321); 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, 311); + ZEPHIR_CALL_METHOD(&properties, &reflection, "getproperties", NULL, 325); 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, 307); + ZEPHIR_CALL_METHOD(&_7$$12, &reflection, "getfilename", NULL, 321); 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, 307); + ZEPHIR_CALL_METHOD(&_12$$15, &reflection, "getfilename", NULL, 321); 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, 312); + ZEPHIR_CALL_METHOD(&methods, &reflection, "getmethods", NULL, 326); 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 156ab55c70..73104d820e 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, 358, &reflectionData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 385, &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, 359, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 386, 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, 358, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 385, 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, 359, &_2$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 386, &_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, 358, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 385, 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, 358, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 385, 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, 358, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 385, 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 64dfda2d22..40b1569b43 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, 313, asset); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "addasset", NULL, 327, 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, 314, &_0, &path_zv, isLocal, &_1, &attributes, &version_zv, &_2); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processadd", NULL, 328, &_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, 313, code); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "addasset", NULL, 327, 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, 315, &_0, &content_zv, &_1, &attributes); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processaddinline", NULL, 329, &_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, 315, &_0, &content_zv, &_1, &attributes); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processaddinline", NULL, 329, &_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, 314, &_0, &path_zv, isLocal, &_1, &attributes, &version_zv, &_2); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processadd", NULL, 328, &_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, 360, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 387, 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, 360, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 387, 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, 361, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 388, 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, 360, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 387, 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, 362, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 389, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 362, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 389, &__$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, 363, &attributes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 390, &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, 364, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 391, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 364, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 391, &__$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, 365, &filters); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 392, &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, 366, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 393, &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, 367, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 394, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 367, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 394, &__$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, 368, &version_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 395, &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, 369, PH_NOISY_CC); - ZEPHIR_CALL_METHOD(&attrs, this_ptr, "processattributes", NULL, 316, &attributes); + 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_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, 316, &attributes); + ZEPHIR_CALL_METHOD(&attrs, this_ptr, "processattributes", NULL, 330, &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, 363, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 390, 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, 363, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 390, 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, 369, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 396, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 369, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 396, &__$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, 370, &sourcePath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 397, &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, 361, &targetPath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 388, &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, 371, &targetUri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 398, &targetUri_zv); RETURN_THISW(); } diff --git a/ext/phalcon/assets/manager.zep.c b/ext/phalcon/assets/manager.zep.c index beac126460..dd5b38a1b9 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, 372, tagFactory); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 373, &options); + 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_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, 317, &type_zv); + ZEPHIR_CALL_METHOD(&collection, this_ptr, "checkandcreatecollection", NULL, 331, &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, 318, &path_zv, &_1, &_2, &attributes, &version_zv, &_3); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 332, &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, 317, &type_zv); + ZEPHIR_CALL_METHOD(&collection, this_ptr, "checkandcreatecollection", NULL, 331, &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, 319, &content_zv, &_1, &attributes); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 333, &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, 320, &content_zv, &_1, &attributes); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 334, &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, 321, &path_zv, &_1, &_2, &attributes, &version_zv, &_3); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 335, &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, 317, &name_zv); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "checkandcreatecollection", NULL, 331, &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, 374, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 401, 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, 322, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 336, &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, 374, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 401, 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, 317, &_0); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "checkandcreatecollection", NULL, 331, &_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, 317, &_0); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "checkandcreatecollection", NULL, 331, &_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, 374, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 401, 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, 373, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 400, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "css"); @@ -1039,7 +1039,7 @@ 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, 323, &completeTargetPath); + ZEPHIR_CALL_METHOD(NULL, &_3$$9, "__construct", NULL, 337, &completeTargetPath); zephir_check_call_status(); zephir_throw_exception_debug(&_3$$9, "phalcon/Assets/Manager.zep", 467); ZEPHIR_MM_RESTORE(); @@ -1050,7 +1050,7 @@ PHP_METHOD(Phalcon_Assets_Manager, output) 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, 324, &completeTargetPath); + ZEPHIR_CALL_METHOD(NULL, &_5$$10, "__construct", NULL, 338, &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, 325, &sourcePath); + ZEPHIR_CALL_METHOD(NULL, &_8$$14, "__construct", &_9, 339, &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, 326, &_11$$15); + ZEPHIR_CALL_METHOD(NULL, &_10$$15, "__construct", &_12, 340, &_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, 327, &targetPath); + ZEPHIR_CALL_METHOD(NULL, &_14$$17, "__construct", &_15, 341, &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, 328, collection, &_20$$21, &_21$$21); + ZEPHIR_CALL_METHOD(&prefixedPath, this_ptr, "calculateprefixedpath", &_22, 342, 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, 329, &callback, &_23$$21, &prefixedPath, &_24$$21); + ZEPHIR_CALL_METHOD(&html, this_ptr, "docallback", &_25, 343, &callback, &_23$$21, &prefixedPath, &_24$$21); zephir_check_call_status(); - zephir_read_property_cached(&_26$$21, this_ptr, _zephir_prop_1, 375, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_26$$21, this_ptr, _zephir_prop_1, 402, 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, 330, &content, &filters, &mustFilter); + ZEPHIR_CALL_METHOD(&filteredContent, this_ptr, "applyfilters", &_27, 344, &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, 328, collection, &_31$$28, &_32$$28); + ZEPHIR_CALL_METHOD(&prefixedPath, this_ptr, "calculateprefixedpath", &_22, 342, 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, 329, &callback, &_33$$28, &prefixedPath, &_35$$28); + ZEPHIR_CALL_METHOD(&html, this_ptr, "docallback", &_25, 343, &callback, &_33$$28, &prefixedPath, &_35$$28); zephir_check_call_status(); - zephir_read_property_cached(&_35$$28, this_ptr, _zephir_prop_1, 375, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_35$$28, this_ptr, _zephir_prop_1, 402, 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, 325, &sourcePath); + ZEPHIR_CALL_METHOD(NULL, &_39$$34, "__construct", &_9, 339, &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, 326, &_41$$35); + ZEPHIR_CALL_METHOD(NULL, &_40$$35, "__construct", &_12, 340, &_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, 327, &targetPath); + ZEPHIR_CALL_METHOD(NULL, &_43$$37, "__construct", &_15, 341, &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, 328, collection, &_47$$41, &_48$$41); + ZEPHIR_CALL_METHOD(&prefixedPath, this_ptr, "calculateprefixedpath", &_22, 342, 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, 329, &callback, &_49$$41, &prefixedPath, &_50$$41); + ZEPHIR_CALL_METHOD(&html, this_ptr, "docallback", &_25, 343, &callback, &_49$$41, &prefixedPath, &_50$$41); zephir_check_call_status(); - zephir_read_property_cached(&_51$$41, this_ptr, _zephir_prop_1, 375, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_51$$41, this_ptr, _zephir_prop_1, 402, 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, 330, &content, &filters, &mustFilter); + ZEPHIR_CALL_METHOD(&filteredContent, this_ptr, "applyfilters", &_27, 344, &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, 328, collection, &_54$$48, &_55$$48); + ZEPHIR_CALL_METHOD(&prefixedPath, this_ptr, "calculateprefixedpath", &_22, 342, 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, 329, &callback, &_56$$48, &prefixedPath, &_57$$48); + ZEPHIR_CALL_METHOD(&html, this_ptr, "docallback", &_25, 343, &callback, &_56$$48, &prefixedPath, &_57$$48); zephir_check_call_status(); - zephir_read_property_cached(&_57$$48, this_ptr, _zephir_prop_1, 375, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_57$$48, this_ptr, _zephir_prop_1, 402, 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, 328, collection, &_59$$51, &completeTargetPath); + ZEPHIR_CALL_METHOD(&prefixedPath, this_ptr, "calculateprefixedpath", &_22, 342, 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, 329, &callback, &_60$$51, &prefixedPath, &_61$$51); + ZEPHIR_CALL_METHOD(&html, this_ptr, "docallback", &_25, 343, &callback, &_60$$51, &prefixedPath, &_61$$51); zephir_check_call_status(); - zephir_read_property_cached(&_62$$51, this_ptr, _zephir_prop_1, 375, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_62$$51, this_ptr, _zephir_prop_1, 402, 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, 330, &content, &filters, &_2$$4); + ZEPHIR_CALL_METHOD(&_1$$4, this_ptr, "applyfilters", &_3, 344, &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, 372, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$6, this_ptr, _zephir_prop_0, 399, 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, 330, &content, &filters, &_12$$7); + ZEPHIR_CALL_METHOD(&_11$$7, this_ptr, "applyfilters", &_3, 344, &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, 372, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$9, this_ptr, _zephir_prop_0, 399, 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, 372, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$10, this_ptr, _zephir_prop_0, 399, 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, 375, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$3, this_ptr, _zephir_prop_1, 402, 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, 373, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 400, &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, 375, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 402, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 375, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 402, &__$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, 331); + ZEPHIR_CALL_METHOD(NULL, &_2$$5, "__construct", &_3, 345); 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, 331); + ZEPHIR_CALL_METHOD(NULL, &_8$$7, "__construct", &_3, 345); 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, 374, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 401, 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, 374, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 401, 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, 332, parameters, &_0, &_1, &_2, &_3); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processparameters", NULL, 346, 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, 332, parameters, &_0, &_1, &_2, &_3); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processparameters", NULL, 346, 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, 376, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$11, this_ptr, _zephir_prop_0, 403, 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, 376, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$11, this_ptr, _zephir_prop_0, 403, 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, 376, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$12, this_ptr, _zephir_prop_0, 403, 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, 372, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20, this_ptr, _zephir_prop_1, 399, 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 7e90c1f0fb..14f1ed8462 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, 377, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 404, 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 82dcbf8638..0628b58aa5 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, 378, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 405, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 378, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 405, &__$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, 379, &sourcePath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 406, &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, 380, &targetPath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 407, &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, 381, &targetUri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 408, &targetUri_zv); RETURN_THISW(); } diff --git a/ext/phalcon/auth/access/accesslocator.zep.c b/ext/phalcon/auth/access/accesslocator.zep.c index 90d3058f10..ad7ee43aec 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, 382, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 409, 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 9d66930e99..61d0810d61 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, 383, acl); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 410, 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, 384, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 411, &_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, 385, &_1$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 412, &_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, 386, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 413, 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, 387, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 414, PH_NOISY_CC); _3 = !(ZEPHIR_IS_EMPTY(&_2)); if (_3) { - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 387, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 414, 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, 333); + ZEPHIR_CALL_METHOD(NULL, &_7$$5, "__construct", NULL, 347); 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, 385, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$6, this_ptr, _zephir_prop_2, 412, 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, 383, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_3, 410, 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, 334, &_1, &_2); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 348, &_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 0127361d06..290acb7683 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, 388, &users); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 415, &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 a60270a013..58105e0a64 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, 335, &_1$$3, &_2$$3, &_3$$3); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 349, &_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, 335, &_5$$4, &_6$$4); + ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 349, &_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, 389, &idColumn_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 416, &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 ba2e8dc893..6e3bd784a4 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, 335, &_1$$3, &_2$$3, &_3$$3); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 349, &_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, 390, &file_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 417, &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 70b033ea85..5fd5cf1ce4 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, 336, &_1, &_4); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 350, &_1, &_4); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 337, hasher, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 351, 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, 391, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 418, 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, 391, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 418, 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, 392, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 419, 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 2f2133427b..de408cf81f 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, 338, &_1, &_4); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 352, &_1, &_4); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 339, hasher, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 353, 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, 340, &_3); + ZEPHIR_CALL_FUNCTION(&_4, "random_bytes", NULL, 303, &_3); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&_5, "bin2hex", NULL, 341, &_4); + ZEPHIR_CALL_FUNCTION(&_5, "bin2hex", NULL, 304, &_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, 342, &_7); + ZEPHIR_CALL_METHOD(&found, this_ptr, "findfirstasauthuser", NULL, 354, &_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, 393, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 420, 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, 342, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "findfirstasauthuser", NULL, 354, &_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, 393, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 420, 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 5d209cd177..4d8e32ee70 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, 343, &_1, &_4); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 355, &_1, &_4); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 344, hasher, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 356, 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, 394, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 421, 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, 345, &path); + ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 357, &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, 346, &path); + ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", NULL, 358, &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, 347, &contents, &_5$$5); + ZEPHIR_CALL_METHOD(&data, &_4$$5, "__invoke", NULL, 359, &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, 348, &path, &ex); + ZEPHIR_CALL_METHOD(NULL, &_7$$6, "__construct", NULL, 360, &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, 349, &path); + ZEPHIR_CALL_METHOD(NULL, &_8$$7, "__construct", NULL, 361, &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 1cab21a819..153eeff3ec 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, 350); + ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 362); 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, 395, &data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 422, &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, 395, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 422, 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, 395, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 422, 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 571c6e8fd6..f21e799510 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, 335, &configName_zv, &configKey_zv, &suffix_zv); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 349, &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 a9c455e4e3..ea6603bd7d 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, 334, &type_zv, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 348, &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 4f09715e53..4994452307 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, 351, &_0, &suffix_zv); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "validatenonempty", NULL, 363, &_0, &suffix_zv); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "name"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "validatenonempty", NULL, 351, &_0, &name_zv); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "validatenonempty", NULL, 363, &_0, &name_zv); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "rememberName"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "validatenonempty", NULL, 351, &_0, &rememberName_zv); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "validatenonempty", NULL, 363, &_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, 352, &_0, &suffix_zv); + ZEPHIR_CALL_METHOD(&_1, this_ptr, "derive", NULL, 364, &_0, &suffix_zv); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 396, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 423, &_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, 352, &_0, &suffix_zv); + ZEPHIR_CALL_METHOD(&_2, this_ptr, "derive", NULL, 364, &_0, &suffix_zv); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 397, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 424, &_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, 398, &_3); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 396, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 397, PH_NOISY_CC | PH_READONLY); + 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); 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, 353); + ZEPHIR_CALL_METHOD(NULL, &_6$$3, "__construct", NULL, 365); 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, 335, &_1$$4, ¶m_zv); + ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 349, &_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 08eead3a39..97833c05f7 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, 335, &_1$$3, &_2$$3); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 349, &_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, 335, &_4$$4, &_5$$4); + ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", NULL, 349, &_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, 399, &inputKey_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 400, &storageKey_zv); + 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_MM_RESTORE(); } diff --git a/ext/phalcon/auth/guard/session.zep.c b/ext/phalcon/auth/guard/session.zep.c index 8cb54e61da..ab970651a4 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, 401, request); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 402, cookies); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 403, session); + 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); 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, 354); + ZEPHIR_CALL_METHOD(NULL, config, "__construct", NULL, 366); 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, 404, clock); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 431, 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, 354, &_0, &_2, &_3, &_4); + ZEPHIR_CALL_METHOD(NULL, &config, "__construct", NULL, 366, &_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, 355, adapter, &_5, &_9, &_10, &config); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 367, 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, 405, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 432, 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, 406, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 433, 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, 406, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 433, 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, 403, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 430, 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, 407, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 434, 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, 407, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 434, 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, 356); + ZEPHIR_CALL_METHOD(&token, &recaller, "gettoken", NULL, 368); 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, 402, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 429, 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, 402, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_0, 429, 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, 403, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 430, 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, 408, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 435, &__$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, 405, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 432, 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, 408, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 435, 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, 408, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 435, 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, 403, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 430, 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, 407, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_2, 434, 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, 408, &_5$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 435, &_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, 408, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 435, 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, 408, &fromRecaller); - zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_1, 403, PH_NOISY_CC | PH_READONLY); + 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_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, 407, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 434, 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, 405, &resolved); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 432, &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, 401, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 428, 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, 407, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 434, 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, 402, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 429, 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, 402, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 429, 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, 357, &raw); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 369, &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, 357, &raw); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 369, &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, 401, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 428, 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, 402, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 429, 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, 404, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 431, 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, 406, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_3, 433, 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, 407, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 434, 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, 358); + ZEPHIR_CALL_METHOD(&id, recaller, "getid", NULL, 370); zephir_check_call_status(); if (Z_TYPE_P(&id) == IS_NULL) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 407, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(&_2, recaller, "gettoken", NULL, 356); + 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_check_call_status(); - ZEPHIR_CALL_METHOD(&_3, recaller, "getuseragent", NULL, 359); + ZEPHIR_CALL_METHOD(&_3, recaller, "getuseragent", NULL, 371); 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, 409, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 436, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 409, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 436, &__$false); } RETURN_CCTOR(&resolved); } diff --git a/ext/phalcon/auth/guard/token.zep.c b/ext/phalcon/auth/guard/token.zep.c index 7622d05816..3530d39f7d 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, 410, request); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 437, 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, 360, &_5, &_6); + ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 372, &_5, &_6); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 361, adapter, &_0, &_1); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 373, 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, 410, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 411, PH_NOISY_CC | PH_READONLY); + 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_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, 410, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 437, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_7); ZVAL_STRING(&_7, "Authorization"); ZEPHIR_CALL_METHOD(&_6, &_3, "getheader", NULL, 0, &_7); @@ -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, 410, request); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 437, 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, 412, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 439, 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, 413, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 440, 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, 411, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 438, 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, 412, &found); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 439, &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, 411, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 438, 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, 413, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 440, 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, 411, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 438, 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 4eb894dc6e..5a5d21f410 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, 347, payload, &_2$$4); + ZEPHIR_CALL_METHOD(&data, &_1$$4, "__invoke", NULL, 359, 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, 414, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 441, &_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, 415, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 442, &_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, 416, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 443, &_10); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/auth/internal/containerresolver.zep.c b/ext/phalcon/auth/internal/containerresolver.zep.c index 9de19fbfc4..dd4c1307c2 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, 362, container, &name); + ZEPHIR_RETURN_CALL_SELF("resolveshared", &_2, 374, 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, 362, container, &name); + ZEPHIR_RETURN_CALL_SELF("resolveshared", &_2, 374, 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 119c3439f7..b15c9dc4ba 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, 363, &context_zv, &key_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 375, &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, 364, &context_zv, &key_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 376, &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 6fe900549f..aa0982858d 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, 417, accessFactory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 444, 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, 417, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 444, 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, 365, &accessName_zv); + ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 377, &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, 417, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 444, 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, 418, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 445, &_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, 417, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 444, 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, 417, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_0, 444, 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, 419, guard); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 446, guard); } RETURN_THISW(); } @@ -285,7 +285,7 @@ PHP_METHOD(Phalcon_Auth_Manager, attempt) remember = 0; } else { } - ZEPHIR_CALL_METHOD(&_0, this_ptr, "requirestatefulguard", NULL, 366); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "requirestatefulguard", NULL, 378); 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, 367); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "requireactiveaccess", NULL, 379); 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, 417, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 444, 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, 419, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 446, 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, 368); + ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 380); 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, 420, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 447, 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, 369, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_3$$5, "__construct", NULL, 381, &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, 420, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 447, 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, 366); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "requirestatefulguard", NULL, 378); 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, 367); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "requireactiveaccess", NULL, 379); 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, 418, access); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 445, 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, 419, guard); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 446, 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, 418, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 445, 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, 370); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 382); 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 e1b8f8fd22..b3977e04e2 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, 421, container); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 422, hasher); + 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_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, 371, container); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 383, container); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 423, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 450, &_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, 371, container); + ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 383, container); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 424, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 451, &_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, 371, container); + ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 383, container); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 425, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 452, &_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, 425, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(NULL, &manager, "__construct", NULL, 372, &_3); + 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_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, 423, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_1, 450, 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, 424, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$5, this_ptr, _zephir_prop_2, 451, 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, 373, &_19$$5, &guard, &_21$$5); + ZEPHIR_CALL_METHOD(NULL, &manager, "addguard", &_22, 385, &_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, 423, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$6, this_ptr, _zephir_prop_1, 450, 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, 424, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$6, this_ptr, _zephir_prop_2, 451, 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, 373, &_33$$6, &guard, &_35$$6); + ZEPHIR_CALL_METHOD(NULL, &manager, "addguard", &_22, 385, &_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, 374, &accessList); + ZEPHIR_CALL_METHOD(NULL, &manager, "addaccesslist", NULL, 386, &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, 375, &name); + ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 387, &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, 422, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 449, 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, 376, &type_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 388, &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, 421, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 448, 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 d919bd6f73..3a76f16a20 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, 426, &componentName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 453, &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, 426, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 453, 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/autoload/loader.zep.c b/ext/phalcon/autoload/loader.zep.c index d42eea9eab..ac6309057b 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, 427, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 454, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 427, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 454, &__$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, 377, directories, &dirSeparator, &name_zv); + ZEPHIR_CALL_METHOD(&_2, this_ptr, "checkdirectories", NULL, 389, directories, &dirSeparator, &name_zv); zephir_check_call_status(); ZEPHIR_CPY_WRT(directories, &_2); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 428, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 455, 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, 428, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 455, 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, 428, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 455, 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, 378, &_7); + ZEPHIR_CALL_FUNCTION(&_2, "array_unique", NULL, 390, &_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, 429, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 456, 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, 430, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 457, &_1$$3); } result = 1; - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 429, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 456, 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, 429, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 456, &_3); ZEPHIR_INIT_VAR(&_4); ZEPHIR_CONCAT_SV(&_4, "Loading: ", &className_zv); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 379, &_4); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 391, &_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, 380, &className_zv); + ZEPHIR_CALL_METHOD(&_6, this_ptr, "autoloadcheckclasses", NULL, 392, &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, 379, &_7$$4); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 391, &_7$$4); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_8$$4, this_ptr, "autoloadchecknamespaces", NULL, 381, &className_zv); + ZEPHIR_CALL_METHOD(&_8$$4, this_ptr, "autoloadchecknamespaces", NULL, 393, &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, 379, &_9$$5); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 391, &_9$$5); zephir_check_call_status(); - zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_2, 431, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_2, 458, PH_NOISY_CC | PH_READONLY); ZVAL_BOOL(&_12$$5, 1); - ZEPHIR_CALL_METHOD(&_10$$5, this_ptr, "autoloadcheckdirectories", NULL, 382, &_11$$5, &className_zv, &_12$$5); + ZEPHIR_CALL_METHOD(&_10$$5, this_ptr, "autoloadcheckdirectories", NULL, 394, &_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, 379, &_13$$6); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 391, &_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, 429, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 456, 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, 429, &_15); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 456, &_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, 432, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 459, 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, 433, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 460, 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, 383, &_1$$3, &__$true, &_3$$3); + ZEPHIR_CALL_FUNCTION(NULL, "spl_autoload_register", NULL, 395, &_1$$3, &__$true, &_3$$3); zephir_check_call_status(); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 433, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 460, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 433, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 460, &__$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, 434, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 461, &_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, 384, &directories, &_0, &_1, &_2); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addtocollection", NULL, 396, &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, 435, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 462, &_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, 436, method); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 463, 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, 436, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 463, &_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, 385); + ZEPHIR_CALL_METHOD(NULL, &_1$$5, "__construct", NULL, 397); 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, 384, &files, &_0, &_1, &_2); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addtocollection", NULL, 396, &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, 428, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 455, &_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, 433, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 460, 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, 386, &_1$$3); + ZEPHIR_CALL_FUNCTION(NULL, "spl_autoload_unregister", NULL, 398, &_1$$3); zephir_check_call_status(); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 433, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 460, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 433, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 460, &__$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, 436, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 463, 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, 437, &file_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 464, &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, 379, &_3$$3); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 391, &_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, 379, &_4); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 391, &_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, 427, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 454, 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, 434, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 461, 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, 434, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 461, 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, 379, &_4$$4); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", NULL, 391, &_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, 435, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 462, 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, 438, &filePath); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 465, &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, 379, &_8$$6); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 391, &_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, 438, &filePath); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 465, &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, 379, &_14$$9); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 391, &_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, 438, &filePath); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 465, &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, 379, &_21$$13); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 391, &_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, 438, &filePath); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 465, &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, 379, &_26$$16); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 391, &_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, 428, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 455, 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, 382, &directories, &fileName); + ZEPHIR_CALL_METHOD(&_5$$3, this_ptr, "autoloadcheckdirectories", &_6, 394, &directories, &fileName); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_5$$3)) { - zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_1, 438, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_1, 465, 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, 379, &_8$$5); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 391, &_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, 382, &directories, &fileName); + ZEPHIR_CALL_METHOD(&_13$$6, this_ptr, "autoloadcheckdirectories", &_6, 394, &directories, &fileName); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_13$$6)) { - zephir_read_property_cached(&_14$$8, this_ptr, _zephir_prop_1, 438, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$8, this_ptr, _zephir_prop_1, 465, 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, 379, &_15$$8); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "adddebug", &_9, 391, &_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, 387, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 399, &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/adapterfactory.zep.c b/ext/phalcon/cache/adapterfactory.zep.c index 6df82b20ec..897c90958a 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, 439, factory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 466, 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, 439, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 466, 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 5ced438d08..afca88ccbd 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, 440, factory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 467, 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, 440, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 467, 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, 388, &adapter); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 400, &adapter); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/cli/console.zep.c b/ext/phalcon/cli/console.zep.c index 2152921448..26010a99e9 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, 441, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 468, 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, 389); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 401); 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, 442, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 469, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_2) != IS_NULL) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 442, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 469, 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, 441, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 468, 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, 443, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 470, PH_NOISY_CC | PH_READONLY); _9 = zephir_is_true(&_10); } if (_9) { - zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_2, 443, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_2, 470, 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, 444, PH_NOISY_CC); + zephir_read_property_cached(&moduleName, this_ptr, _zephir_prop_3, 471, PH_NOISY_CC); } if (zephir_is_true(&moduleName)) { - zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_1, 442, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_1, 469, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_12$$9) != IS_NULL) { - zephir_read_property_cached(&_13$$10, this_ptr, _zephir_prop_1, 442, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$10, this_ptr, _zephir_prop_1, 469, 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, 390, &moduleName, &_18$$12); + ZEPHIR_CALL_METHOD(NULL, &_17$$12, "__construct", NULL, 402, &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, 391, &path); + ZEPHIR_CALL_METHOD(NULL, &_20$$16, "__construct", NULL, 403, &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, 441, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$13, this_ptr, _zephir_prop_0, 468, 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, 441, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$13, this_ptr, _zephir_prop_0, 468, 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, 441, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24$$13, this_ptr, _zephir_prop_0, 468, 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, 390, &moduleName, &_26$$19); + ZEPHIR_CALL_METHOD(NULL, &_25$$19, "__construct", NULL, 402, &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, 441, PH_NOISY_CC); + zephir_read_property_cached(&_28$$18, this_ptr, _zephir_prop_0, 468, 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, 442, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$9, this_ptr, _zephir_prop_1, 469, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_29$$9) != IS_NULL) { - zephir_read_property_cached(&_30$$20, this_ptr, _zephir_prop_1, 442, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_30$$20, this_ptr, _zephir_prop_1, 469, 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, 441, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_33, this_ptr, _zephir_prop_0, 468, 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, 445, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_36, this_ptr, _zephir_prop_4, 472, 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, 442, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_37, this_ptr, _zephir_prop_1, 469, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_37) != IS_NULL) { - zephir_read_property_cached(&_38$$22, this_ptr, _zephir_prop_1, 442, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_38$$22, this_ptr, _zephir_prop_1, 469, 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, 442, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_41, this_ptr, _zephir_prop_1, 469, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_41) != IS_NULL) { - zephir_read_property_cached(&_42$$24, this_ptr, _zephir_prop_1, 442, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_42$$24, this_ptr, _zephir_prop_1, 469, 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, 392, &arg, &_2$$5, &_3$$5); + ZEPHIR_CALL_FUNCTION(&_4$$5, "strncmp", &_5, 404, &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, 392, &arg, &_17$$9, &_18$$9); + ZEPHIR_CALL_FUNCTION(&_19$$9, "strncmp", &_5, 404, &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, 392, &arg, &_24$$14, &_25$$14); + ZEPHIR_CALL_FUNCTION(&_26$$14, "strncmp", &_5, 404, &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, 392, &arg, &_38$$18, &_39$$18); + ZEPHIR_CALL_FUNCTION(&_40$$18, "strncmp", &_5, 404, &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, 443, &_43$$22); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 470, &_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, 443, &handleArgs); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 470, &handleArgs); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 445, &opts); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 472, &opts); RETURN_THIS(); } diff --git a/ext/phalcon/cli/dispatcher.zep.c b/ext/phalcon/cli/dispatcher.zep.c index ff59baf7db..2edd7413f0 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, 446, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 473, 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, 446, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 473, 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, 447, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 474, 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, 446, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 473, 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, 448, &taskName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 475, &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, 446, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 473, &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, 449, &taskName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 476, &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, 450, &taskSuffix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 477, &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, 451, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 478, 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 c724a89e91..183d409e7f 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, 393, &_1$$3, &_0$$3); + ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 405, &_1$$3, &_0$$3); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_2$$3, &route, "getrouteid", NULL, 394); + ZEPHIR_CALL_METHOD(&_2$$3, &route, "getrouteid", NULL, 406); 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, 393, &_1$$3, &_3$$3); + ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 405, &_1$$3, &_3$$3); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_4$$3, &route, "getrouteid", NULL, 394); + ZEPHIR_CALL_METHOD(&_4$$3, &route, "getrouteid", NULL, 406); 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, 393, &pattern_zv, paths); + ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 405, &pattern_zv, paths); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_0, &route, "getrouteid", NULL, 394); + ZEPHIR_CALL_METHOD(&_0, &route, "getrouteid", NULL, 406); 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, 452, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 479, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, id)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 452, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 479, 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, 452, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 479, 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, 453, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 480, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 453, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 480, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 454, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 481, &__$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, 395, &_2$$4); + ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 407, &_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, 452, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 479, 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, 396, &_6$$10); + ZEPHIR_CALL_METHOD(NULL, &_5$$10, "__construct", &_7, 408, &_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, 455, &matches); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 482, &matches); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 454, &route); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 481, &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, 396, &_25$$30); + ZEPHIR_CALL_METHOD(NULL, &_24$$30, "__construct", &_7, 408, &_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, 455, &matches); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 482, &matches); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 454, &route); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 481, &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, 453, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 480, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 453, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 480, &__$false); } } else { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 453, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 480, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 453, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 480, &__$false); } - zephir_read_property_cached(&_40$$46, this_ptr, _zephir_prop_4, 456, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 457, &_40$$46); - zephir_read_property_cached(&_41$$46, this_ptr, _zephir_prop_6, 458, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 459, &_41$$46); - zephir_read_property_cached(&_42$$46, this_ptr, _zephir_prop_8, 460, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 461, &_42$$46); - zephir_read_property_cached(&_43$$46, this_ptr, _zephir_prop_10, 462, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 463, &_43$$46); + 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); 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, 456, PH_NOISY_CC); + zephir_read_property_cached(&moduleName, this_ptr, _zephir_prop_4, 483, 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, 458, PH_NOISY_CC); + zephir_read_property_cached(&taskName, this_ptr, _zephir_prop_6, 485, 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, 460, PH_NOISY_CC); + zephir_read_property_cached(&actionName, this_ptr, _zephir_prop_8, 487, 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, 457, &moduleName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 459, &taskName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 461, &actionName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 463, ¶ms); + 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); 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, 460, &actionName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 487, &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, 456, &moduleName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 483, &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, 456, &module); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 483, &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, 458, &task); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 485, &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, 460, &action); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 487, &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, 462, ¶ms); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 489, ¶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, 458, &taskName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 485, &taskName_zv); RETURN_THISW(); } diff --git a/ext/phalcon/cli/router/route.zep.c b/ext/phalcon/cli/router/route.zep.c index 6023ce8ead..5f8be8d0be 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, 464, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 491, &_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, 465, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 492, &_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, 466, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 396, &_1$$3); + 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_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, 467, callback); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 494, 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, 464, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 491, 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, 464, PH_NOISY_CC); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 491, 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, 464, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 491, 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, 464, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 491, 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, 464, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 491, 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, 464, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 491, 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, 464, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 491, 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, 464, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$3, this_ptr, _zephir_prop_0, 491, 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, 464, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$3, this_ptr, _zephir_prop_0, 491, 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, 464, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$3, this_ptr, _zephir_prop_0, 491, 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, 464, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$27, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_29$$27); ZEPHIR_CONCAT_SVS(&_29$$27, "([^", &_28$$27, "]*)"); zephir_concat_self(&route, &_29$$27); @@ -693,7 +693,7 @@ 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, 468, PH_NOISY_CC | PH_READONLY); + 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_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, 397, &pattern); + ZEPHIR_CALL_METHOD(NULL, &_2$$11, "__construct", NULL, 409, &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, 397, &pattern); + ZEPHIR_CALL_METHOD(NULL, &_4$$16, "__construct", NULL, 409, &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, 464, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$21, this_ptr, _zephir_prop_0, 491, 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, 466, &pattern); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 469, &compiledPattern); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 468, &routePaths); + 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_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, 470, &description_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 497, &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, 471, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 498, &name_zv); RETURN_THISW(); } diff --git a/ext/phalcon/config/adapter/grouped.zep.c b/ext/phalcon/config/adapter/grouped.zep.c index 2c2de42cea..fc763c6fe4 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, 398); + ZEPHIR_CALL_METHOD(NULL, &configFactory, "__construct", NULL, 410); 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, 399, &configName); + ZEPHIR_CALL_METHOD(&_5$$7, &configFactory, "load", &_6, 411, &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, 400); + ZEPHIR_CALL_METHOD(NULL, &_10$$10, "__construct", &_11, 412); 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, 472, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_0, 499, 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, 399, &configInstance); + ZEPHIR_CALL_METHOD(&_14$$11, &configFactory, "load", &_6, 411, &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, 399, &configName); + ZEPHIR_CALL_METHOD(&_19$$15, &configFactory, "load", &_6, 411, &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, 400); + ZEPHIR_CALL_METHOD(NULL, &_23$$18, "__construct", &_11, 412); 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, 472, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24$$17, this_ptr, _zephir_prop_0, 499, 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, 399, &configInstance); + ZEPHIR_CALL_METHOD(&_25$$19, &configFactory, "load", &_6, 411, &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 0e9360f08d..18fa0ade23 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, 401, &_3$$3); + ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 413, &_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, 402, &path, &castValue); + ZEPHIR_CALL_METHOD(&result, this_ptr, "parseinistring", NULL, 414, &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, 403, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &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, 403, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &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, 403, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &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, 404, &filename_zv, &_0, &_1); + ZEPHIR_RETURN_CALL_FUNCTION("parse_ini_file", NULL, 416, &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 74d1b795f1..298c3b2c0c 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, 401, &_1$$3); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 413, &_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, 347, &content, &_4); + ZEPHIR_CALL_METHOD(&_3, &_2, "__invoke", NULL, 359, &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 da114af30b..1d0c3462d3 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, 405, &filePath_zv); + ZEPHIR_CALL_FUNCTION(&_0, "is_file", NULL, 417, &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, 401, &_2$$3); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 413, &_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 5e68247883..cee1ff8917 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, 406); + ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 418); 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, 401, &_5$$7); + ZEPHIR_CALL_METHOD(NULL, &_4$$7, "__construct", NULL, 413, &_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, 407, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &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, 408, &filename_zv, &_0, &ndocs, &callbacks); + ZEPHIR_RETURN_CALL_FUNCTION("yaml_parse_file", NULL, 420, &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 cd40aa8f38..2b0b91be78 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, 409); + ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 421); 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, 410); + ZEPHIR_CALL_METHOD(NULL, &_5$$6, "__construct", NULL, 422); 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, 411, config); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkconfigarray", NULL, 423, 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 9cda044ab0..ca37af2329 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, 473, &fileName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 500, &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 8b7d9c4ae1..419bd30b7a 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, 474, &option_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 501, &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 bcbe27f245..1a7f9e974e 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, 475, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 502, &_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, 476, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 503, &_1); ZEPHIR_MM_RESTORE(); } @@ -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, 412, &name); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "resolvealias", NULL, 424, &name); zephir_check_call_status(); zephir_get_strval(&name, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 477, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 504, 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, 413, &name); + ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", NULL, 425, &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, 478, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 505, 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, 414, &name); + ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 426, &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, 478, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 505, 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, 412, &name); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "resolvealias", NULL, 424, &name); zephir_check_call_status(); zephir_get_strval(&name, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 479, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 506, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_1, &name)) { - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "resolveparameter", NULL, 415, &name); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "resolveparameter", NULL, 427, &name); zephir_check_call_status(); RETURN_MM(); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 477, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 504, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_2, &name)) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 477, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 504, 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, 416, &name, &_5); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "resolve", NULL, 428, &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, 480, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 507, 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, 481, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 508, 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, 478, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 505, 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, 414, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 426, &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, 478, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 505, 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, 477, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 504, 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, 417, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 429, &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, 477, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 504, 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, 479, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 506, 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, 418, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 430, &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, 415, &name_zv); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "resolveparameter", NULL, 427, &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, 419, &serviceName_zv); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 431, &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, 412, &name); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "resolvealias", NULL, 424, &name); zephir_check_call_status(); zephir_get_strval(&name, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 479, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 506, PH_NOISY_CC | PH_READONLY); _2 = zephir_array_key_exists(&_1, &name); if (!(_2)) { - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 477, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 504, 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, 478, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 505, 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, 482, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_3, 509, PH_NOISY_CC | PH_READONLY); _7 = zephir_is_true(&_6); if (_7) { - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_4, 475, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_4, 502, 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, 480, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 507, 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, 478, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 505, 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, 477, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 504, 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, 479, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 506, 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, 412, &name); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "resolvealias", NULL, 424, &name); zephir_check_call_status(); zephir_get_strval(&name, &_0); ZVAL_BOOL(&_1, 0); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "resolve", NULL, 416, &name, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "resolve", NULL, 428, &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, 420, &name_zv, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 432, &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, 421, definition); + ZEPHIR_CALL_METHOD(&processor, this_ptr, "findprocessor", NULL, 433, 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, 422, &alias_zv, &name_zv); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "detectcircularalias", NULL, 434, &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, 482, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 509, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 482, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 509, &__$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, 481, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 508, 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, 481, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 508, 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, 480, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 507, 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, 478, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 505, 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, 477, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 504, 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, 483, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 510, 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, 483, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 510, 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, 477, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_1, 504, 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, 483, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 510, 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, 477, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_1, 504, 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, 483, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$6, this_ptr, _zephir_prop_0, 510, 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, 479, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 506, 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, 423, &alias_zv); + ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", &_1, 435, &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, 480, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 507, 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, 480, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 507, 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, 476, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 503, 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, 424); + ZEPHIR_CALL_METHOD(NULL, &_6, "__construct", NULL, 436); 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, 478, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 505, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_key_exists(&_0, &name_zv))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 482, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 509, 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, 414, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_3$$5, "__construct", NULL, 426, &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, 478, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 505, 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, 480, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 507, 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, 423, &name_zv); + ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", &_2, 435, &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, 480, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 507, 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, 479, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 506, 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 4c60ca5f3c..d00c83c890 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, 425); + ZEPHIR_CALL_METHOD(NULL, &container, "__construct", NULL, 437); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 484, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 511, 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 bd9c575820..a74242e196 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, 420, &name_zv, &_0, definition); + ZEPHIR_CALL_METHOD(NULL, &def, "__construct", NULL, 432, &name_zv, &_0, definition); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &def, "setfactory", NULL, 426, definition); + ZEPHIR_CALL_METHOD(NULL, &def, "setfactory", NULL, 438, 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 d9b2ccb42f..df15bb9180 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, 420, &name_zv, &_0, definition); + ZEPHIR_CALL_METHOD(NULL, &def, "__construct", NULL, 432, &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, 426, &_0); + ZEPHIR_CALL_METHOD(NULL, &def, "setfactory", NULL, 438, &_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 932ccc1274..ef605bd558 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, 420, &name_zv, &_0, definition); + ZEPHIR_CALL_METHOD(NULL, &def, "__construct", NULL, 432, &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, 427, &_2); + ZEPHIR_CALL_METHOD(NULL, &def, "setiscacheable", NULL, 439, &_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 247d7f351b..484c3eaba8 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, 420, &name_zv, &_0, definition); + ZEPHIR_CALL_METHOD(NULL, &def, "__construct", NULL, 432, &name_zv, &_0, definition); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &def, "setclass", NULL, 428, definition); + ZEPHIR_CALL_METHOD(NULL, &def, "setclass", NULL, 440, definition); zephir_check_call_status(); ZVAL_BOOL(&_1, 1); - ZEPHIR_CALL_METHOD(NULL, &def, "setiscacheable", NULL, 427, &_1); + ZEPHIR_CALL_METHOD(NULL, &def, "setiscacheable", NULL, 439, &_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 32afa04651..2d3cfd2218 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, 485, &serviceName_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 486, &type_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 487, raw); + 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); } /** @@ -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, 488, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 515, 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, 489, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 516, PH_NOISY_CC | PH_READONLY); _3 = Z_TYPE_P(&_2) != IS_NULL; if (_3) { - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 489, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 516, 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, 489, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_2, 485, PH_NOISY_CC | PH_READONLY); + 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_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, 490, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 517, 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, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 518, 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, 491, PH_NOISY_CC); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 518, PH_NOISY_CC); } else { ZEPHIR_OBS_NVAR(&_2$$4); - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 485, PH_NOISY_CC); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 512, PH_NOISY_CC); } ZEPHIR_CPY_WRT(&className, &_2$$4); - zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_3, 492, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(&args, this_ptr, "resolveargs", NULL, 429, container, &_4$$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_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_check_call_status(); - ZEPHIR_CALL_METHOD(&instance, &reflection, "newinstanceargs", NULL, 430, &args); + ZEPHIR_CALL_METHOD(&instance, &reflection, "newinstanceargs", NULL, 442, &args); zephir_check_call_status(); } - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_4, 493, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_4, 520, 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, 494, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 521, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 486, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 513, 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, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_3, 518, 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, 491, PH_NOISY_CC); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_3, 518, PH_NOISY_CC); } else { ZEPHIR_OBS_NVAR(&_8$$4); - zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_4, 485, PH_NOISY_CC); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_4, 512, 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_check_call_status(); - ZEPHIR_CALL_METHOD(&constructor, &reflection, "getconstructor", NULL, 431); + ZEPHIR_CALL_METHOD(&constructor, &reflection, "getconstructor", NULL, 443); 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, 495, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_2, 522, 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, 492, &_11$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 519, &_11$$5); } } else { - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 486, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 513, 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, 495, PH_NOISY_CC); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 522, PH_NOISY_CC); _6 = !(ZEPHIR_IS_EMPTY(&_7)); } if (_6) { - zephir_read_property_cached(&_13$$6, this_ptr, _zephir_prop_2, 495, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 492, &_13$$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); } } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 494, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 521, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 494, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 521, &__$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, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 518, 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, 485, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 432, &_2$$3); + 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_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, 490, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 517, 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, 485, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 433, &_2$$3); + 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_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, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 518, 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, 493, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 520, 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, 490, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 517, 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, 496, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 523, PH_NOISY_CC | PH_READONLY); _1 = zephir_is_true(&_0); if (_1) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 494, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 521, 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, 489, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 516, 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, 491, &className_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 518, &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, 485, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_0, 512, PH_NOISY_CC | PH_READONLY); zephir_cast_to_string(&_5$$4, &key); - ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", &_6, 434, &_4$$4, &_5$$4); + ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", &_6, 446, &_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, 485, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$6, this_ptr, _zephir_prop_0, 512, PH_NOISY_CC | PH_READONLY); zephir_cast_to_string(&_11$$6, &key); - ZEPHIR_CALL_METHOD(NULL, &_9$$6, "__construct", &_6, 434, &_10$$6, &_11$$6); + ZEPHIR_CALL_METHOD(NULL, &_9$$6, "__construct", &_6, 446, &_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, 493, &extenders); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 520, &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, 490, factory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 517, 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, 496, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 523, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 496, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 523, &__$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, 497, &lifetime_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 524, &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, 491, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 518, &__$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, 493, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 520, &_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, 490, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 517, &__$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, 494, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 521, 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, 485, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 435, &_2$$3); + 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_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Container/Definition/ServiceDefinition.zep", 541); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/container/resolver/lazy/arrayvalues.zep.c b/ext/phalcon/container/resolver/lazy/arrayvalues.zep.c index 5e980b1e07..041a975328 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, 498, &values); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 525, &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, 498, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 525, 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, 498, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 525, 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, 498, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 525, 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, 498, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 525, 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, 498, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 525, 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, 498, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 525, 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 6460bacbe3..18d51ab275 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, 499, callableObject); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 526, 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, 499, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 526, 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 174b27adf9..c882b9756b 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, 500, id); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 527, id); } /** diff --git a/ext/phalcon/container/resolver/lazy/callablenew.zep.c b/ext/phalcon/container/resolver/lazy/callablenew.zep.c index c3f83e2542..f6cb9a6c7d 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, 501, id); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 528, id); } /** diff --git a/ext/phalcon/container/resolver/lazy/csenv.zep.c b/ext/phalcon/container/resolver/lazy/csenv.zep.c index 5bbfdeb4de..4b68910e4e 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, 436, &_0, &_1, &_2, &_3); + ZEPHIR_CALL_FUNCTION(&values, "str_getcsv", NULL, 448, &_0, &_1, &_2, &_3); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 502, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 529, 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, 502, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 529, 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, 502, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_0, 529, 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 65aeb17383..a156ed4f53 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, 503, defaultValue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 530, 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 af8023b66c..6713c55686 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, 504, &functionName_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 505, &arguments); + 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_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, 505, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 532, 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, 504, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 531, 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 d0a543ca38..4735c5fb6f 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, 506, id); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 533, 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, 506, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 533, 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 5ee46edfde..5488ae5cf3 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, 507, id); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 508, &method_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 509, &arguments); + 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_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, 507, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 534, 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, 509, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 536, 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, 508, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 535, 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 1c3cdfe6b7..c4862a6d27 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, 437, &values); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 449, &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, 438, callableObject); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 450, 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, 439, &id_zv); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 451, &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, 440, &id_zv); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 452, &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, 441, &name_zv, &type_zv); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 453, &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, 441, &name_zv, &type_zv); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 453, &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, 442, &name_zv, defaultValue, &type_zv); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 454, &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, 443, &functionName_zv, &args); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 455, &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, 444, &id_zv); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 456, &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, 445, &id_zv, &method_zv, &args); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 457, &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, 446, &id_zv, &method_zv, &args); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 458, &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, 447, &id_zv); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 459, &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, 448, &className_zv, &method_zv, &args); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 460, &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 c454ce2de7..7fcbd5e53c 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, 510, id); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 511, &method_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 512, &arguments); + 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_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, 510, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 537, 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, 512, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 539, 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, 511, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 538, 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 9b845398f5..2c65d5ada3 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, 513, id); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 540, 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, 513, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 540, 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 3f1387f8b3..7cb29fa277 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, 514, className); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 515, &method_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 516, &arguments); + 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_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, 514, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 541, 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, 516, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 543, 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, 515, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 542, 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 e1cdffe6a1..f91983929e 100644 --- a/ext/phalcon/container/resolver/resolver.zep.c +++ b/ext/phalcon/container/resolver/resolver.zep.c @@ -87,7 +87,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Resolver, isResolvableClass) object_init_ex(&_0, zephir_get_internal_ce(SL("reflectionclass"))); ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 233, &className_zv); zephir_check_call_status(); - ZEPHIR_RETURN_CALL_METHOD(&_0, "isinstantiable", NULL, 449); + ZEPHIR_RETURN_CALL_METHOD(&_0, "isinstantiable", NULL, 461); zephir_check_call_status(); RETURN_MM(); } @@ -190,12 +190,12 @@ PHP_METHOD(Phalcon_Container_Resolver_Resolver, resolveClass) object_init_ex(&reflection, zephir_get_internal_ce(SL("reflectionclass"))); ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 233, &className_zv); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&constructor, &reflection, "getconstructor", NULL, 431); + ZEPHIR_CALL_METHOD(&constructor, &reflection, "getconstructor", NULL, 443); 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, 430, &_0$$3); + ZEPHIR_RETURN_CALL_METHOD(&reflection, "newinstanceargs", NULL, 442, &_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, 430, &resolved); + ZEPHIR_RETURN_CALL_METHOD(&reflection, "newinstanceargs", NULL, 442, &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, 450, &_7, &declaringName); + ZEPHIR_CALL_METHOD(NULL, &_6, "__construct", NULL, 462, &_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, 451, ioc, &_4$$4); + ZEPHIR_CALL_METHOD(&_3$$4, this_ptr, "resolvearg", &_5, 463, 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, 451, ioc, &_7$$5); + ZEPHIR_CALL_METHOD(&_6$$5, this_ptr, "resolvearg", &_5, 463, 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, 451, ioc, &_13$$7); + ZEPHIR_CALL_METHOD(&_12$$7, this_ptr, "resolvearg", &_5, 463, 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, 451, ioc, &_15$$8); + ZEPHIR_CALL_METHOD(&_14$$8, this_ptr, "resolvearg", &_5, 463, 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/dispatcher.zep.c b/ext/phalcon/contracts/adr/dispatcher.zep.c new file mode 100644 index 0000000000..f8a9f24a7a --- /dev/null +++ b/ext/phalcon/contracts/adr/dispatcher.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/ + */ +/** + * Resolves an Action by class name, builds the middleware pipeline around it and + * runs it to produce a response. + */ +ZEPHIR_INIT_CLASS(Phalcon_Contracts_ADR_Dispatcher) +{ + ZEPHIR_REGISTER_INTERFACE(Phalcon\\Contracts\\ADR, Dispatcher, phalcon, contracts_adr_dispatcher, phalcon_contracts_adr_dispatcher_method_entry); + + return SUCCESS; +} + +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Dispatcher, dispatch); diff --git a/ext/phalcon/contracts/adr/dispatcher.zep.h b/ext/phalcon/contracts/adr/dispatcher.zep.h new file mode 100644 index 0000000000..adca1a1b83 --- /dev/null +++ b/ext/phalcon/contracts/adr/dispatcher.zep.h @@ -0,0 +1,15 @@ + +extern zend_class_entry *phalcon_contracts_adr_dispatcher_ce; + +ZEPHIR_INIT_CLASS(Phalcon_Contracts_ADR_Dispatcher); + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_contracts_adr_dispatcher_dispatch, 0, 2, Phalcon\\Http\\ResponseInterface, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) + ZEND_ARG_OBJ_INFO(0, request, Phalcon\\Contracts\\Http\\AttributeRequestInterface, 0) +ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, routeMiddleware, IS_ARRAY, 0, "[]") +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_contracts_adr_dispatcher_method_entry) { + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Dispatcher, dispatch, arginfo_phalcon_contracts_adr_dispatcher_dispatch) + PHP_FE_END +}; diff --git a/ext/phalcon/contracts/adr/router/group.zep.c b/ext/phalcon/contracts/adr/router/group.zep.c new file mode 100644 index 0000000000..330807bd70 --- /dev/null +++ b/ext/phalcon/contracts/adr/router/group.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/ + */ +/** + * A group of routes sharing a path prefix and middleware. Group middleware is + * flattened onto each route as it is registered. + */ +ZEPHIR_INIT_CLASS(Phalcon_Contracts_ADR_Router_Group) +{ + ZEPHIR_REGISTER_INTERFACE(Phalcon\\Contracts\\ADR\\Router, Group, phalcon, contracts_adr_router_group, phalcon_contracts_adr_router_group_method_entry); + + return SUCCESS; +} + +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Router_Group, withMiddleware); diff --git a/ext/phalcon/contracts/adr/router/group.zep.h b/ext/phalcon/contracts/adr/router/group.zep.h new file mode 100644 index 0000000000..66ba8217d0 --- /dev/null +++ b/ext/phalcon/contracts/adr/router/group.zep.h @@ -0,0 +1,13 @@ + +extern zend_class_entry *phalcon_contracts_adr_router_group_ce; + +ZEPHIR_INIT_CLASS(Phalcon_Contracts_ADR_Router_Group); + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_contracts_adr_router_group_withmiddleware, 0, 0, Phalcon\\Contracts\\ADR\\Router\\Group, 0) + ZEND_ARG_VARIADIC_TYPE_INFO(0, classes, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_contracts_adr_router_group_method_entry) { + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Router_Group, withMiddleware, arginfo_phalcon_contracts_adr_router_group_withmiddleware) + PHP_FE_END +}; diff --git a/ext/phalcon/contracts/adr/router/route.zep.c b/ext/phalcon/contracts/adr/router/route.zep.c new file mode 100644 index 0000000000..fc5e7490ef --- /dev/null +++ b/ext/phalcon/contracts/adr/router/route.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 "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/ + */ +/** + * A registered route. Fluent, mutating configuration returned from the router's + * registration methods. + */ +ZEPHIR_INIT_CLASS(Phalcon_Contracts_ADR_Router_Route) +{ + ZEPHIR_REGISTER_INTERFACE(Phalcon\\Contracts\\ADR\\Router, Route, phalcon, contracts_adr_router_route, phalcon_contracts_adr_router_route_method_entry); + + return SUCCESS; +} + +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Router_Route, withMiddleware); +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Router_Route, withName); diff --git a/ext/phalcon/contracts/adr/router/route.zep.h b/ext/phalcon/contracts/adr/router/route.zep.h new file mode 100644 index 0000000000..7df5e46725 --- /dev/null +++ b/ext/phalcon/contracts/adr/router/route.zep.h @@ -0,0 +1,18 @@ + +extern zend_class_entry *phalcon_contracts_adr_router_route_ce; + +ZEPHIR_INIT_CLASS(Phalcon_Contracts_ADR_Router_Route); + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_contracts_adr_router_route_withmiddleware, 0, 0, Phalcon\\Contracts\\ADR\\Router\\Route, 0) + ZEND_ARG_VARIADIC_TYPE_INFO(0, classes, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_contracts_adr_router_route_withname, 0, 1, Phalcon\\Contracts\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_contracts_adr_router_route_method_entry) { + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Router_Route, withMiddleware, arginfo_phalcon_contracts_adr_router_route_withmiddleware) + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Router_Route, withName, arginfo_phalcon_contracts_adr_router_route_withname) + PHP_FE_END +}; diff --git a/ext/phalcon/contracts/adr/router/router.zep.c b/ext/phalcon/contracts/adr/router/router.zep.c new file mode 100644 index 0000000000..e080a04f5e --- /dev/null +++ b/ext/phalcon/contracts/adr/router/router.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 "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/ + */ +/** + * Maps a request to an Action. Routes are registered by pattern and HTTP method + * and matched against the incoming request. + */ +ZEPHIR_INIT_CLASS(Phalcon_Contracts_ADR_Router_Router) +{ + ZEPHIR_REGISTER_INTERFACE(Phalcon\\Contracts\\ADR\\Router, Router, phalcon, contracts_adr_router_router, phalcon_contracts_adr_router_router_method_entry); + + return SUCCESS; +} + +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Router_Router, add); +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Router_Router, delete); +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Router_Router, get); +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Router_Router, group); +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Router_Router, match); +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Router_Router, patch); +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Router_Router, post); +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Router_Router, put); diff --git a/ext/phalcon/contracts/adr/router/router.zep.h b/ext/phalcon/contracts/adr/router/router.zep.h new file mode 100644 index 0000000000..15fae3b05f --- /dev/null +++ b/ext/phalcon/contracts/adr/router/router.zep.h @@ -0,0 +1,56 @@ + +extern zend_class_entry *phalcon_contracts_adr_router_router_ce; + +ZEPHIR_INIT_CLASS(Phalcon_Contracts_ADR_Router_Router); + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_contracts_adr_router_router_add, 0, 2, Phalcon\\Contracts\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, methods, IS_ARRAY, 0, "[]") +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_contracts_adr_router_router_delete, 0, 2, Phalcon\\Contracts\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_contracts_adr_router_router_get, 0, 2, Phalcon\\Contracts\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_contracts_adr_router_router_group, 0, 2, Phalcon\\Contracts\\ADR\\Router\\Group, 0) + ZEND_ARG_TYPE_INFO(0, prefix, IS_STRING, 0) + ZEND_ARG_OBJ_INFO(0, configure, Closure, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_contracts_adr_router_router_match, 0, 1, Phalcon\\Contracts\\ADR\\Router\\RouterMatch, 1) + ZEND_ARG_OBJ_INFO(0, request, Phalcon\\Http\\RequestInterface, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_contracts_adr_router_router_patch, 0, 2, Phalcon\\Contracts\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_contracts_adr_router_router_post, 0, 2, Phalcon\\Contracts\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_contracts_adr_router_router_put, 0, 2, Phalcon\\Contracts\\ADR\\Router\\Route, 0) + ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, actionClass, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_contracts_adr_router_router_method_entry) { + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Router_Router, add, arginfo_phalcon_contracts_adr_router_router_add) + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Router_Router, delete, arginfo_phalcon_contracts_adr_router_router_delete) + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Router_Router, get, arginfo_phalcon_contracts_adr_router_router_get) + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Router_Router, group, arginfo_phalcon_contracts_adr_router_router_group) + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Router_Router, match, arginfo_phalcon_contracts_adr_router_router_match) + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Router_Router, patch, arginfo_phalcon_contracts_adr_router_router_patch) + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Router_Router, post, arginfo_phalcon_contracts_adr_router_router_post) + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Router_Router, put, arginfo_phalcon_contracts_adr_router_router_put) + PHP_FE_END +}; diff --git a/ext/phalcon/contracts/adr/router/routermatch.zep.c b/ext/phalcon/contracts/adr/router/routermatch.zep.c new file mode 100644 index 0000000000..73ea94a88b --- /dev/null +++ b/ext/phalcon/contracts/adr/router/routermatch.zep.c @@ -0,0 +1,40 @@ + +#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/ + */ +/** + * The result of matching a request against the router: the Action class, the + * extracted route attributes, the route's middleware and its optional name. + */ +ZEPHIR_INIT_CLASS(Phalcon_Contracts_ADR_Router_RouterMatch) +{ + ZEPHIR_REGISTER_INTERFACE(Phalcon\\Contracts\\ADR\\Router, RouterMatch, phalcon, contracts_adr_router_routermatch, phalcon_contracts_adr_router_routermatch_method_entry); + + return SUCCESS; +} + +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Router_RouterMatch, getAction); +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Router_RouterMatch, getAttributes); +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Router_RouterMatch, getMiddleware); +ZEPHIR_DOC_METHOD(Phalcon_Contracts_ADR_Router_RouterMatch, getName); diff --git a/ext/phalcon/contracts/adr/router/routermatch.zep.h b/ext/phalcon/contracts/adr/router/routermatch.zep.h new file mode 100644 index 0000000000..1c61e769e1 --- /dev/null +++ b/ext/phalcon/contracts/adr/router/routermatch.zep.h @@ -0,0 +1,24 @@ + +extern zend_class_entry *phalcon_contracts_adr_router_routermatch_ce; + +ZEPHIR_INIT_CLASS(Phalcon_Contracts_ADR_Router_RouterMatch); + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_contracts_adr_router_routermatch_getaction, 0, 0, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_contracts_adr_router_routermatch_getattributes, 0, 0, IS_ARRAY, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_contracts_adr_router_routermatch_getmiddleware, 0, 0, IS_ARRAY, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_contracts_adr_router_routermatch_getname, 0, 0, IS_STRING, 1) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_contracts_adr_router_routermatch_method_entry) { + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Router_RouterMatch, getAction, arginfo_phalcon_contracts_adr_router_routermatch_getaction) + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Router_RouterMatch, getAttributes, arginfo_phalcon_contracts_adr_router_routermatch_getattributes) + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Router_RouterMatch, getMiddleware, arginfo_phalcon_contracts_adr_router_routermatch_getmiddleware) + PHP_ABSTRACT_ME(Phalcon_Contracts_ADR_Router_RouterMatch, getName, arginfo_phalcon_contracts_adr_router_routermatch_getname) + PHP_FE_END +}; diff --git a/ext/phalcon/datamapper/pdo/connection.zep.c b/ext/phalcon/datamapper/pdo/connection.zep.c index e0ae7faf2c..5fcb60644d 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, 452, &_2$$3); + ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 464, &_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, 517, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 544, &_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, 453); + ZEPHIR_CALL_METHOD(NULL, profiler, "__construct", NULL, 465); 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, 517, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 544, 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, 517, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 544, 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, 517, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 544, 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, 518, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 545, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 519, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 546, 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, 517, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 544, 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, 517, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 544, 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, 517, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 544, 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, 517, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_2, 544, 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, 517, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_2, 544, 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, 518, &_2$$3); - zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_1, 519, PH_NOISY_CC | PH_READONLY); + 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_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, 519, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 546, 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, 518, &__$null); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 519, PH_NOISY_CC | PH_READONLY); + 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_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 4bc2215f87..043540e13d 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, 520, pdo); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 547, 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, 453); + ZEPHIR_CALL_METHOD(NULL, profiler, "__construct", NULL, 465); 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 627d1f0f58..7feb60c376 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, 521, callableObject); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 548, 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, 522, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 549, 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, 454, &collection); + ZEPHIR_CALL_FUNCTION(&requested, "array_rand", NULL, 466, &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, 522, &instances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 549, &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 bc65fc5840..16076192a6 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, 523, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 550, &_0); ZVAL_UNDEF(&_1); ZVAL_LONG(&_1, 7); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 524, &_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 525, logger); + 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_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, 526, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 553, &_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, 527, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 554, 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, 455, &__$true); + ZEPHIR_CALL_FUNCTION(&finish, "hrtime", NULL, 467, &__$true); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_1$$3, &ex, "gettraceasstring", NULL, 456); + ZEPHIR_CALL_METHOD(&_1$$3, &ex, "gettraceasstring", NULL, 468); 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, 528, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_1, 555, 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, 526, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_2, 553, 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, 525, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_12$$3, this_ptr, _zephir_prop_4, 524, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_13$$3, this_ptr, _zephir_prop_5, 523, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_14$$3, this_ptr, _zephir_prop_1, 528, PH_NOISY_CC | PH_READONLY); + 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_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, 528, &_15$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 555, &_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, 524, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 551, 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, 527, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 554, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 527, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 554, &__$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, 523, &logFormat_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 550, &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, 524, &logLevel_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 551, &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, 527, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 554, 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, 455, &__$true); + ZEPHIR_CALL_FUNCTION(&_2$$3, "hrtime", NULL, 467, &__$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, 528, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 555, &_1$$3); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/datamapper/query/bind.zep.c b/ext/phalcon/datamapper/query/bind.zep.c index ee13e5bf04..1d64c98bf7 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, 529, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 556, 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, 529, &_4); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 529, PH_NOISY_CC | PH_READONLY); + 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_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, 530, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 557, 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, 530, &store); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 557, &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, 529, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 556, 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, 529, &_2$$3); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 529, PH_NOISY_CC | PH_READONLY); + 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_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, 529, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_0, 556, 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, 529, &_9$$4); - zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 529, PH_NOISY_CC | PH_READONLY); + 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_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 acbbe8fb85..7bd66d16db 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, 531, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 558, 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, 531, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 558, 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 0a480b97d3..a0afaeafd2 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, 532, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 559, 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, 533, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 560, 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, 534, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 561, 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, 457); + ZEPHIR_CALL_METHOD(&_3, this_ptr, "buildcolumns", NULL, 469); 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, 534, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 561, 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, 532, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 559, 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, 534, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 561, 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, 534, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15, this_ptr, _zephir_prop_0, 561, 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 079c038926..5cd7c9e62f 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, 535, &selectClass); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 562, &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, 458, connection, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 470, 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, 459, connection, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 471, 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, 535, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 562, 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, 460, connection, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 472, 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 6f6ee23d93..1be9bf37f8 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, 536, PH_NOISY_CC); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 563, 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, 461, &method_zv); + ZEPHIR_CALL_METHOD(NULL, &_5, "__construct", NULL, 473, &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, 537, &asAlias_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 564, &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, 538, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 565, 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, 539, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 566, 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, 539, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 566, 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, 539, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 566, 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, 539, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 566, 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, 540, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 567, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 540, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 567, &__$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, 539, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 566, 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, 539, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 566, 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, 538, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$5, this_ptr, _zephir_prop_0, 565, 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, 539, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19, this_ptr, _zephir_prop_1, 566, 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, 537, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 564, &_0); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 540, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 567, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 540, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 567, &__$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, 536, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 538, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 462, &_0, &_1); + 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_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, 540, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 567, 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, 463); + ZEPHIR_CALL_METHOD(&_3, this_ptr, "buildcolumns", NULL, 475); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_4, this_ptr, "buildfrom", NULL, 464); + ZEPHIR_CALL_METHOD(&_4, this_ptr, "buildfrom", NULL, 476); 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, 537, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11, this_ptr, _zephir_prop_1, 564, 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, 537, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 564, 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, 539, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 566, 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, 539, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 566, 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, 539, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 566, 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 85e6962894..ef41f05d6d 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, 541, 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(); @@ -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, 542, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 569, 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, 465); + ZEPHIR_CALL_METHOD(&_3, this_ptr, "buildcolumns", NULL, 477); 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, 542, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 569, 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, 542, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 569, 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, 541, 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(); @@ -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, 542, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 569, 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 0e7e0f372a..a9d8e42943 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, 543, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 570, 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, 466); + ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 478); 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, 543, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 570, 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, 543, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 570, 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, 467, &columnName, &definition); + ZEPHIR_CALL_METHOD(NULL, &_71$$3, "__construct", &_72, 479, &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, 467, &columnName, &definition); + ZEPHIR_CALL_METHOD(NULL, &_143$$62, "__construct", &_72, 479, &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, 543, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 570, 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, 543, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 570, 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 b309559746..15e1c3a5e7 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, 544, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 571, 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, 545, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 572, 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, 545, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 572, 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, 467, &columnName, &definition); + ZEPHIR_CALL_METHOD(NULL, &_73$$3, "__construct", &_74, 479, &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, 467, &columnName, &definition); + ZEPHIR_CALL_METHOD(NULL, &_145$$57, "__construct", &_74, 479, &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, 545, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 572, 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, 545, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 572, 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 0c065cd58a..e30b2b0eae 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, 546, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 573, 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, 468); + ZEPHIR_CALL_METHOD(NULL, &_1$$5, "__construct", NULL, 480); 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, 547, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 574, 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, 467, &columnName, &definition); + ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", &_46, 479, &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, 467, &columnName, &definition); + ZEPHIR_CALL_METHOD(NULL, &_50$$32, "__construct", &_46, 479, &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, 547, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 574, 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, 547, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 574, 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, 547, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 574, 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, 547, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_31$$13, this_ptr, _zephir_prop_0, 574, 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, 547, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_33$$13, this_ptr, _zephir_prop_0, 574, 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, 547, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 574, 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 c6e5715850..0c6c60d5c8 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, 469); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 481); 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, 470); + ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 482); 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, 548, &name_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 549, &expression); + 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_MM_RESTORE(); } diff --git a/ext/phalcon/db/column.zep.c b/ext/phalcon/db/column.zep.c index e5a23fb980..faa310164d 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, 550, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 577, &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, 471); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 483); 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, 551, &type); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 578, &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, 552, &typeReference); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 579, &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, 553, &typeValues); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 580, &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, 554, ¬Null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 581, ¬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, 555, &primary); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 582, &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, 556, &size); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 583, &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, 557, &scale); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 584, &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, 472); + ZEPHIR_CALL_METHOD(NULL, &_1$$11, "__construct", NULL, 484); 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, 558, &defaultValue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 585, &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, 559, &dunsigned); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 586, &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, 560, &isNumeric); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 587, &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, 561, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 588, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 561, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 588, &__$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, 561, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 588, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 561, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 588, &__$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, 473); + ZEPHIR_CALL_METHOD(NULL, &_2$$19, "__construct", NULL, 485); 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, 562, &first); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_12, 589, &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, 563, &after); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 590, &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, 564, &bindType); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_14, 591, &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, 565, &comment); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_15, 592, &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, 474); + ZEPHIR_CALL_METHOD(NULL, &_3$$26, "__construct", NULL, 486); 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, 561, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$25, this_ptr, _zephir_prop_11, 588, 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, 475); + ZEPHIR_CALL_METHOD(NULL, &_5$$27, "__construct", NULL, 487); 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, 558, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$25, this_ptr, _zephir_prop_8, 585, 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, 476); + ZEPHIR_CALL_METHOD(NULL, &_7$$28, "__construct", NULL, 488); 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, 566, &generated); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_16, 593, &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, 567, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 594, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 567, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 594, &__$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, 568, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_18, 595, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_18, 568, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_18, 595, &__$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, 569, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 596, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 569, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 596, &__$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, 558, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 585, 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, 566, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 593, 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 4bce840a1a..964f845d67 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, 477, &defaultValue, &_17$$11); + ZEPHIR_CALL_FUNCTION(&_18$$11, "addcslashes", NULL, 489, &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, 477, &defaultValue, &_21$$16); + ZEPHIR_CALL_FUNCTION(&_22$$16, "addcslashes", &_23, 489, &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, 477, &defaultValue, &_47$$29); + ZEPHIR_CALL_FUNCTION(&_48$$29, "addcslashes", &_23, 489, &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, 478, column); + ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "checkcolumnunsigned", NULL, 490, 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, 478, column); + ZEPHIR_CALL_METHOD(&_8$$18, this_ptr, "checkcolumnunsigned", NULL, 490, 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, 479, column); + ZEPHIR_CALL_METHOD(&_10$$20, this_ptr, "checkcolumnsizeandscale", NULL, 491, column); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_11$$20, this_ptr, "checkcolumnunsigned", NULL, 478, column); + ZEPHIR_CALL_METHOD(&_11$$20, this_ptr, "checkcolumnunsigned", NULL, 490, 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, 479, column); + ZEPHIR_CALL_METHOD(&_14$$24, this_ptr, "checkcolumnsizeandscale", NULL, 491, column); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_15$$24, this_ptr, "checkcolumnunsigned", NULL, 478, column); + ZEPHIR_CALL_METHOD(&_15$$24, this_ptr, "checkcolumnunsigned", NULL, 490, 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, 478, column); + ZEPHIR_CALL_METHOD(&_18$$26, this_ptr, "checkcolumnunsigned", NULL, 490, 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, 478, column); + ZEPHIR_CALL_METHOD(&_21$$36, this_ptr, "checkcolumnunsigned", NULL, 490, 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, 478, column); + ZEPHIR_CALL_METHOD(&_24$$40, this_ptr, "checkcolumnunsigned", NULL, 490, 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, 478, column); + ZEPHIR_CALL_METHOD(&_31$$52, this_ptr, "checkcolumnunsigned", NULL, 490, 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, 480, &_36$$75, &_35$$75); + ZEPHIR_CALL_METHOD(NULL, &_34$$75, "__construct", NULL, 492, &_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, 477, &value$$77, &_38$$78); + ZEPHIR_CALL_FUNCTION(&_39$$78, "addcslashes", &_40, 489, &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, 477, &value$$77, &_44$$79); + ZEPHIR_CALL_FUNCTION(&_45$$79, "addcslashes", &_40, 489, &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, 477, &typeValues, &_51$$80); + ZEPHIR_CALL_FUNCTION(&_52$$80, "addcslashes", &_40, 489, &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, 477, &defaultValue, &_23$$14); + ZEPHIR_CALL_FUNCTION(&_24$$14, "addcslashes", NULL, 489, &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, 481); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 493); 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 fa6fbbc699..406297f51f 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, 480, &_7$$74, &_6$$74); + ZEPHIR_CALL_METHOD(NULL, &_5$$74, "__construct", NULL, 492, &_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, 477, &value$$76, &_9$$77); + ZEPHIR_CALL_FUNCTION(&_10$$77, "addcslashes", &_11, 489, &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, 477, &value$$76, &_15$$78); + ZEPHIR_CALL_FUNCTION(&_16$$78, "addcslashes", &_11, 489, &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, 477, &typeValues, &_22$$79); + ZEPHIR_CALL_FUNCTION(&_23$$79, "addcslashes", &_11, 489, &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, 482); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 494); 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, 477, &defaultValue, &_12$$7); + ZEPHIR_CALL_FUNCTION(&_13$$7, "addcslashes", NULL, 489, &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 d45dc628f7..65cfcd5c8c 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, 477, &defaultValue, &_13$$6); + ZEPHIR_CALL_FUNCTION(&_14$$6, "addcslashes", NULL, 489, &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, 483); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 495); 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, 484); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 496); 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, 485); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 497); 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, 477, &defaultValue, &_18$$14); + ZEPHIR_CALL_FUNCTION(&_19$$14, "addcslashes", &_20, 489, &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, 477, &defaultValue, &_38$$24); + ZEPHIR_CALL_FUNCTION(&_39$$24, "addcslashes", &_20, 489, &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, 486); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 498); 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, 487); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 499); 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, 488); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 500); 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, 480, &_7$$38, &_6$$38); + ZEPHIR_CALL_METHOD(NULL, &_5$$38, "__construct", NULL, 492, &_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, 477, &value$$40, &_9$$41); + ZEPHIR_CALL_FUNCTION(&_10$$41, "addcslashes", &_11, 489, &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, 477, &value$$40, &_15$$42); + ZEPHIR_CALL_FUNCTION(&_16$$42, "addcslashes", &_11, 489, &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, 477, &typeValues, &_22$$43); + ZEPHIR_CALL_FUNCTION(&_23$$43, "addcslashes", &_11, 489, &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, 489); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 501); 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, 482); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 494); 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 8309a81973..09182c3b9c 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, 570, &geometries); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 597, &geometries); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 571, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 598, &_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, 570, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 597, 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 99c6673bdf..1a6c181593 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, 572, &points); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 599, &points); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 573, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 600, &_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, 572, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 599, 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 b336ae86be..18ef507b08 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, 574, &lineStrings); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 601, &lineStrings); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 575, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 602, &_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, 574, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 601, 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 2cb59da684..7da0e62c52 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, 576, &points); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 603, &points); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 577, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 604, &_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, 576, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 603, 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 9f69fbbeb1..038a2f7f7e 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, 578, &polygons); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 605, &polygons); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 579, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 606, &_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, 578, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 605, 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 d925fb1dcb..27433e12ef 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, 580, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 607, &_0); ZVAL_UNDEF(&_0); ZVAL_DOUBLE(&_0, y); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 581, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 608, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 582, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 609, &_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, 580, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 581, PH_NOISY_CC | PH_READONLY); + 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_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 4ba304ac9f..489351da10 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, 583, &rings); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 610, &rings); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 584, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 611, &_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, 583, 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/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 f4f96f15e2..cdfaae54d4 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, 490, &raw_zv); + ZEPHIR_CALL_FUNCTION(&_1, "ctype_xdigit", NULL, 502, &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, 491, &_5$$5, &_4$$5); + ZEPHIR_CALL_FUNCTION(&arr, "unpack", NULL, 503, &_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, 585, &body); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 612, &body); ZVAL_UNDEF(&_8); ZVAL_LONG(&_8, zephir_fast_strlen_ev(&body)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 586, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 613, &_8); ZVAL_UNDEF(&_8); ZVAL_LONG(&_8, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 587, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 614, &_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, 492, &_5$$9, &srid); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 504, &_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, 493, &_9$$10, &srid); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 505, &_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, 494, &srid); + ZEPHIR_CALL_METHOD(&_14$$12, this_ptr, "readgeometry", &_15, 506, &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, 495, &items, &srid); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 507, &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, 496, &items, &srid); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 508, &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, 497, &items, &srid); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 509, &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, 498, &items, &srid); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 510, &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, 499, &_17$$16); + ZEPHIR_CALL_METHOD(NULL, &_16$$16, "__construct", NULL, 511, &_17$$16); zephir_check_call_status(); zephir_throw_exception_debug(&_16$$16, "phalcon/Db/Geometry/WkbParser.zep", 137); ZEPHIR_MM_RESTORE(); @@ -404,7 +404,7 @@ PHP_METHOD(Phalcon_Db_Geometry_WkbParser, readPoint) zephir_check_call_status(); object_init_ex(return_value, phalcon_db_geometry_point_ce); ZVAL_LONG(&_5, srid); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 500, &x, &y, &_5); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &x, &y, &_5); zephir_check_call_status(); RETURN_MM(); } @@ -484,7 +484,7 @@ PHP_METHOD(Phalcon_Db_Geometry_WkbParser, readPointList) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_8$$3); object_init_ex(&_8$$3, phalcon_db_geometry_point_ce); - ZEPHIR_CALL_METHOD(NULL, &_8$$3, "__construct", &_9, 500, &x, &y); + ZEPHIR_CALL_METHOD(NULL, &_8$$3, "__construct", &_9, 0, &x, &y); zephir_check_call_status(); zephir_array_append(&points, &_8$$3, PH_SEPARATE, "phalcon/Db/Geometry/WkbParser.zep", 166); i = (i + 1); @@ -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, 587, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 586, PH_NOISY_CC | PH_READONLY); + 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); 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, 585, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 587, PH_NOISY_CC | PH_READONLY); + 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); 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, 491, &_6, &_5); + ZEPHIR_CALL_FUNCTION(&arr, "unpack", NULL, 503, &_6, &_5); zephir_check_call_status(); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 587, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 614, 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, 587, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 614, &_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, 587, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 586, PH_NOISY_CC | PH_READONLY); + 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); 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, 585, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 587, PH_NOISY_CC | PH_READONLY); + 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); ZVAL_LONG(&_4, 4); ZEPHIR_INIT_VAR(&_5); zephir_substr(&_5, &_2, zephir_get_intval(&_3), 4 , 0); - ZEPHIR_CALL_FUNCTION(&arr, "unpack", NULL, 491, &fmt, &_5); + ZEPHIR_CALL_FUNCTION(&arr, "unpack", NULL, 503, &fmt, &_5); zephir_check_call_status(); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 587, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 614, 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, 587, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 614, &_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, 587, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 586, PH_NOISY_CC | PH_READONLY); + 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); 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, 585, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 587, PH_NOISY_CC | PH_READONLY); + 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); ZVAL_LONG(&_4, 8); ZEPHIR_INIT_VAR(&_5); zephir_substr(&_5, &_2, zephir_get_intval(&_3), 8 , 0); - ZEPHIR_CALL_FUNCTION(&arr, "unpack", NULL, 491, &fmt, &_5); + ZEPHIR_CALL_FUNCTION(&arr, "unpack", NULL, 503, &fmt, &_5); zephir_check_call_status(); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 587, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 614, 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, 587, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 614, &_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 89db201b88..4c8fb7e581 100644 --- a/ext/phalcon/db/index.zep.c +++ b/ext/phalcon/db/index.zep.c @@ -219,32 +219,32 @@ 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, 588, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 615, &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); if (UNEXPECTED(Z_TYPE_P(&_0$$3) != IS_ARRAY)) { ZEPHIR_INIT_VAR(&_1$$4); object_init_ex(&_1$$4, phalcon_db_exceptions_invalidindexcolumns_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 501); + ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 0); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$4, "phalcon/Db/Index.zep", 140); ZEPHIR_MM_RESTORE(); 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, 589, &_2$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 616, &_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, 590, &_3$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 617, &_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, 591, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 618, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 591, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 618, &__$false); } } zephir_memory_observe(&directions); @@ -252,37 +252,37 @@ PHP_METHOD(Phalcon_Db_Index, __construct) if (UNEXPECTED(Z_TYPE_P(&directions) != IS_ARRAY)) { ZEPHIR_INIT_VAR(&_4$$8); object_init_ex(&_4$$8, phalcon_db_exceptions_invalidindexdirections_ce); - ZEPHIR_CALL_METHOD(NULL, &_4$$8, "__construct", NULL, 502); + ZEPHIR_CALL_METHOD(NULL, &_4$$8, "__construct", NULL, 0); zephir_check_call_status(); zephir_throw_exception_debug(&_4$$8, "phalcon/Db/Index.zep", 155); ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 592, &directions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 619, &directions); } zephir_memory_observe(&where); if (zephir_array_isset_string_fetch(&where, &columnsOrDefinition, SL("where"), 0)) { if (UNEXPECTED(Z_TYPE_P(&where) != IS_STRING)) { ZEPHIR_INIT_VAR(&_5$$10); object_init_ex(&_5$$10, phalcon_db_exceptions_invalidindexwhere_ce); - ZEPHIR_CALL_METHOD(NULL, &_5$$10, "__construct", NULL, 503); + ZEPHIR_CALL_METHOD(NULL, &_5$$10, "__construct", NULL, 0); zephir_check_call_status(); zephir_throw_exception_debug(&_5$$10, "phalcon/Db/Index.zep", 163); ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 593, &where); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 620, &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, 594, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 621, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 594, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 621, &__$false); } } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 589, &columnsOrDefinition); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 590, &type_zv); + 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_MM_RESTORE(); } diff --git a/ext/phalcon/db/profiler.zep.c b/ext/phalcon/db/profiler.zep.c index 5f8359a0ef..5558631927 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, 595, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 622, 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, 595, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 622, &_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, 596, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 623, &_0); RETURN_THISW(); } @@ -272,21 +272,21 @@ PHP_METHOD(Phalcon_Db_Profiler, startProfile) zephir_check_call_status(); } - ZEPHIR_CALL_METHOD(NULL, &activeProfile, "setsqlstatement", NULL, 504, &sqlStatement_zv); + ZEPHIR_CALL_METHOD(NULL, &activeProfile, "setsqlstatement", NULL, 0, &sqlStatement_zv); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &activeProfile, "setsqlvariables", NULL, 505, &sqlVariables); + ZEPHIR_CALL_METHOD(NULL, &activeProfile, "setsqlvariables", NULL, 0, &sqlVariables); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &activeProfile, "setsqlbindtypes", NULL, 506, &sqlBindTypes); + ZEPHIR_CALL_METHOD(NULL, &activeProfile, "setsqlbindtypes", NULL, 0, &sqlBindTypes); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&_0, "hrtime", NULL, 455, &__$true); + ZEPHIR_CALL_FUNCTION(&_0, "hrtime", NULL, 467, &__$true); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &activeProfile, "setinitialtime", NULL, 507, &_0); + ZEPHIR_CALL_METHOD(NULL, &activeProfile, "setinitialtime", NULL, 0, &_0); zephir_check_call_status(); if ((zephir_method_exists_ex(this_ptr, ZEND_STRL("beforestartprofile")) == SUCCESS)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "beforestartprofile", NULL, 0, &activeProfile); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 597, &activeProfile); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 624, &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, 597, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 624, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&activeProfile, &_0); - ZEPHIR_CALL_FUNCTION(&_1, "hrtime", NULL, 455, &__$true); + ZEPHIR_CALL_FUNCTION(&_1, "hrtime", NULL, 467, &__$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, 596, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 623, PH_NOISY_CC | PH_READONLY); _2 = ZEPHIR_GT_LONG(&_0, 0); if (_2) { - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 595, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 596, PH_NOISY_CC | PH_READONLY); + 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); _2 = ZEPHIR_LE_LONG(&_4, zephir_fast_count_int(&_3)); } if (_2) { - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 595, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 622, 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, 595, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_2, 622, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_6$$4, &firstKey, PH_SEPARATE); } } - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_3, 598, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_3, 625, 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, 598, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 625, &_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 6c29eaba35..7f33e18c31 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, 599, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 600, PH_NOISY_CC | PH_READONLY); + 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_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, 599, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 626, &_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, 600, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 627, &_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, 601, &sqlBindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 628, &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, 602, &sqlStatement_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 629, &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, 603, &sqlVariables); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 630, &sqlVariables); RETURN_THIS(); } diff --git a/ext/phalcon/db/rawvalue.zep.c b/ext/phalcon/db/rawvalue.zep.c index 30c6347e16..42f80ca833 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, 604, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 631, &_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, 604, &_1$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 631, &_1$$4); } else { zephir_cast_to_string(&_2$$5, value); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 604, &_2$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 631, &_2$$5); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/db/reference.zep.c b/ext/phalcon/db/reference.zep.c index 1a15e7c5bb..f7dde39b17 100644 --- a/ext/phalcon/db/reference.zep.c +++ b/ext/phalcon/db/reference.zep.c @@ -173,60 +173,60 @@ 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, 605, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 632, &name_zv); zephir_memory_observe(&referencedTable); if (UNEXPECTED(!(zephir_array_isset_string_fetch(&referencedTable, &definition, SL("referencedTable"), 0)))) { ZEPHIR_INIT_VAR(&_0$$3); object_init_ex(&_0$$3, phalcon_db_exceptions_referencedtablerequired_ce); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 508); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 0); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$3, "phalcon/Db/Reference.zep", 108); ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 606, &referencedTable); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 633, &referencedTable); zephir_memory_observe(&columns); if (UNEXPECTED(!(zephir_array_isset_string_fetch(&columns, &definition, SL("columns"), 0)))) { ZEPHIR_INIT_VAR(&_1$$4); object_init_ex(&_1$$4, phalcon_db_exceptions_foreignkeycolumnsrequired_ce); - ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 509); + ZEPHIR_CALL_METHOD(NULL, &_1$$4, "__construct", NULL, 0); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$4, "phalcon/Db/Reference.zep", 114); ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 607, &columns); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 634, &columns); zephir_memory_observe(&referencedColumns); if (UNEXPECTED(!(zephir_array_isset_string_fetch(&referencedColumns, &definition, SL("referencedColumns"), 0)))) { ZEPHIR_INIT_VAR(&_2$$5); object_init_ex(&_2$$5, phalcon_db_exceptions_referencedcolumnsrequired_ce); - ZEPHIR_CALL_METHOD(NULL, &_2$$5, "__construct", NULL, 510); + ZEPHIR_CALL_METHOD(NULL, &_2$$5, "__construct", NULL, 0); zephir_check_call_status(); zephir_throw_exception_debug(&_2$$5, "phalcon/Db/Reference.zep", 120); ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 608, &referencedColumns); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 635, &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, 609, &schema); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 636, &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, 610, &referencedSchema); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 637, &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, 611, &onDelete); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 638, &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, 612, &onUpdate); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 639, &onUpdate); } if (UNEXPECTED(zephir_fast_count_int(&columns) != zephir_fast_count_int(&referencedColumns))) { ZEPHIR_INIT_VAR(&_3$$10); object_init_ex(&_3$$10, phalcon_db_exceptions_referencedcolumncountmismatch_ce); - ZEPHIR_CALL_METHOD(NULL, &_3$$10, "__construct", NULL, 511); + ZEPHIR_CALL_METHOD(NULL, &_3$$10, "__construct", NULL, 0); zephir_check_call_status(); zephir_throw_exception_debug(&_3$$10, "phalcon/Db/Reference.zep", 142); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/db/result/pdoresult.zep.c b/ext/phalcon/db/result/pdoresult.zep.c index b1ca9dfd82..6bbdf694cc 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, 613, connection); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 614, result); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 615, sqlStatement); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 616, bindParams); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 617, bindTypes); + 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); } /** @@ -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, 613, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 640, 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, 615, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 642, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlStatement, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 616, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 643, 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, 617, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 644, 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, 614, &statement); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 641, &statement); n = -1; number--; while (1) { if (!(n != number)) { break; } - zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_5, 618, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_5, 645, 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, 619, &__$null); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 614, PH_NOISY_CC | PH_READONLY); + 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_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, 618, PH_NOISY_CC); + zephir_read_property_cached(&mode, this_ptr, _zephir_prop_0, 645, PH_NOISY_CC); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 641, 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, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 641, 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, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 641, 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, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 641, 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, 614, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 618, PH_NOISY_CC | PH_READONLY); + 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_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, 619, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 646, 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, 613, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 640, 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, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_2, 641, 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, 615, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_3, 642, 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, 616, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11$$7, this_ptr, _zephir_prop_5, 617, PH_NOISY_CC | PH_READONLY); + 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_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, 619, &rowCount); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 646, &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, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 641, 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, 618, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 645, &_0); RETURN_MM_BOOL(1); } diff --git a/ext/phalcon/di/factorydefault/cli.zep.c b/ext/phalcon/di/factorydefault/cli.zep.c index 79d52dcadb..7d8cca6963 100644 --- a/ext/phalcon/di/factorydefault/cli.zep.c +++ b/ext/phalcon/di/factorydefault/cli.zep.c @@ -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, 620, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 647, &_0); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/di/service.zep.c b/ext/phalcon/di/service.zep.c index edab2e4432..d3b030dfc6 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, 621, definition); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 648, definition); if (shared) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 622, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 649, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 622, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 649, &__$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, 621, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 648, 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, 621, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 648, 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, 622, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 649, PH_NOISY_CC | PH_READONLY); _1 = zephir_is_true(&_0); if (_1) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 623, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 650, 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, 621, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 648, 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, 622, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 649, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_3)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 623, &instance); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 650, &instance); } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 624, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 651, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 624, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 651, &__$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, 621, definition); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 648, 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, 621, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 648, 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, 621, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 648, 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, 622, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 649, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 622, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 649, &__$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, 623, sharedInstance); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 650, sharedInstance); } diff --git a/ext/phalcon/domain/payload/payload.zep.c b/ext/phalcon/domain/payload/payload.zep.c index 4bdf531c20..0a912d6af8 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, 625, exception); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 652, 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, 626, extras); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 653, 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, 627, input); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 654, 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, 628, messages); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 655, 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, 629, output); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 656, 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, 630, status); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 657, status); RETURN_THISW(); } diff --git a/ext/phalcon/encryption/crypt.zep.c b/ext/phalcon/encryption/crypt.zep.c index 09b962d2f2..4e59b9fcd5 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, 631, padFactory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 658, padFactory); ZEPHIR_INIT_VAR(&_0); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "sha256"); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 632, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 659, &_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, 633, PH_NOISY_CC); + zephir_read_property_cached(&decryptKey, this_ptr, _zephir_prop_0, 660, 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, 634, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 661, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cipher, &_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 635, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 662, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&ivLength, &_1); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "cipher"); @@ -390,10 +390,10 @@ PHP_METHOD(Phalcon_Encryption_Crypt, decrypt) 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, 636, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 663, 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, 637, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_4, 664, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&hashLength, &_5$$6, &hashAlgorithm, 0))) { ZEPHIR_INIT_VAR(&_7$$7); ZVAL_STRING(&_7$$7, ""); @@ -422,7 +422,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, decrypt) } 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, 636, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12, this_ptr, _zephir_prop_3, 663, 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, 633, PH_NOISY_CC); + zephir_read_property_cached(&encryptKey, this_ptr, _zephir_prop_0, 660, 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, 634, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 661, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cipher, &_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 635, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 662, 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, 636, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 663, 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, 634, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 661, 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, 638, &data_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 665, &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, 639, &tag_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 666, &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, 640, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 667, &_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, 635, &_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 634, &cipher_zv); + 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); 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, 633, &key_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 660, &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, 632, &hashAlgorithm_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 659, &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, 641, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 668, &_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, 636, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 663, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 636, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 663, &__$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, 631, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 658, 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, 631, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 658, 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, 631, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 658, 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, 631, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 658, 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, 641, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 668, 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, 634, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 661, 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, 638, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 665, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&authData, &_4$$3); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 640, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 667, 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, 641, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 668, 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, 641, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 668, 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, 634, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 661, 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, 638, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 665, 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, 639, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 666, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&authTag, &_4$$3); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_3, 640, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_3, 667, 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, 639, &authTag); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 666, &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, 642, &allowed); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 669, &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, 635, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 662, 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, 634, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 661, 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, 634, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 661, 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, 634, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 634, PH_NOISY_CC | PH_READONLY); + 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); 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, 407, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &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 56f91d2055..34e5d48b1b 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, 643, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 644, request); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 645, session); + 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_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, 646, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 673, 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, 647, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_1, 674, 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, 648, &__$null); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 649, &__$null); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 650, &__$null); + 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); 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, 650, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 677, 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, 647, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 674, 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, 651, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 678, PH_NOISY_CC | PH_READONLY); numberBytes = zephir_get_numberval(&_0$$3); } while (1) { - zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_1, 643, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_1, 670, 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, 648, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 675, 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, 652, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_1, 679, 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, 647, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_2, 674, 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, 648, &sessionToken); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 650, &sessionToken); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 675, &sessionToken); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 677, &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, 650, &_6$$3); - zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_4, 643, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_5, 651, PH_NOISY_CC | PH_READONLY); + 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_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, 648, &_8$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 675, &_8$$3); if (Z_TYPE_P(&session) != IS_NULL) { - zephir_read_property_cached(&_10$$6, this_ptr, _zephir_prop_2, 647, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_0, 648, PH_NOISY_CC | PH_READONLY); + 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_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, 649, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 676, 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, 652, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 679, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_FALSE_IDENTICAL(&_3$$4)) { - zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_2, 646, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_2, 673, 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, 649, &sessionTokenKey); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 676, &sessionTokenKey); RETURN_MM_MEMBER(getThis(), "tokenKey"); } } - zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_3, 643, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_4, 651, PH_NOISY_CC | PH_READONLY); + 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_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, 649, &_6$$4); - zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_2, 646, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 649, PH_NOISY_CC | PH_READONLY); + 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_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, 653, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 680, 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, 643, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 651, PH_NOISY_CC | PH_READONLY); + 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_CALL_METHOD(&_1, &_0, "base64safe", NULL, 0, &_2); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 648, &_1); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 643, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 651, PH_NOISY_CC | PH_READONLY); + 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_CALL_METHOD(&_4, &_3, "base64safe", NULL, 0, &_5); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 649, &_4); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 650, &__$null); + 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_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, 647, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_2, 648, PH_NOISY_CC | PH_READONLY); + 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_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, 646, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_3, 649, PH_NOISY_CC | PH_READONLY); + 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_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, 652, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 679, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 652, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 679, &__$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, 653, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 680, &_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, 651, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 678, &_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, 654, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 681, &_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, 655, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 682, 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, 655, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 682, 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, 655, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 682, 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, 653, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 680, 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, 653, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 680, 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, 653, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 680, PH_NOISY_CC | PH_READONLY); _1 = ZEPHIR_IS_LONG_IDENTICAL(&_0, 10); if (!(_1)) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 653, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 680, 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, 654, PH_NOISY_CC); + zephir_read_property_cached(&cost, this_ptr, _zephir_prop_0, 681, 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, 646, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 673, 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 1f3dc5a7c8..9b8862a092 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, 656, signer); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 683, 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, 657, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 658, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 656, PH_NOISY_CC | PH_READONLY); + 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_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, 659, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, 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, 658, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 685, 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, 659, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, 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, 659, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, 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, 658, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 685, 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, 659, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, 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, 658, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 685, 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, 659, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, 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, 659, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, 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, 659, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, 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, 659, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, 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, 659, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, 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, 660, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 687, 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, 657, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 684, 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, 657, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 684, 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, 656, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 683, 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, 660, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12, this_ptr, _zephir_prop_0, 687, 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, 660, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 687, &_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, 659, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 686, &_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, 658, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 685, &_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, 658, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 685, 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, 660, &passphrase_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 687, &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, 659, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 686, 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 9d61d84525..f94cf2c0cd 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, 661, &algo_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 688, &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, 661, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 688, 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 4633c80f7b..330d59e9d6 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, 662, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 689, 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, 662, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 689, 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, 662, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 689, 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 8bb3d3a0ae..8c9563ae0a 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, 663, &service); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 690, &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, 663, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 690, 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, 663, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 690, 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 81b20a12d0..5e97a6d570 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, 664, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 691, 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 c4de581155..a4174fa040 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, 665, headers); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 666, claims); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 667, 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); } /** @@ -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, 665, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 692, 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, 666, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 693, 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, 667, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 694, 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, 667, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 694, 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 5b888d76ea..5958c2a483 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, 668, token); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 695, token); ZVAL_UNDEF(&_1); ZVAL_LONG(&_1, timeShift); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 669, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 696, &_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, 670, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 697, &_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, 670, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 697, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, &claim_zv)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 670, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 697, 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, 668, token); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 695, 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, 668, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, 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, 668, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 695, 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, 668, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, 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, 668, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 695, 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, 668, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, 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, 668, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, 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, 668, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, 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, 668, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, 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, 668, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 695, 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, 668, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 695, 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, 668, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 695, 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, 669, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 696, 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 09442926b4..e81bca7300 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, 340, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("random_bytes", NULL, 303, &_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, 491, &_2, &_0); + ZEPHIR_CALL_FUNCTION(&_3, "unpack", NULL, 503, &_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, 491, &_1, &_0); + ZEPHIR_CALL_FUNCTION(&bytes, "unpack", NULL, 503, &_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 5a5fabbd7f..493c16470f 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, 340, &_0); + ZEPHIR_CALL_FUNCTION(&nodeBytes, "random_bytes", NULL, 303, &_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, 341, &nodeBytes); + ZEPHIR_RETURN_CALL_FUNCTION("bin2hex", NULL, 304, &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 894e89f045..d0ca4f0dc2 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, 671, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 698, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { RETURN_MM_MEMBER_TYPED(getThis(), "node", IS_STRING); } @@ -147,7 +147,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_SysNodeProvider, getNode) ZEPHIR_CALL_FUNCTION(&cached, "apcu_fetch", NULL, 268, &_3$$4); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&cached)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 671, &cached); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 698, &cached); RETURN_MM_MEMBER_TYPED(getThis(), "node", IS_STRING); } } @@ -353,13 +353,13 @@ 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, 671, &node); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 698, &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, 671, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_54$$21, this_ptr, _zephir_prop_0, 698, 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); @@ -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, 490, &node_zv); + ZEPHIR_CALL_FUNCTION(&_0, "ctype_xdigit", NULL, 502, &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, 407, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &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 bd8c024e51..3d4a0e7f07 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, 340, &_5); + ZEPHIR_CALL_FUNCTION(&clockSeqBytes, "random_bytes", NULL, 303, &_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, 672, &_14); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 699, &_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, 672, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 699, 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, 672, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 699, 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 5c6b0a0c8a..642ad9c53c 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, 341, &hash); + ZEPHIR_CALL_FUNCTION(&_15, "bin2hex", NULL, 304, &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, 673, &_14); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 700, &_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 b4b49c109b..2ffc968347 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, 340, &_0); + ZEPHIR_CALL_FUNCTION(&_1, "random_bytes", NULL, 303, &_0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "N1a/n1b/n1c/n1d/n1e/N1f"); - ZEPHIR_CALL_FUNCTION(&_3, "unpack", NULL, 491, &_2, &_1); + ZEPHIR_CALL_FUNCTION(&_3, "unpack", NULL, 503, &_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, 674, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 701, &_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 caf4e70d02..9cc4c789bd 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, 341, &hash); + ZEPHIR_CALL_FUNCTION(&_18, "bin2hex", NULL, 304, &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, 675, &_17); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 702, &_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 fc34792de7..e3d81f0fbf 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, 340, &_3); + ZEPHIR_CALL_FUNCTION(&clockSeqBytes, "random_bytes", NULL, 303, &_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, 676, &_12); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 703, &_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, 676, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 703, 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, 676, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 703, 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 b4047de90d..4f030f177f 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, 340, &_2); + ZEPHIR_CALL_FUNCTION(&randBytes, "random_bytes", NULL, 303, &_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, 341, &_4); + ZEPHIR_CALL_FUNCTION(&_5, "bin2hex", NULL, 304, &_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, 341, &_9); + ZEPHIR_CALL_FUNCTION(&_10, "bin2hex", NULL, 304, &_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, 341, &_14); + ZEPHIR_CALL_FUNCTION(&_15, "bin2hex", NULL, 304, &_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, 677, &_17); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 704, &_17); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/events/event.zep.c b/ext/phalcon/events/event.zep.c index 1090a124fd..f6a1911a1d 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, 678, &type_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 679, source); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 680, data); + 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); if (cancelable) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 681, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 708, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 681, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 708, &__$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, 680, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 707, 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, 678, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 705, &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, 681, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 708, 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, 682, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 709, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 682, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 709, &__$false); } RETURN_THIS(); } diff --git a/ext/phalcon/events/manager.zep.c b/ext/phalcon/events/manager.zep.c index 0df58e38f2..c21b738a85 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, 683, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 710, 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, 684, PH_NOISY_CC); + zephir_read_property_cached(&snapshot, this_ptr, _zephir_prop_0, 711, 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, 685, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 712, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 685, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 712, &__$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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 713, 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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$10, this_ptr, _zephir_prop_0, 713, 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, 686, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 713, &_0$$3); } else { - zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_0, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_0, 713, 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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$5, this_ptr, _zephir_prop_0, 713, 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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 713, 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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 713, 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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 713, 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, 687, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 714, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 687, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 714, &__$false); } } @@ -885,7 +885,7 @@ PHP_METHOD(Phalcon_Events_Manager, fire) cancelable = 1; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 688, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 715, 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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 713, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_3)) { - zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_2, 689, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_2, 716, 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, 690, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_3, 717, 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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12, this_ptr, _zephir_prop_1, 713, PH_NOISY_CC | PH_READONLY); hasTypeQueue = zephir_array_isset_value(&_12, &type); - zephir_read_property_cached(&_13, this_ptr, _zephir_prop_1, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13, this_ptr, _zephir_prop_1, 713, 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, 689, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$10, this_ptr, _zephir_prop_2, 716, 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, 691, PH_NOISY_CC); + zephir_read_property_cached(&wasDepth, this_ptr, _zephir_prop_4, 718, PH_NOISY_CC); ZVAL_UNDEF(&_17); ZVAL_LONG(&_17, (zephir_get_numberval(&wasDepth) + 1)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 691, &_17); - zephir_read_property_cached(&_17, this_ptr, _zephir_prop_5, 685, PH_NOISY_CC | PH_READONLY); + 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); 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, 692, PH_NOISY_CC); + zephir_read_property_cached(&stashed, this_ptr, _zephir_prop_6, 719, PH_NOISY_CC); } ZEPHIR_INIT_VAR(&_18$$12); array_init(&_18$$12); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 692, &_18$$12); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 719, &_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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$15, this_ptr, _zephir_prop_1, 713, 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, 693, PH_NOISY_CC); + zephir_read_property_cached(&_23$$14, this_ptr, _zephir_prop_7, 720, 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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_30$$16, this_ptr, _zephir_prop_1, 713, 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, 692, &stashed); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 719, &stashed); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 691, &wasDepth); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 718, &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, 692, &stashed); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 719, &stashed); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 691, &wasDepth); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 718, &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, 688, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 715, 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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 713, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_1)) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 689, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 716, 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, 690, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 717, 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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_1, 713, PH_NOISY_CC | PH_READONLY); hasTypeQueue = zephir_array_isset_value(&_10, &type); - zephir_read_property_cached(&_11, this_ptr, _zephir_prop_1, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11, this_ptr, _zephir_prop_1, 713, 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, 689, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$9, this_ptr, _zephir_prop_2, 716, 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, 691, PH_NOISY_CC); + zephir_read_property_cached(&wasDepth, this_ptr, _zephir_prop_4, 718, PH_NOISY_CC); ZVAL_UNDEF(&_15); ZVAL_LONG(&_15, (zephir_get_numberval(&wasDepth) + 1)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 691, &_15); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 718, &_15); zephir_memory_observe(&stashed); - zephir_read_property_cached(&stashed, this_ptr, _zephir_prop_5, 692, PH_NOISY_CC); + zephir_read_property_cached(&stashed, this_ptr, _zephir_prop_5, 719, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_16); array_init(&_16); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 692, &_16); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 719, &_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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$12, this_ptr, _zephir_prop_1, 713, 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, 693, PH_NOISY_CC); + zephir_read_property_cached(&_21$$11, this_ptr, _zephir_prop_6, 720, 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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$13, this_ptr, _zephir_prop_1, 713, 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, 692, &stashed); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 691, &wasDepth); + 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_throw_exception_debug(&ex, "phalcon/Events/Manager.zep", 651); ZEPHIR_MM_RESTORE(); return; } } - zephir_read_property_cached(&_15, this_ptr, _zephir_prop_5, 692, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15, this_ptr, _zephir_prop_5, 719, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&responses, &_15); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 692, &stashed); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 691, &wasDepth); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 719, &stashed); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 718, &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, 688, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 715, 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, 685, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 712, 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, 688, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 715, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 688, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 715, &__$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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 713, 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, 684, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 711, 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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 713, 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, 684, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 711, 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, 684, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 711, 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, 683, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 710, 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, 688, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 715, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 688, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 715, &__$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, 694, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 721, &_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, 693, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 720, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 693, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 720, &__$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, 689, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 716, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 689, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 716, &__$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, 685, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 712, 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, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$6, this_ptr, _zephir_prop_0, 722, 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, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$7, this_ptr, _zephir_prop_0, 722, 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, 694, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$7, this_ptr, _zephir_prop_1, 721, 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, 695, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$7, this_ptr, _zephir_prop_1, 694, PH_NOISY_CC | PH_READONLY); + 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); _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, 695, &_8$$8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 722, &_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, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$6, this_ptr, _zephir_prop_0, 722, 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, 693, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$3, this_ptr, _zephir_prop_2, 720, 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, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$16, this_ptr, _zephir_prop_0, 722, 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, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$17, this_ptr, _zephir_prop_0, 722, 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, 694, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$17, this_ptr, _zephir_prop_1, 721, 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, 695, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_25$$17, this_ptr, _zephir_prop_1, 694, PH_NOISY_CC | PH_READONLY); + 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); _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, 695, &_26$$18); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 722, &_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, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$16, this_ptr, _zephir_prop_0, 722, 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, 693, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_32$$13, this_ptr, _zephir_prop_2, 720, 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, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_39$$28, this_ptr, _zephir_prop_0, 722, 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, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_41$$29, this_ptr, _zephir_prop_0, 722, 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, 694, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_43$$29, this_ptr, _zephir_prop_1, 721, 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, 695, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_46$$29, this_ptr, _zephir_prop_1, 694, PH_NOISY_CC | PH_READONLY); + 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); _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, 695, &_47$$30); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 722, &_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, 695, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_49$$28, this_ptr, _zephir_prop_0, 722, 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, 693, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_53$$25, this_ptr, _zephir_prop_2, 720, 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, 687, PH_NOISY_CC); + zephir_read_property_cached(&prioritiesOn, this_ptr, _zephir_prop_0, 714, 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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 713, 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 413b325195..ddfc58514d 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, 696, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 723, 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, 697, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 724, 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, 696, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 723, 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, 697, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 724, 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, 696, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 723, 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, 697, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 724, 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 3ad5fc4f2b..ba61a52a3c 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, 698, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 725, &_0); ZEPHIR_INIT_VAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, NULL, phalcon_16__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, 699, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 726, &_2); ZEPHIR_INIT_VAR(&_3); ZEPHIR_INIT_NVAR(&_3); zephir_create_closure_ex(&_3, NULL, phalcon_17__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, 700, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 727, &_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, 698, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 725, 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, 701, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 728, 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, 702, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$7, this_ptr, _zephir_prop_1, 729, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&whitelist, &_7$$7); } - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 703, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 730, 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, 704, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$8, this_ptr, _zephir_prop_3, 731, 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, 704, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$8, this_ptr, _zephir_prop_3, 731, 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, 704, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$8, this_ptr, _zephir_prop_3, 731, 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, 704, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_27$$15, this_ptr, _zephir_prop_3, 731, 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, 704, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$15, this_ptr, _zephir_prop_3, 731, 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, 704, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$15, this_ptr, _zephir_prop_3, 731, 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, 703, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 730, 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, 705, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 732, 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, 706, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 733, 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, 704, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 731, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&entity, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 701, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 728, 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, 703, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 730, 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, 704, entity); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 731, 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, 705, &labels); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 732, &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, 699, &validators); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 726, &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, 699, PH_NOISY_CC); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 700, PH_NOISY_CC | PH_READONLY); + 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_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, 706, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 733, &_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, 698, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 725, &_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, 701, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 728, data); ZEPHIR_CPY_WRT(&inputData, data); } else { - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 701, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 728, PH_NOISY_CC | PH_READONLY); if (!(ZEPHIR_IS_EMPTY(&_0))) { ZEPHIR_OBS_NVAR(&inputData); - zephir_read_property_cached(&inputData, this_ptr, _zephir_prop_4, 701, PH_NOISY_CC); + zephir_read_property_cached(&inputData, this_ptr, _zephir_prop_4, 728, 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, 704, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$8, this_ptr, _zephir_prop_3, 698, PH_NOISY_CC | PH_READONLY); + 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_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, 704, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_58$$44, this_ptr, _zephir_prop_3, 698, PH_NOISY_CC | PH_READONLY); + 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_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, 698, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 725, 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 3609b10547..a4ca87df96 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, 707, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 734, 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 b734676a9a..e79d66b87e 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, 708, PH_NOISY_CC); + zephir_read_property_cached(&savedTemplate, this_ptr, _zephir_prop_0, 735, PH_NOISY_CC); zephir_memory_observe(&savedChanged); - zephir_read_property_cached(&savedChanged, this_ptr, _zephir_prop_1, 709, PH_NOISY_CC); + zephir_read_property_cached(&savedChanged, this_ptr, _zephir_prop_1, 736, PH_NOISY_CC); zephir_memory_observe(&savedTemplates); - zephir_read_property_cached(&savedTemplates, this_ptr, _zephir_prop_2, 710, PH_NOISY_CC); + zephir_read_property_cached(&savedTemplates, this_ptr, _zephir_prop_2, 737, 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, 708, &savedTemplate); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 709, &savedChanged); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 710, &savedTemplates); + 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); 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 39852922fd..b5a64f493d 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, 407, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/filter/validation/validator/file/mimetype.zep.c b/ext/phalcon/filter/validation/validator/file/mimetype.zep.c index 1760eeeae6..b09b46b9b7 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, 407, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &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 597d4784c5..a16adafec0 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, 711, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 738, 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 5291eca885..3c0ca67fb3 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, 407, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &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 938ba5bb24..3a13f44d4f 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, 407, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &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 55c2bd9004..81af321b90 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, 712, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 739, 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, 712, &_7$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 739, &_7$$3); } zephir_memory_observe(&_8); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 712, PH_NOISY_CC); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 739, PH_NOISY_CC); _9 = Z_TYPE_P(&_8) == IS_ARRAY; if (_9) { - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 712, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 739, 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, 712, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$4, this_ptr, _zephir_prop_0, 739, 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 5908977c5a..8c68b51031 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, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 740, 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 2cd437e678..92721ee0f0 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, 714, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 741, 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 e993ccb046..9490478ab7 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, 715, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 742, &_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, 716, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 743, 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, 715, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 742, 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, 715, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$6, this_ptr, _zephir_prop_0, 742, 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, 715, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$7, this_ptr, _zephir_prop_0, 742, 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, 715, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 742, 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, 717, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 744, 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, 718, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 745, PH_NOISY_CC | PH_READONLY); _2 = Z_TYPE_P(&_1) != IS_NULL; if (_2) { - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 718, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 745, 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, 718, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_1, 745, 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, 717, &_7$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 744, &_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 e3b1be31cc..88c55ec40e 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, 719, value); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 746, value); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 720, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 747, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 720, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 747, &__$false); } RETURN_THISW(); } diff --git a/ext/phalcon/forms/element/checkgroup.zep.c b/ext/phalcon/forms/element/checkgroup.zep.c index 7f4676920e..42b91f8110 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, 721, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 748, &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, 722, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 749, 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, 723, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 721, PH_NOISY_CC | PH_READONLY); + 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_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, 721, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 748, &options); RETURN_THIS(); } diff --git a/ext/phalcon/forms/element/radiogroup.zep.c b/ext/phalcon/forms/element/radiogroup.zep.c index e34a0d6ecf..a41174bc06 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, 724, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 751, &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, 725, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 752, 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, 726, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 724, PH_NOISY_CC | PH_READONLY); + 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_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, 724, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 751, &options); RETURN_THIS(); } diff --git a/ext/phalcon/forms/element/select.zep.c b/ext/phalcon/forms/element/select.zep.c index cbf9f29681..0ea49a4042 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, 727, options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 754, 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, 727, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 754, 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, 727, options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 754, 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, 728, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 755, 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, 729, PH_NOISY_CC); + zephir_read_property_cached(&defaultAttributes, this_ptr, _zephir_prop_1, 756, 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 03611157b6..9d85cc3fdc 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, 730, entity); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 731, &userOptions); + 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_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, 732, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 759, &_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, 733, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 760, &_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, 734, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 761, 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, 734, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 761, 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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 762, 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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 762, 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, 735, &elements); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 762, &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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, 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, 736, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_1, 763, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&whitelist, &_3$$6); } - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 762, 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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$15, this_ptr, _zephir_prop_0, 762, 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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$16, this_ptr, _zephir_prop_0, 762, 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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_43$$30, this_ptr, _zephir_prop_0, 762, 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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_44$$31, this_ptr, _zephir_prop_0, 762, 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, 737, &assignData); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 738, &filteredData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 764, &assignData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 765, &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, 737, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 764, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&data, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 762, 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, 737, &data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 764, &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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, 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, 739, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 740, PH_NOISY_CC | PH_READONLY); + 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); 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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, 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, 732, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 759, 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, 732, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 759, &_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, 738, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 765, 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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, 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, 731, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 758, 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, 730, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 757, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&entity, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 737, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 764, 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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 762, 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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, 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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, 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, 736, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_1, 763, 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, 737, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$5, this_ptr, _zephir_prop_2, 764, 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, 730, PH_NOISY_CC); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 757, PH_NOISY_CC); _3 = Z_TYPE_P(&_4) == IS_OBJECT; } if (_3) { - zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_3, 730, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_3, 757, 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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 762, 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, 733, &messages); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 760, &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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, 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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, 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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 762, 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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 762, 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, 739, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 766, &_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, 740, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 735, PH_NOISY_CC | PH_READONLY); + 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_CALL_FUNCTION(&_1, "array_values", NULL, 27, &_0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 739, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 766, &_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, 732, attributes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 759, 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, 730, entity); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 757, 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, 734, tagFactory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 761, 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, 741, validation); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 768, 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, 736, &whitelist); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 763, &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, 731, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 758, &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, 739, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 740, PH_NOISY_CC | PH_READONLY); + 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); 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 482e745747..280f739306 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, 742, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 769, &_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, 743, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 770, 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, 744, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 771, 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, 742, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 769, 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, 742, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 769, 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, 743, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 770, 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, 742, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 769, 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, 744, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 771, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_0, &name_zv, PH_SEPARATE); zephir_update_property_array(this_ptr, SL("factories"), &name_zv, factory); } diff --git a/ext/phalcon/forms/loader/arrayloader.zep.c b/ext/phalcon/forms/loader/arrayloader.zep.c index f0012a1bab..3bde373051 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, 745, &definitions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 772, &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, 745, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 772, 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 4494239eb2..ec0ef00ba7 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, 746, &source_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 773, &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, 746, PH_NOISY_CC); - ZEPHIR_CALL_FUNCTION(&_0, "is_file", NULL, 405, &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_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, 347, &json, &_6$$4, &_7$$4, &_8$$4); + ZEPHIR_CALL_METHOD(&definitions, &_5$$4, "__invoke", NULL, 359, &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 9383d7d209..a77a8d8060 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, 747, &source_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 774, &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, 747, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 774, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&source, &_3); - ZEPHIR_CALL_FUNCTION(&_4, "is_file", NULL, 405, &source); + ZEPHIR_CALL_FUNCTION(&_4, "is_file", NULL, 417, &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, 408, &source); + ZEPHIR_CALL_FUNCTION(&definitions, "yaml_parse_file", NULL, 420, &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, 407, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &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 cdb8e9dff0..3b2b6685af 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, 748, locator); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 775, 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, 749, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 776, 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, 749, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 776, 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, 748, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 775, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&locator, &_0); ZEPHIR_INIT_VAR(&_1); object_init_ex(&_1, phalcon_forms_form_ce); @@ -268,7 +268,7 @@ 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, 748, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 775, 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")); diff --git a/ext/phalcon/html/breadcrumbs.zep.c b/ext/phalcon/html/breadcrumbs.zep.c index 21361c7b7b..7386c74b51 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, 750, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 777, &_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, 750, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 777, 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, 750, &elements); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 777, &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, 750, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 777, 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, 751, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 778, 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, 752, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 779, 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, 752, &separator_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 779, &separator_zv); RETURN_THISW(); } diff --git a/ext/phalcon/html/escaper.zep.c b/ext/phalcon/html/escaper.zep.c index df543831b0..e12c32cdaa 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, 753, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 780, &_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, 754, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 781, &_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, 755, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 782, &_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, 756, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 783, &_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, 757, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 784, &_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, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 780, 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, 754, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 781, 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, 755, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 782, 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, 755, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 782, 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, 755, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 782, 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, 755, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 782, 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, 756, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 783, 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, 755, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 782, 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, 753, escaper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 780, 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, 754, escaper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 781, 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, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 780, 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, 754, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 781, 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, 755, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 782, 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, 756, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_3, 783, 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, 757, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_4, 784, 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, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 780, 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, 754, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 781, 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, 755, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 782, 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, 756, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 783, 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, 757, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_4, 784, 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, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 780, 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, 754, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 781, 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, 755, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 782, 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, 756, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 783, 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, 757, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_4, 784, 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, 755, escaper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 782, 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, 756, escaper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 783, 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, 757, escaper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 784, 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, 757, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 784, 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 3fa5030736..75f322af23 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, 758, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 759, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 760, PH_NOISY_CC | PH_READONLY); + 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_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 973691e98e..2ca5165bc6 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, 761, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 762, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 763, PH_NOISY_CC | PH_READONLY); + 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_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 7a4c57cf67..0516d53542 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, 764, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 791, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 764, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 791, &__$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, 765, &encoding_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 792, &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, 766, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 793, &_0); RETURN_THISW(); } diff --git a/ext/phalcon/html/helper/anchor.zep.c b/ext/phalcon/html/helper/anchor.zep.c index 6d85bb3b96..b50bf3b65a 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, 767, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 794, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 767, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 794, &__$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, 767, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 794, 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 d8e9881b22..77363d3bb1 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, 768, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 769, url); + 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_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, 770, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 771, &indent_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); 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, 772, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 799, 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, 772, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 799, &_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, 773, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 800, &_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, 772, PH_NOISY_CC); + zephir_read_property_cached(&elements, this_ptr, _zephir_prop_0, 799, PH_NOISY_CC); zephir_array_unset_long(&elements, index, PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 772, &elements); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 799, &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, 772, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 799, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_0)) { RETURN_MM_STRING(""); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 772, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 799, 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, 774, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_1, 801, 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, 774, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$5, this_ptr, _zephir_prop_1, 801, 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, 774, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 801, 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, 768, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_15, this_ptr, _zephir_prop_1, 774, PH_NOISY_CC | PH_READONLY); + 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_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, 773, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19, this_ptr, _zephir_prop_3, 800, 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, 770, PH_NOISY_CC); + zephir_read_property_cached(&_20, this_ptr, _zephir_prop_4, 797, 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, 771, PH_NOISY_CC); + zephir_read_property_cached(&_20, this_ptr, _zephir_prop_5, 798, 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, 771, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_23, this_ptr, _zephir_prop_6, 775, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_24, this_ptr, _zephir_prop_4, 770, PH_NOISY_CC | PH_READONLY); + 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_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, 773, &attributes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 800, &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, 776, &prefix_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 769, &__$null); + 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); 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, 775, &separator_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 802, &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, 774, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 801, &_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, 769, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 796, 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, 769, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 796, 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, 776, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 803, PH_NOISY_CC | PH_READONLY); _4 = !(ZEPHIR_IS_EMPTY(&_5)); } if (_4) { - zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_1, 776, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_1, 803, 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, 771, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11, this_ptr, _zephir_prop_3, 768, PH_NOISY_CC | PH_READONLY); + 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_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, 777, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17, this_ptr, _zephir_prop_4, 804, 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, 770, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19, this_ptr, _zephir_prop_5, 797, 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 c3c77578ca..6931fa842e 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, 778, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 805, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 778, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 805, &__$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, 778, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 805, 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 dd467f4b82..4b2a9b260f 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, 779, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 806, &_0); ZEPHIR_INIT_VAR(&_1); ZEPHIR_GET_CONSTANT(&_1, "PHP_EOL"); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 780, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 807, &_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, 779, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 780, &delimiter_zv); + 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); 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, 779, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 806, PH_NOISY_CC | PH_READONLY); do { if (ZEPHIR_IS_LONG(&_0, 1)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 807, 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, 780, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); + 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_CONCAT_SVSV(return_value, "", &_3$$4); return; } if (ZEPHIR_IS_LONG(&_0, 3)) { - zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); + 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_CONCAT_SVSV(return_value, "", &_5$$5); return; } if (ZEPHIR_IS_LONG(&_0, 4)) { - zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); + 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_CONCAT_SVSV(return_value, "", &_7$$6); return; } if (ZEPHIR_IS_LONG(&_0, 6)) { - zephir_read_property_cached(&_8$$7, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_9$$7, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); + 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_CONCAT_SVSV(return_value, "", &_9$$7); return; } if (ZEPHIR_IS_LONG(&_0, 7)) { - zephir_read_property_cached(&_10$$8, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11$$8, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); + 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_CONCAT_SVSV(return_value, "", &_11$$8); return; } if (ZEPHIR_IS_LONG(&_0, 8)) { - zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_13$$9, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); + 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_CONCAT_SVSV(return_value, "", &_13$$9); return; } if (ZEPHIR_IS_LONG(&_0, 9)) { - zephir_read_property_cached(&_14$$10, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_15$$10, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); + 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_CONCAT_SVSV(return_value, "", &_15$$10); return; } if (ZEPHIR_IS_LONG(&_0, 10)) { - zephir_read_property_cached(&_16$$11, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_17$$11, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); + 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_CONCAT_SVSV(return_value, "", &_17$$11); return; } } while(0); - zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 807, 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 d37fb87b7f..690ba2d929 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, 781, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 808, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 781, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 808, &__$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, 781, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 808, 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 fe194362ca..a6748995be 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, 782, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 809, &_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, 782, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 809, 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 1619335de8..9879874567 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, 783, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 810, 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, 783, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 810, PH_NOISY_CC); if (Z_TYPE_P(&_1) == IS_ARRAY) { zephir_memory_observe(&selected); - zephir_read_property_cached(&selected, this_ptr, _zephir_prop_0, 783, PH_NOISY_CC); + zephir_read_property_cached(&selected, this_ptr, _zephir_prop_0, 810, 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, 783, PH_NOISY_CC); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_0, 810, 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 2dfeae0d74..01ef9a7c4e 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, 784, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 811, &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, 784, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 811, &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 2d47665254..2f4777ab64 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, 785, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 812, 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, 785, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 812, 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 d95fede13a..d7a254a864 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, 786, PH_NOISY_CC); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 813, 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, 786, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 813, 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, 787, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 814, 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, 788, PH_NOISY_CC); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 815, PH_NOISY_CC); ZEPHIR_ADD_ASSIGN(&_5$$3, &_2$$3) - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 788, &_5$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 815, &_5$$3); } else { ZEPHIR_INIT_VAR(&_7$$4); ZVAL_LONG(&_7$$4, 1); - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_1, 788, PH_NOISY_CC); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_1, 815, PH_NOISY_CC); ZEPHIR_SUB_ASSIGN(&_6$$4, &_7$$4) - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 788, &_6$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 815, &_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, 787, PH_NOISY_CC); + zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 814, PH_NOISY_CC); if (!zephir_is_true(&_11)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 787, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 814, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 787, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 814, &__$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, 786, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 813, 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, 789, &selected_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 816, &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, 790, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 817, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 790, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 817, &__$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, 789, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 816, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_STRING_IDENTICAL(&_1$$3, "")) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 790, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 817, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_2$$4)) { - zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_0, 789, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_0, 816, 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, 789, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$6, this_ptr, _zephir_prop_0, 816, 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 af307c4faf..5d632d9319 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, 791, &data); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 792, &attributes); + 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_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 1968e539a4..deac620d28 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, 793, resultset); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 794, &using); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 795, &attributesMap); + 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_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, 796, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 823, 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, 797, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 824, 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, 794, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 821, 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, 794, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 821, 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, 793, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 820, 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, 795, PH_NOISY_CC); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_2, 822, 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, 795, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$5, this_ptr, _zephir_prop_2, 822, 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, 795, PH_NOISY_CC); + zephir_read_property_cached(&_24$$15, this_ptr, _zephir_prop_2, 822, 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, 795, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$17, this_ptr, _zephir_prop_2, 822, 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, 797, &options); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 796, &attrs); + 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_MM_RESTORE(); } diff --git a/ext/phalcon/html/helper/input/textarea.zep.c b/ext/phalcon/html/helper/input/textarea.zep.c index 0ffd85e3da..6f223c5caa 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, 798, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 825, 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, 798, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 825, &_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, 799, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 826, 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 5602b73e47..9f4415fece 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, 800, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 827, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 800, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 827, &__$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, 800, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 827, PH_NOISY_CC); _0 = zephir_is_true(&_1); } ZEPHIR_INIT_VAR(&_2); diff --git a/ext/phalcon/html/helper/preload.zep.c b/ext/phalcon/html/helper/preload.zep.c index 001d02cb8e..c372b9b577 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, 801, response); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 828, 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, 801, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 828, 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, 801, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 828, 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/title.zep.c b/ext/phalcon/html/helper/title.zep.c index 8f92421754..837f08ed68 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, 802, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 803, &indent_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); 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, 804, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 831, 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, 805, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 832, PH_NOISY_CC); zephir_array_fast_append(&_1, &_2); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 806, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 833, 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, 806, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 833, &_4); ZEPHIR_INIT_VAR(&_5); array_init(&_5); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 804, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 831, &_5); ZEPHIR_INIT_VAR(&_6); ZEPHIR_INIT_NVAR(&_6); ZVAL_STRING(&_6, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 805, &_6); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_3, 803, PH_NOISY_CC | PH_READONLY); + 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_INIT_NVAR(&_6); - zephir_read_property_cached(&_9, this_ptr, _zephir_prop_4, 807, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_4, 834, 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, 802, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12, this_ptr, _zephir_prop_5, 829, 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, 808, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 835, 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, 808, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 835, 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, 805, &text); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 832, &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, 808, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 835, 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, 807, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 834, &_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, 808, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 835, 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, 804, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 831, 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, 804, &prepend); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 831, &prepend); RETURN_THIS(); } diff --git a/ext/phalcon/html/helper/voidtag.zep.c b/ext/phalcon/html/helper/voidtag.zep.c index f83702a170..fc624f12cc 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, 809, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 836, PH_NOISY_CC | PH_READONLY); _1 = Z_TYPE_P(&_0) != IS_NULL; if (_1) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 809, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 836, 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 8b8ce11f68..25a0f9b624 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, 810, escaper); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 811, response); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 812, url); + 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_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, 813, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 840, &_0); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getdefaultservices", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 814, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 841, &_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, 814, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 841, 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, 814, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 841, 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, 815, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 842, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_2, &name_zv))) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 814, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 841, 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, 815, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 842, 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, 815, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 842, PH_NOISY_CC | PH_READONLY); zephir_array_unset(&_0, &name_zv, PH_SEPARATE); } @@ -462,11 +462,11 @@ 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, 810, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 837, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&escaper, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 811, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 838, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&response, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 812, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 839, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&url, &_0); zephir_create_array(return_value, 59, 0); ZEPHIR_INIT_VAR(&_1); diff --git a/ext/phalcon/http/cookie.zep.c b/ext/phalcon/http/cookie.zep.c index 69cce1ce0c..330f428c1d 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, 816, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 843, &name_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, expire); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 817, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 818, &path_zv); + 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); if (secure) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 819, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 846, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 819, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 846, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 820, &domain_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 847, &domain_zv); if (httpOnly) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 821, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 848, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 821, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 848, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 822, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 849, &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, 816, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 843, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&name, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 820, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 847, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&domain, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 818, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 845, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&path, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 819, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 846, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&secure, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 821, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 848, 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, 823, &__$null); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 822, PH_NOISY_CC | PH_READONLY); + 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_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, 824, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, 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, 824, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, 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, 824, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, 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, 824, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, 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, 824, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, 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, 824, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, 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, 816, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 843, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&name, &_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 825, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 852, 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, 826, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 853, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_2$$4)) { - zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_4, 827, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_4, 854, 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, 828, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_5, 855, 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, 823, &decryptedValue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 850, &decryptedValue); if (Z_TYPE_P(filters) != IS_NULL) { - zephir_read_property_cached(&_8$$12, this_ptr, _zephir_prop_7, 829, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$12, this_ptr, _zephir_prop_7, 856, 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, 827, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$14, this_ptr, _zephir_prop_4, 854, 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, 829, &filter); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 856, &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, 824, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, 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, 817, &expire); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 844, &expire); } if (zephir_array_isset_string_fetch(&domain, &definition, SL("domain"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 820, &domain); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 847, &domain); } if (zephir_array_isset_string_fetch(&path, &definition, SL("path"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 818, &path); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 845, &path); } if (zephir_array_isset_string_fetch(&secure, &definition, SL("secure"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 819, &secure); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 846, &secure); } if (zephir_array_isset_string_fetch(&httpOnly, &definition, SL("httpOnly"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 821, &httpOnly); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 848, &httpOnly); } if (zephir_array_isset_string_fetch(&options, &definition, SL("options"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 822, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 849, &options); } } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 824, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 851, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 824, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 851, &__$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, 816, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 843, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&name, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 823, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&value, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 817, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 844, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&expire, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 820, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 847, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&domain, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 818, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 845, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&path, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 819, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 846, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&secure, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 821, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 848, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&httpOnly, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_7, 822, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_7, 849, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_8, 827, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_8, 854, 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, 826, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_9, 853, 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, 828, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$5, this_ptr, _zephir_prop_10, 855, 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, 824, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, 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, 820, &domain_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 847, &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, 824, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, 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, 817, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 844, &_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, 824, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, 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, 821, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 848, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 821, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 848, &__$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, 822, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 849, &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, 824, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, 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, 818, &path_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 845, &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, 824, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 851, 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, 819, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 846, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 819, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 846, &__$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, 828, &signKey_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 855, &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, 823, value); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 850, value); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 825, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 852, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 825, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 852, &__$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, 826, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 853, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 826, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 853, &__$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, 816, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 843, 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, 827, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 854, 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 3ffb410d28..09968fa1e0 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, 830, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 857, 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, 830, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 857, &_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, 831, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$4, this_ptr, _zephir_prop_0, 858, 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, 831, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_0, 858, 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, 832, PH_NOISY_CC); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 859, PH_NOISY_CC); _3$$4 = !(ZEPHIR_IS_EMPTY(&_2$$4)); if (_3$$4) { ZEPHIR_CALL_METHOD(&_4$$4, this_ptr, "isproxytrusted", NULL, 0, &address); @@ -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, 832, PH_NOISY_CC); + zephir_read_property_cached(&_8$$9, this_ptr, _zephir_prop_1, 859, 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, 832, PH_NOISY_CC); + zephir_read_property_cached(&_14$$12, this_ptr, _zephir_prop_1, 859, 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, 833, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 860, 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, 834, PH_NOISY_CC); + zephir_read_property_cached(&strict, this_ptr, _zephir_prop_0, 861, 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, 347, &rawBody, &_1); + ZEPHIR_RETURN_CALL_METHOD(&_0, "__invoke", NULL, 359, &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, 835, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$5, this_ptr, _zephir_prop_0, 862, 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, 836, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 863, 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, 836, &_0); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 836, PH_NOISY_CC | PH_READONLY); + 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); 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, 836, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 836, PH_NOISY_CC | PH_READONLY); + 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); 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, 836, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 863, 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, 836, &_0); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 836, PH_NOISY_CC | PH_READONLY); + 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); 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, 837, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 864, 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, 837, &contents); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 864, &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, 835, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 862, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 835, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 862, &__$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, 834, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 861, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 834, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 861, &__$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, 831, &trustedHeader); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 858, &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, 491, &_3, &ipBin); + ZEPHIR_CALL_FUNCTION(&ipBits, "unpack", NULL, 503, &_3, &ipBin); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_3); ZVAL_STRING(&_3, "H*"); - ZEPHIR_CALL_FUNCTION(&subnetBits, "unpack", NULL, 491, &_3, &subnetBin); + ZEPHIR_CALL_FUNCTION(&subnetBits, "unpack", NULL, 503, &_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, 392, &ipBits, &subnetBits, &_8); + ZEPHIR_CALL_FUNCTION(&_9, "strncmp", NULL, 404, &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, 838, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 865, 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, 839, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 866, 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, 838, &filterService); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 865, &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, 832, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 859, 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/file.zep.c b/ext/phalcon/http/request/file.zep.c index ce723b4fa9..9602f79ac6 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, 840, &name); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 867, &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, 841, &_3$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 868, &_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, 842, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 869, &_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, 843, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 870, &_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, 844, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 871, &_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, 845, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 872, &_8); if (!(ZEPHIR_IS_EMPTY(&key_zv))) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 846, &key_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 873, &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, 847, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 874, 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, 842, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 869, 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, 847, &mime); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 874, &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, 842, PH_NOISY_CC); + zephir_read_property_cached(&name, this_ptr, _zephir_prop_0, 869, 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, 842, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 869, 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 736c20bc0b..ddaea71a90 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, 848, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 875, &_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, 849, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 876, &_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, 850, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 877, &_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, 850, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 877, 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, 851, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 878, 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, 851, &container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 878, &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, 848, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 875, 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, 848, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 875, 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, 848, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 875, 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, 848, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 875, 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, 852, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 879, 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, 850, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 877, 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, 853, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_2, 880, 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, 852, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 879, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 852, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 879, &__$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, 854, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 881, 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, 848, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 875, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&headers, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 855, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 882, 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, 850, &content_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 877, &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, 854, cookies); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 881, 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, 851, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 878, 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, 855, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 882, 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, 477, &basePath, &_7$$8); + ZEPHIR_CALL_FUNCTION(&_8$$8, "addcslashes", NULL, 489, &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, 853, &filePath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 880, &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, 848, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 875, 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, 848, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 875, 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, 848, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_0, 875, 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, 849, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 876, 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, 848, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 875, 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, 848, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 875, 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, 848, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 875, 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, 848, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$6, this_ptr, _zephir_prop_0, 875, 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, 848, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17, this_ptr, _zephir_prop_0, 875, 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, 848, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20, this_ptr, _zephir_prop_0, 875, 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, 407, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &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 20cb29de17..e60d9098b5 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, 856, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 883, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 856, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 883, &__$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, 857, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 884, 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, 857, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 884, 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, 856, PH_NOISY_CC); + zephir_read_property_cached(&encryption, this_ptr, _zephir_prop_1, 883, 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, 858, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_2, 885, 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, 857, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 884, 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, 857, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 884, &_0); RETURN_THIS(); } @@ -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, 857, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 884, 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, 859, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 886, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 859, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 886, &__$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, 856, PH_NOISY_CC); + zephir_read_property_cached(&encryption, this_ptr, _zephir_prop_0, 883, PH_NOISY_CC); zephir_memory_observe(&cookie); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 857, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 884, 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, 860, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 887, 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, 860, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 887, 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, 858, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_3, 885, 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, 858, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$5, this_ptr, _zephir_prop_3, 885, 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, 861, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_4, 888, 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, 861, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 888, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 861, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 888, &__$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, 858, &signKey_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 885, &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, 856, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 883, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 856, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 883, &__$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, 860, 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_INIT_VAR(&_1$$3); diff --git a/ext/phalcon/http/response/headers.zep.c b/ext/phalcon/http/response/headers.zep.c index 7e6707a859..a0dcedf943 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, 862, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 889, 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, 862, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 889, 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, 862, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 889, 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, 862, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 889, 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, 862, &headers); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 889, &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, 862, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 889, &_0); ZEPHIR_MM_RESTORE(); } @@ -257,13 +257,13 @@ PHP_METHOD(Phalcon_Http_Response_Headers, send) zephir_check_call_status(); _1 = ZEPHIR_IS_TRUE_IDENTICAL(&_0); if (!(_1)) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 863, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 890, 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, 862, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 889, 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) @@ -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, 863, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 890, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 863, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 890, &__$false); } RETURN_MM_BOOL(1); } diff --git a/ext/phalcon/image/adapter/gd.zep.c b/ext/phalcon/image/adapter/gd.zep.c index 686b2adc78..d0fde63451 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, 864, &file_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 891, &file_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 865, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 864, PH_NOISY_CC | PH_READONLY); + 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_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, 864, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 891, 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, 866, &_3$$3); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 864, PH_NOISY_CC | PH_READONLY); + 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_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, 867, &_5$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 894, &_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, 868, &_6$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 895, &_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, 865, &_7$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 892, &_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, 869, &_8$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 896, &_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, 864, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$5, this_ptr, _zephir_prop_0, 891, 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, 865, PH_NOISY_CC); + zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_1, 892, PH_NOISY_CC); do { if (ZEPHIR_IS_LONG(&_11$$3, 1)) { - zephir_read_property_cached(&_12$$6, this_ptr, _zephir_prop_0, 864, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$6, this_ptr, _zephir_prop_0, 891, 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, 870, &_13$$6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 897, &_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, 864, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$7, this_ptr, _zephir_prop_0, 891, 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, 870, &_15$$7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 897, &_15$$7); break; } if (ZEPHIR_IS_LONG(&_11$$3, 3)) { - zephir_read_property_cached(&_16$$8, this_ptr, _zephir_prop_0, 864, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$8, this_ptr, _zephir_prop_0, 891, 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, 870, &_17$$8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 897, &_17$$8); break; } if (ZEPHIR_IS_LONG(&_11$$3, 18)) { - zephir_read_property_cached(&_18$$9, this_ptr, _zephir_prop_0, 864, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$9, this_ptr, _zephir_prop_0, 891, 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, 870, &_19$$9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 897, &_19$$9); break; } if (ZEPHIR_IS_LONG(&_11$$3, 15)) { - zephir_read_property_cached(&_20$$10, this_ptr, _zephir_prop_0, 864, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$10, this_ptr, _zephir_prop_0, 891, 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, 870, &_21$$10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 897, &_21$$10); break; } if (ZEPHIR_IS_LONG(&_11$$3, 16)) { - zephir_read_property_cached(&_22$$11, this_ptr, _zephir_prop_0, 864, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$11, this_ptr, _zephir_prop_0, 891, 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, 870, &_23$$11); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 897, &_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, 869, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$12, this_ptr, _zephir_prop_5, 896, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_26$$3, this_ptr, _zephir_prop_6, 897, 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, 864, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$14, this_ptr, _zephir_prop_0, 891, 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, 870, &_32$$13); - zephir_read_property_cached(&_30$$13, this_ptr, _zephir_prop_6, 870, PH_NOISY_CC | PH_READONLY); + 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_CALL_FUNCTION(NULL, "imagealphablending", NULL, 0, &_30$$13, &__$true); zephir_check_call_status(); - zephir_read_property_cached(&_31$$13, this_ptr, _zephir_prop_6, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_31$$13, this_ptr, _zephir_prop_6, 897, 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, 864, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 866, &_33$$13); + 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); ZVAL_UNDEF(&_34$$13); ZVAL_LONG(&_34$$13, width); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 867, &_34$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 894, &_34$$13); ZVAL_UNDEF(&_34$$13); ZVAL_LONG(&_34$$13, height); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 868, &_34$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 895, &_34$$13); ZVAL_UNDEF(&_34$$13); ZVAL_LONG(&_34$$13, 3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 865, &_34$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 892, &_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, 869, &_35$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 896, &_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, 870, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 897, &__$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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 897, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 867, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 868, 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(&_3, this_ptr, _zephir_prop_2, 895, 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, 867, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 868, PH_NOISY_CC | PH_READONLY); + 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); 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, 870, &background); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 897, &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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 897, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 897, 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, 870, &image); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 897, &image); ZEPHIR_CALL_FUNCTION(&_2, "imagesx", NULL, 0, &image); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 867, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 894, &_2); ZEPHIR_CALL_FUNCTION(&_3, "imagesy", NULL, 0, &image); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 868, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 895, &_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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 897, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 897, 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, 867, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 868, PH_NOISY_CC | PH_READONLY); + 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_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, 867, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 894, PH_NOISY_CC | PH_READONLY); _9 = !ZEPHIR_IS_LONG_IDENTICAL(&_5, maskWidth); if (!(_9)) { - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 868, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 895, 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, 867, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_1, 868, PH_NOISY_CC | PH_READONLY); + 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_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, 867, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_13$$3, this_ptr, _zephir_prop_1, 868, PH_NOISY_CC | PH_READONLY); + 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); 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, 867, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 894, 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, 868, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$4, this_ptr, _zephir_prop_1, 895, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$5, this_ptr, _zephir_prop_2, 897, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$5, this_ptr, _zephir_prop_2, 897, 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, 870, &newImage); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 897, &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, 867, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 894, 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, 868, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 895, 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, 867, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 894, 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, 868, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_1, 895, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_2, 897, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_2, 897, 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, 867, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 868, PH_NOISY_CC | PH_READONLY); + 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); 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, 870, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 867, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 868, PH_NOISY_CC | PH_READONLY); + 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); 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, 868, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_1, 895, PH_NOISY_CC | PH_READONLY); sourceY = ((zephir_get_numberval(&_11$$5) - offset) - 1); - zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_1, 868, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_1, 895, 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, 867, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$5, this_ptr, _zephir_prop_0, 894, 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, 870, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_19$$5, this_ptr, _zephir_prop_0, 867, PH_NOISY_CC | PH_READONLY); + 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); 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, 867, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$5, this_ptr, _zephir_prop_0, 894, 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, 870, &reflection); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 897, &reflection); ZEPHIR_CALL_FUNCTION(&_27, "imagesx", NULL, 0, &reflection); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 867, &_27); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 894, &_27); ZEPHIR_CALL_FUNCTION(&_28, "imagesy", NULL, 0, &reflection); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 868, &_28); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 895, &_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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 897, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 897, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_0, 897, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_0, 897, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$7, this_ptr, _zephir_prop_0, 897, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$8, this_ptr, _zephir_prop_0, 897, 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, 870, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 867, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 868, PH_NOISY_CC | PH_READONLY); + 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); 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, 870, &image); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 897, &image); ZEPHIR_CALL_FUNCTION(&_9, "imagesx", NULL, 0, &image); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 867, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 894, &_9); ZEPHIR_CALL_FUNCTION(&_10, "imagesy", NULL, 0, &image); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 868, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 895, &_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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 897, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 897, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 897, 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, 870, &image); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 867, &width); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 868, &height); + 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_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, 865, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 892, 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, 865, &_3$$4); - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 870, PH_NOISY_CC | PH_READONLY); + 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_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, 865, &_4$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 892, &_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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_1, 897, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$7, this_ptr, _zephir_prop_1, 897, 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, 865, &_9$$8); - zephir_read_property_cached(&_9$$8, this_ptr, _zephir_prop_1, 870, PH_NOISY_CC | PH_READONLY); + 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_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, 865, &_10$$9); - zephir_read_property_cached(&_10$$9, this_ptr, _zephir_prop_1, 870, PH_NOISY_CC | PH_READONLY); + 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_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, 865, &_11$$10); - zephir_read_property_cached(&_11$$10, this_ptr, _zephir_prop_1, 870, PH_NOISY_CC | PH_READONLY); + 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_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, 865, &_12$$11); - zephir_read_property_cached(&_12$$11, this_ptr, _zephir_prop_1, 870, PH_NOISY_CC | PH_READONLY); + 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_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, 865, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 892, 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, 869, &_14); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 896, &_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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 897, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 897, 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, 867, &_9$$3); - zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 870, PH_NOISY_CC | PH_READONLY); + 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_CALL_FUNCTION(&_11$$3, "imagesy", NULL, 0, &_10$$3); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 868, &_11$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 895, &_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, 867, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$6, this_ptr, _zephir_prop_0, 894, 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, 868, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$7, this_ptr, _zephir_prop_1, 895, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 897, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_2, 897, 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, 867, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$9, this_ptr, _zephir_prop_0, 894, 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, 868, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$10, this_ptr, _zephir_prop_1, 895, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$8, this_ptr, _zephir_prop_2, 897, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_31$$8, this_ptr, _zephir_prop_2, 897, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 897, 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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 897, 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, 407, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &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 3f2339feac..e6f40d8a9b 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, 871, &file_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 898, &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, 872, &_0); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 871, PH_NOISY_CC | PH_READONLY); + 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_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, 871, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 898, 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, 873, &_4$$3); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 872, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_2, 873, PH_NOISY_CC | PH_READONLY); + 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_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, 871, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 898, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_1, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_1, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$3, this_ptr, _zephir_prop_1, 899, 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, 874, &_16$$3); - zephir_read_property_cached(&_17$$3, this_ptr, _zephir_prop_1, 872, PH_NOISY_CC | PH_READONLY); + 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_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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19$$6, this_ptr, _zephir_prop_1, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$6, this_ptr, _zephir_prop_1, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$6, this_ptr, _zephir_prop_1, 899, 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, 872, &image); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 899, &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, 871, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24$$8, this_ptr, _zephir_prop_0, 898, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$7, this_ptr, _zephir_prop_1, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$7, this_ptr, _zephir_prop_1, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$7, this_ptr, _zephir_prop_1, 899, 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, 871, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 873, &_30$$7); + 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(&_31, this_ptr, _zephir_prop_1, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_31, this_ptr, _zephir_prop_1, 899, 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, 875, &_32); - zephir_read_property_cached(&_33, this_ptr, _zephir_prop_1, 872, PH_NOISY_CC | PH_READONLY); + 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_CALL_METHOD(&_34, &_33, "getimageheight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 876, &_34); - zephir_read_property_cached(&_35, this_ptr, _zephir_prop_1, 872, PH_NOISY_CC | PH_READONLY); + 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_CALL_METHOD(&_36, &_35, "getimagetype", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 874, &_36); - zephir_read_property_cached(&_37, this_ptr, _zephir_prop_1, 872, PH_NOISY_CC | PH_READONLY); + 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_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, 877, &_39); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 904, &_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, 872, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC); if (zephir_is_instance_of(&_0, SL("Imagick"))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, 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, 875, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 902, &_10); ZEPHIR_CALL_METHOD(&_11, &image, "getimageheight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 876, &_11); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 903, &_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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 899, 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, 875, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 876, 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_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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 899, 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, 872, &background); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 899, &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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, 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, 875, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 902, &_9); ZEPHIR_CALL_METHOD(&_10, &image, "getimageheight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 876, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 903, &_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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 899, 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, 875, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 902, PH_NOISY_CC | PH_READONLY); width = (int) (zephir_safe_div_zval_long(&_0, amount)); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 876, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 903, PH_NOISY_CC | PH_READONLY); height = (int) (zephir_safe_div_zval_long(&_1, amount)); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 899, 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, 872, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 875, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_1, 876, PH_NOISY_CC | PH_READONLY); + 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_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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_2, 899, 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, 878, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 905, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$5, this_ptr, _zephir_prop_1, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$7, this_ptr, _zephir_prop_1, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_31, this_ptr, _zephir_prop_1, 899, 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, 875, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_33$$10, this_ptr, _zephir_prop_2, 902, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_34$$10, this_ptr, _zephir_prop_1, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_41$$10, this_ptr, _zephir_prop_1, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_44$$10, this_ptr, _zephir_prop_1, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_46$$10, this_ptr, _zephir_prop_1, 899, 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, 876, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_53$$13, this_ptr, _zephir_prop_3, 903, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_32, this_ptr, _zephir_prop_1, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_60, this_ptr, _zephir_prop_1, 899, 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, 872, &image); - zephir_read_property_cached(&_61, this_ptr, _zephir_prop_1, 872, PH_NOISY_CC | PH_READONLY); + 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_CALL_METHOD(&_62, &_61, "getimagewidth", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 875, &_62); - zephir_read_property_cached(&_63, this_ptr, _zephir_prop_1, 872, PH_NOISY_CC | PH_READONLY); + 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_CALL_METHOD(&_64, &_63, "getimageheight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 876, &_64); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 903, &_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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, 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, 874, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 901, &_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, 877, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 904, &_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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, 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, 875, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 902, &_6); ZEPHIR_CALL_METHOD(&_7, &image, "getimageheight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 876, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 903, &_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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 875, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 876, PH_NOISY_CC | PH_READONLY); + 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); 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 899, 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, 875, &_9); - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 872, PH_NOISY_CC | PH_READONLY); + 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_CALL_METHOD(&_11, &_10, "getimageheight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 876, &_11); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 903, &_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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 899, 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, 874, &_3); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 872, PH_NOISY_CC | PH_READONLY); + 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_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, 877, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 904, &_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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$4, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$5, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$14, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19$$14, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 899, 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, 872, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_0, 899, 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, 878, &_4$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 905, &_4$$4); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/logger/adapter/stream.zep.c b/ext/phalcon/logger/adapter/stream.zep.c index e3eb011987..3c7ecf56ca 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, 879, &name_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 880, &mode); + 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_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, 881, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 881, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&handler, &_1$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 881, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 908, &__$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, 881, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC | PH_READONLY); if (!(Z_TYPE_P(&_0) == IS_RESOURCE)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 879, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 880, PH_NOISY_CC | PH_READONLY); + 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_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, 881, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 908, &__$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, 879, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_2, 880, PH_NOISY_CC | PH_READONLY); + 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_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, 881, &fileHandler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 908, &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, 881, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 908, 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 d5e1206065..228445e75a 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, 882, &name_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 883, &option); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 884, &facility); + 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_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, 885, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 912, 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, 882, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 883, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 884, PH_NOISY_CC | PH_READONLY); + 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_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, 882, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 884, PH_NOISY_CC | PH_READONLY); + 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_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, 885, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 912, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 885, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 912, &__$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 d10e11bf4a..78c37ba669 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, 886, &dateFormat_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 887, &interpolatorLeft_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 888, &interpolatorRight_zv); + 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_MM_RESTORE(); } diff --git a/ext/phalcon/logger/formatter/line.zep.c b/ext/phalcon/logger/formatter/line.zep.c index 638484225d..ceccd03167 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, 889, &format_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 890, &dateFormat_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 891, &interpolatorLeft_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 892, &interpolatorRight_zv); + 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_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, 889, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 916, 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, 891, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 892, PH_NOISY_CC | PH_READONLY); + 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_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, 891, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 892, PH_NOISY_CC | PH_READONLY); + 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_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, 891, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 892, PH_NOISY_CC | PH_READONLY); + 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_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, 889, &format_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 916, &format_zv); RETURN_THISW(); } diff --git a/ext/phalcon/logger/item.zep.c b/ext/phalcon/logger/item.zep.c index ed757e497b..4f51b20497 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, 893, &message_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 894, &levelName_zv); + 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); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, level); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 895, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 896, dateTime); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 897, &context); + 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_MM_RESTORE(); } diff --git a/ext/phalcon/logger/loggerfactory.zep.c b/ext/phalcon/logger/loggerfactory.zep.c index 5aa31f6230..2b7e553f4e 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, 898, factory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 925, 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, 898, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_0, 925, 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, 898, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$4, this_ptr, _zephir_prop_0, 925, 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 42522571c8..932c0b105f 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, 899, &message_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 900, &field_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 901, &type_zv); + 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); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, code); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 902, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 903, &metaData); + 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_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, 900, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 927, 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, 899, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 926, 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, 901, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 928, 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, 902, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 929, 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, 903, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 930, 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, 902, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 929, &_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, 900, &field_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 927, &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, 899, &message_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 926, &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, 903, &metaData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 930, &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, 901, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 928, &type_zv); RETURN_THISW(); } diff --git a/ext/phalcon/messages/messages.zep.c b/ext/phalcon/messages/messages.zep.c index da406ffe8e..a552482004 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, 904, &messages); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 931, &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, 904, PH_NOISY_CC); + zephir_read_property_cached(¤tMessages, this_ptr, _zephir_prop_0, 931, 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, 904, &finalMessages); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 931, &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, 904, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 931, 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, 904, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 931, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 905, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 932, 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, 904, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 931, 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, 904, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 931, 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, 904, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 931, 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, 904, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 931, 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, 904, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 931, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, index)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 904, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 931, 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, 905, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 932, &_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, 904, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 905, PH_NOISY_CC | PH_READONLY); + 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); 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 6fe5654acf..48ac31ab03 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, 906, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 933, 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, 907, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 934, 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, 908, PH_NOISY_CC); + zephir_read_property_cached(&moduleName, this_ptr, _zephir_prop_2, 935, 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, 909, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 936, 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, 910, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 937, 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, 911, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_45, this_ptr, _zephir_prop_5, 938, 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, 911, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 938, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 911, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 938, &__$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, 910, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 937, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 910, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 937, &__$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, 909, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 936, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 909, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 936, &__$false); } RETURN_THISW(); } diff --git a/ext/phalcon/mvc/controller.zep.c b/ext/phalcon/mvc/controller.zep.c index 39e2ca7a2c..d727d691b7 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, 912, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 939, 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, 912, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 939, 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, 912, PH_NOISY_CC); + zephir_read_property_cached(&eventsManager, this_ptr, _zephir_prop_0, 939, 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 cf5cb753a1..769265a768 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, 913, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 940, 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, 914, &controllerName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 941, &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, 915, &controllerSuffix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 942, &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, 916, &controllerName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 943, &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, 913, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 940, 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, 917, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 944, 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 27bba9eabb..2c3ca6641c 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, 918, handler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 945, 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, 919, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 946, 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, 920, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 947, 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, 921, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 948, 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, 921, &_1$$3); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 921, PH_NOISY_CC | PH_READONLY); + 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_CALL_METHOD(NULL, &_3$$3, "clear", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 921, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 948, 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, 922, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 949, 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, 922, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 949, 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, 922, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 949, 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, 920, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_2$$4) != IS_NULL) { - zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_1, 920, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_1, 947, 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, 923, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$7, this_ptr, _zephir_prop_2, 950, 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, 924, &handler); - zephir_read_property_cached(&_11$$7, this_ptr, _zephir_prop_1, 920, PH_NOISY_CC | PH_READONLY); + 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); if (Z_TYPE_P(&_11$$7) != IS_NULL) { - zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_1, 920, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_1, 947, 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, 924, PH_NOISY_CC); + zephir_read_property_cached(&handler, this_ptr, _zephir_prop_3, 951, PH_NOISY_CC); } - zephir_read_property_cached(&_15$$7, this_ptr, _zephir_prop_4, 925, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$7, this_ptr, _zephir_prop_4, 952, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&beforeHandlers, &_15$$7); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 926, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 953, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 926, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 953, &__$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, 926, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$11, this_ptr, _zephir_prop_5, 953, 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, 926, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_27$$16, this_ptr, _zephir_prop_5, 953, 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, 919, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$7, this_ptr, _zephir_prop_6, 946, 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, 920, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$7, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_15$$7) != IS_NULL) { - zephir_read_property_cached(&_40$$29, this_ptr, _zephir_prop_1, 920, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_40$$29, this_ptr, _zephir_prop_1, 947, 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, 927, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_43$$7, this_ptr, _zephir_prop_7, 954, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&afterBindingHandlers, &_43$$7); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 926, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 953, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 926, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 953, &__$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, 926, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_48$$31, this_ptr, _zephir_prop_5, 953, 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, 926, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_54$$36, this_ptr, _zephir_prop_5, 953, 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, 928, &returnedValue); - zephir_read_property_cached(&_43$$7, this_ptr, _zephir_prop_1, 920, PH_NOISY_CC | PH_READONLY); + 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); if (Z_TYPE_P(&_43$$7) != IS_NULL) { - zephir_read_property_cached(&_55$$41, this_ptr, _zephir_prop_1, 920, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_55$$41, this_ptr, _zephir_prop_1, 947, 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, 929, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_57$$7, this_ptr, _zephir_prop_9, 956, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&afterHandlers, &_57$$7); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 926, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 953, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 926, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 953, &__$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, 926, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_62$$42, this_ptr, _zephir_prop_5, 953, 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, 926, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_68$$47, this_ptr, _zephir_prop_5, 953, 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, 920, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_69$$52, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_69$$52) != IS_NULL) { - zephir_read_property_cached(&_70$$53, this_ptr, _zephir_prop_1, 920, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_70$$53, this_ptr, _zephir_prop_1, 947, 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, 930, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_73$$52, this_ptr, _zephir_prop_10, 957, 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, 920, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_75$$4, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_75$$4) != IS_NULL) { - zephir_read_property_cached(&_76$$56, this_ptr, _zephir_prop_1, 920, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_76$$56, this_ptr, _zephir_prop_1, 947, 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, 931, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_78$$4, this_ptr, _zephir_prop_11, 958, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&finishHandlers, &_78$$4); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 926, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 953, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 926, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 953, &__$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, 926, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_84$$57, this_ptr, _zephir_prop_5, 953, 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, 926, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_91$$62, this_ptr, _zephir_prop_5, 953, 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, 920, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_93$$67, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_93$$67) != IS_NULL) { - zephir_read_property_cached(&_94$$68, this_ptr, _zephir_prop_1, 920, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_94$$68, this_ptr, _zephir_prop_1, 947, 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, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_96$$67, this_ptr, _zephir_prop_12, 945, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_96$$67) != IS_NULL) { - zephir_read_property_cached(&_97$$69, this_ptr, _zephir_prop_12, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_97$$69, this_ptr, _zephir_prop_12, 945, 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, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_99$$69, this_ptr, _zephir_prop_12, 945, 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, 932, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_13, 959, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { - zephir_read_property_cached(&_101$$77, this_ptr, _zephir_prop_13, 932, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_101$$77, this_ptr, _zephir_prop_13, 959, 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, 932, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_103$$77, this_ptr, _zephir_prop_13, 959, 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, 922, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 949, 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, 930, handler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 957, 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, 922, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 949, 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, 924, activeHandler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 951, 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, 922, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 949, 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, 919, modelBinder); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 946, 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, 932, handler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 959, 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, 922, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 949, 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, 926, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 953, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 926, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 953, &__$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, 922, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 949, 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, 922, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 949, &_1$$3); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/mvc/micro/collection.zep.c b/ext/phalcon/mvc/micro/collection.zep.c index 71f94baae1..2675c846e2 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, 933, handler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 960, handler); if (isLazy) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 934, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 961, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 934, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 961, &__$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, 934, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 961, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 934, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 961, &__$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, 935, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 962, &prefix_zv); RETURN_THISW(); } diff --git a/ext/phalcon/mvc/micro/lazyloader.zep.c b/ext/phalcon/mvc/micro/lazyloader.zep.c index a22efe741b..2a7f4000b7 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, 936, &definition_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 963, &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, 937, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 964, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&handler, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 936, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 963, 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, 937, &handler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 964, &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 ab6625a37f..ef8ab89093 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, 938, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 965, 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, 939, modelsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 966, 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, 940, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 967, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_1$$3, &lowerProperty)) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 940, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 967, 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, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 968, 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, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_1, 968, 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, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$5, this_ptr, _zephir_prop_1, 968, 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, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$6, this_ptr, _zephir_prop_1, 968, 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, 942, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 969, 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, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 970, 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, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 970, PH_NOISY_CC | PH_READONLY); _4 = !ZEPHIR_IS_EQUAL(&attributes, &_1); } if (_4) { - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 970, 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, 942, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 969, 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, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 968, 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, 942, &dirtyState); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 969, &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, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$9, this_ptr, _zephir_prop_1, 968, 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, 942, &_8$$9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 969, &_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, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$10, this_ptr, _zephir_prop_1, 968, 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, 942, &_15$$17); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 969, &_15$$17); } else { zephir_unset_property_array(this_ptr, ZEND_STRL("dirtyRelated"), &lowerProperty); - zephir_read_property_cached(&_16$$18, this_ptr, _zephir_prop_2, 940, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$18, this_ptr, _zephir_prop_2, 967, 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, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$20, this_ptr, _zephir_prop_1, 968, 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, 940, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19$$20, this_ptr, _zephir_prop_2, 967, 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, 938, &container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 965, &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, 939, &manager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 966, &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, 942, &dirtyState); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 969, &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, 943, &_12$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 970, &_12$$13); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 943, &properties); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 970, &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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 944, &rawValues); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 971, &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, 944, &rawValues); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 971, &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, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 968, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&related, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 940, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 967, 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, 945, &_2$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 972, &_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, 946, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 973, &_0); ZEPHIR_INIT_VAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 945, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 972, &_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, 947, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 974, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 947, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 974, &__$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, 947, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_35$$20, this_ptr, _zephir_prop_2, 974, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_41$$29, this_ptr, _zephir_prop_3, 966, 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, 941, &_42$$29); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 968, &_42$$29); ZEPHIR_INIT_VAR(&_43$$29); array_init(&_43$$29); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 940, &_43$$29); - zephir_read_property_cached(&_44$$29, this_ptr, _zephir_prop_3, 939, PH_NOISY_CC | PH_READONLY); + 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_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, 942, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 969, &_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, 299, this_ptr); + ZEPHIR_RETURN_CALL_FUNCTION("get_object_vars", NULL, 313, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 966, 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, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 970, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 945, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 972, 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, 948, PH_NOISY_CC); + zephir_read_property_cached(&metaData, this_ptr, _zephir_prop_0, 975, PH_NOISY_CC); if (Z_TYPE_P(&metaData) == IS_NULL) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_1, 938, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_1, 965, 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, 948, &metaData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 975, &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, 949, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 976, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 949, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 976, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 940, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 967, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_3$$4, &lowerAlias)) { - zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_1, 940, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_1, 967, 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, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_2, 968, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_6$$4, &lowerAlias)) { - zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_2, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_2, 968, 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, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 968, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 970, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&snapshot, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 950, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 977, 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, 942, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 969, 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, 949, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 976, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 949, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 976, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 970, 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, 942, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 969, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 966, 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, 951, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 978, 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, 951, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_2, 978, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueKey, &_7$$6); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 952, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 979, 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, 953, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_4, 980, 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, 954, &_3$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 981, &_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, 946, &_4$$8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 973, &_4$$8); } else { ZVAL_UNDEF(&_5$$9); ZVAL_LONG(&_5$$9, 1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 946, &_5$$9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 973, &_5$$9); } ZEPHIR_INIT_NVAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 945, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 972, &_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, 954, &_8$$10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 981, &_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, 943, PH_NOISY_CC); + zephir_read_property_cached(&savedSnapshot, this_ptr, _zephir_prop_3, 970, PH_NOISY_CC); zephir_memory_observe(&savedOldSnapshot); - zephir_read_property_cached(&savedOldSnapshot, this_ptr, _zephir_prop_4, 950, PH_NOISY_CC); + zephir_read_property_cached(&savedOldSnapshot, this_ptr, _zephir_prop_4, 977, 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, 942, &_17$$16); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 969, &_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, 943, &savedSnapshot); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 950, &savedOldSnapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 970, &savedSnapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 977, &savedOldSnapshot); } } else { if (hasRelatedToSave) { ZEPHIR_INIT_VAR(&_25$$24); array_init(&_25$$24); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 940, &_25$$24); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 967, &_25$$24); } ZEPHIR_INIT_VAR(&_26$$23); array_init(&_26$$23); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 941, &_26$$23); - zephir_read_property_cached(&_27$$23, this_ptr, _zephir_prop_8, 939, PH_NOISY_CC | PH_READONLY); + 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_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, 954, &_16); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 981, &_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, 942, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 969, 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, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 970, 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, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 970, PH_NOISY_CC | PH_READONLY); _4 = !ZEPHIR_IS_EQUAL(&attributes, &_1); } if (_4) { - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 970, 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, 938, &container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 965, &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, 939, &manager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 966, &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, 942, &dirtyState); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 969, &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, 943, &_16$$18); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 970, &_16$$18); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 943, &properties); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 970, &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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 942, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 969, &_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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 950, &snapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 977, &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, 943, &snapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 970, &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, 949, transaction); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 976, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 947, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 974, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 947, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 974, &__$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, 942, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 969, 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, 945, &_3$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 972, &_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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 944, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 971, 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, 951, &__$null); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 952, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 978, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 979, &__$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, 943, &snapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 970, &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, 944, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 971, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&rawValues, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 966, 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, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 970, 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, 950, &snapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 977, &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, 951, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 978, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueKey, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 952, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 979, 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, 953, PH_NOISY_CC); + zephir_read_property_cached(&_78, this_ptr, _zephir_prop_6, 980, 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, 950, &snapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 977, &snapshot); ZEPHIR_INIT_VAR(&_83$$96); zephir_fast_array_merge(&_83$$96, &snapshot, &newSnapshot); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 943, &_83$$96); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 970, &_83$$96); } else { ZEPHIR_INIT_VAR(&_84$$97); array_init(&_84$$97); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 950, &_84$$97); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 943, &newSnapshot); + 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); } } 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, 951, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 978, 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, 951, &joinWhere); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 952, &uniqueParams); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 953, &uniqueTypes); + 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_CPY_WRT(&uniqueKey, &joinWhere); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 942, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 969, 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, 951, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24$$25, this_ptr, _zephir_prop_0, 978, 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, 952, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$26, this_ptr, _zephir_prop_1, 979, 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, 953, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_26$$27, this_ptr, _zephir_prop_2, 980, 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, 942, &_31$$30); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 969, &_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, 942, &_32$$31); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 969, &_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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 947, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 974, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 947, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 974, &__$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, 947, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_55$$60, this_ptr, _zephir_prop_0, 974, 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, 954, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$9, this_ptr, _zephir_prop_0, 981, 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, 954, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$9, this_ptr, _zephir_prop_0, 981, 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, 954, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_203$$91, this_ptr, _zephir_prop_0, 981, 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, 954, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_204$$91, this_ptr, _zephir_prop_0, 981, 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, 946, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 973, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 966, 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, 945, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 972, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_fast_count_int(&_0) > 0); } @@ -14165,7 +14165,7 @@ PHP_METHOD(Phalcon_Mvc_Model, getPrivateProperties) break; } ZVAL_LONG(&_0$$4, 4); - ZEPHIR_CALL_METHOD(&reflectionProperties, &reflection, "getproperties", &_1, 311, &_0$$4); + ZEPHIR_CALL_METHOD(&reflectionProperties, &reflection, "getproperties", &_1, 325, &_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 76dec60f70..207abd5590 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, 955, cache); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 982, 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, 956, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 983, &_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, 957, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 984, &_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, 955, cache); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 982, 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, 958, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 985, 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, 955, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 982, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cache, &_1); _2 = Z_TYPE_P(&cache) == IS_NULL; if (!(_2)) { @@ -454,7 +454,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Binder, getParamsFromReflection) ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 230, handler); zephir_check_call_status(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 955, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 982, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cache, &_0); ZEPHIR_CALL_METHOD(&methodParams, &reflection, "getparameters", NULL, 231); zephir_check_call_status(); diff --git a/ext/phalcon/mvc/model/criteria.zep.c b/ext/phalcon/mvc/model/criteria.zep.c index 27535c6ec8..d7e25f9cb2 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, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, 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, 960, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 987, 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, 960, &nextHiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 987, &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, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, 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, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 986, 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, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_0, 986, 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, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 986, 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, 961, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 988, 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, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, 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, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, 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, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, 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, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, 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, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, 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, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, 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, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, 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, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, 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, 960, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 987, 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, 960, &hiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 987, &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, 960, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 987, 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, 960, &nextHiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 987, &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, 960, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 987, 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, 960, &hiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 987, &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, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, 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, 961, &modelName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 988, &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, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 986, 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, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_0, 986, 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, 959, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 986, 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 f681a8d04f..212ce12bb7 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, 962, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 989, 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, 963, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 990, 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, 964, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 991, 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, 965, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 992, 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, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 993, 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, 967, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 994, 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, 968, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 995, 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, 969, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 996, 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, 970, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 997, 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, 971, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 998, 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, 972, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 999, 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, 973, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1000, &_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, 974, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1001, 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, 975, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1002, &_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, 974, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1001, 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, 976, &query); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1003, &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, 964, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 991, 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, 965, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 992, 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, 977, 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(&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, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 993, 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, 965, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 992, 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, 968, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 995, 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, 970, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 997, 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, 969, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 996, 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, 972, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 999, 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, 978, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1005, 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, 979, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1006, 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, 980, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 979, PH_NOISY_CC | PH_READONLY); + 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_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, 981, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1008, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 982, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1009, 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, 983, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 1010, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_2$$3, &writeService)) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 982, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 1009, 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, 984, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 1011, 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, 984, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1011, 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, 985, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1012, 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, 964, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 991, 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, 966, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 993, 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, 970, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 997, 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, 972, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12, this_ptr, _zephir_prop_3, 999, 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, 968, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16, this_ptr, _zephir_prop_4, 995, 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, 963, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 990, 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, 965, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 992, 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, 969, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 996, 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, 971, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_3, 998, 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, 967, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_4, 994, 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, 973, 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(&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, 982, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1009, 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, 982, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1009, 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, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1013, 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, 987, model); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 988, PH_NOISY_CC | PH_READONLY); + 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_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, 987, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1014, &__$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, 986, 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_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, 989, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1016, 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, 990, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1017, 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,7 +3568,7 @@ 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, 991, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1018, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_0, &className))) { ZEPHIR_INIT_VAR(&publicProperties); array_init(&publicProperties); @@ -3577,7 +3577,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, isVisibleModelProperty) ZEPHIR_CALL_METHOD(NULL, &classReflection, "__construct", NULL, 233, &className); zephir_check_call_status(); ZVAL_LONG(&_1$$3, 1); - ZEPHIR_CALL_METHOD(&reflectionProperties, &classReflection, "getproperties", NULL, 311, &_1$$3); + ZEPHIR_CALL_METHOD(&reflectionProperties, &classReflection, "getproperties", NULL, 325, &_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, 991, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 1018, 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, 974, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1001, 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, 962, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 989, 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, 988, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 1015, 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, 962, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 989, 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, 988, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 1015, 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, 977, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 1004, 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, 981, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1008, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 982, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1009, 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, 962, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 989, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, &entityName)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 962, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 989, 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, 962, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_0, 989, 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, 962, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$7, this_ptr, _zephir_prop_0, 989, 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, 962, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$3, this_ptr, _zephir_prop_0, 989, 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, 983, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1010, &_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, 974, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1001, 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, 988, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1015, 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, 980, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1007, &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, 981, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1008, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 981, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1008, &__$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, 974, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1001, 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, 986, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1013, 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 91791ab7d3..31910b72cf 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, 992, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1019, &_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 637d695344..69e60f953c 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, 993, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1020, &_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, 993, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1020, 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 d89dfba4b1..166561c5f6 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, 994, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1021, &_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, 994, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1021, 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 43a16ea88c..365528ab17 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, 995, &metaDataDir); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1022, &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, 995, 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_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, 995, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1022, 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 d6b7ff00e0..2fcbd52981 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, 996, &phql_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1023, &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, 997, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1024, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 997, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1024, &__$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, 997, &_0$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1024, &_0$$5); } ZEPHIR_INIT_VAR(&_2); array_init(&_2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 998, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1025, &_2); ZEPHIR_INIT_VAR(&_3); array_init(&_3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 999, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1026, &_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, 1000, &cacheOptions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1027, &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, 1001, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1028, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueRow, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1000, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1027, 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, 1002, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 1029, 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, 1003, &cache); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1030, &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, 998, PH_NOISY_CC); + zephir_read_property_cached(&defaultBindParams, this_ptr, _zephir_prop_4, 1025, 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, 999, PH_NOISY_CC); + zephir_read_property_cached(&defaultBindTypes, this_ptr, _zephir_prop_5, 1026, 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, 1004, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 1031, 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, 1001, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1028, 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, 1004, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1031, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_LONG(&_0, 309)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 998, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 999, PH_NOISY_CC | PH_READONLY); + 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); 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, 1005, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1032, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1023, 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, 1004, &_2$$7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1031, &_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, 1006, &ast); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1004, &type); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1033, &ast); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1031, &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, 1005, &irPhql); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1032, &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, 998, PH_NOISY_CC); + zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_0, 1025, 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, 998, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1025, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 998, &bindParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1025, &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, 999, PH_NOISY_CC); + zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_0, 1026, 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, 999, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1026, &_0$$4); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 999, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1026, &bindTypes); } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 999, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1026, &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, 1007, &manager); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1008, &metaData); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1002, container); + 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_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, 1005, &intermediate); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1032, &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, 1009, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1036, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1009, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1036, &__$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, 1010, transaction); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1037, 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, 1004, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1031, &_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, 1011, &resultsetRowClass_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1038, &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, 1001, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1028, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1001, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1028, &__$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, 1012, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1039, 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, 1007, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 1034, 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, 1007, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1034, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); zephir_memory_observe(&model); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1012, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1039, 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, 1008, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1035, 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, 1007, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1034, 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, 1012, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 1039, 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, 1012, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$9, this_ptr, _zephir_prop_1, 1039, 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, 1008, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1035, 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, 1012, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_31$$33, this_ptr, _zephir_prop_1, 1039, 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, 1012, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_59$$51, this_ptr, _zephir_prop_1, 1039, 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, 1009, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1036, 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, 1003, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_110, this_ptr, _zephir_prop_4, 1030, 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, 1011, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_111$$92, this_ptr, _zephir_prop_5, 1038, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_STRING_IDENTICAL(&_111$$92, "")) { - zephir_read_property_cached(&_112$$93, this_ptr, _zephir_prop_5, 1011, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_112$$93, this_ptr, _zephir_prop_5, 1038, 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, 1011, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_110, this_ptr, _zephir_prop_5, 1038, 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, 1012, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1039, 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, 1007, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 1034, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&model, &_2$$4, "load", NULL, 0, &modelName); zephir_check_call_status(); } @@ -3096,7 +3096,7 @@ 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, 378, &_18$$13); + ZEPHIR_CALL_FUNCTION(¶mKeys, "array_unique", &_19, 390, &_18$$13); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_20$$13); ZEPHIR_INIT_NVAR(&_20$$13); @@ -3289,7 +3289,7 @@ 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, 378, &_67$$30); + ZEPHIR_CALL_FUNCTION(¶mKeys, "array_unique", &_19, 390, &_67$$30); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_68$$30); ZEPHIR_INIT_NVAR(&_68$$30); @@ -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, 998, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_58$$52, this_ptr, _zephir_prop_0, 1025, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1023, 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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1040, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&models, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1014, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1041, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlAliases, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1015, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1042, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlAliasesModels, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1016, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1043, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlModelsAliases, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1017, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1044, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlAliasesModelsInstances, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 1012, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 1039, 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, 1007, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 1034, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$9, this_ptr, _zephir_prop_7, 1023, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$11, this_ptr, _zephir_prop_7, 1023, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$14, this_ptr, _zephir_prop_7, 1023, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$16, this_ptr, _zephir_prop_7, 1023, 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, 1013, &models); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1014, &sqlAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1015, &sqlAliasesModels); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1016, &sqlModelsAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1017, &sqlAliasesModelsInstances); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1012, &modelsInstances); + 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_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, 997, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_8, 1024, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_44$$28, this_ptr, _zephir_prop_7, 1023, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_64$$43, this_ptr, _zephir_prop_7, 1023, 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, 1007, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1034, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 1023, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$7, this_ptr, _zephir_prop_1, 1023, 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, 1018, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1045, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&nestingLevel, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1019, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1046, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, &nestingLevel)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1019, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1046, 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, 1008, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 1035, 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, 1014, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_3, 1041, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$7, this_ptr, _zephir_prop_4, 1023, 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, 1017, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$8, this_ptr, _zephir_prop_5, 1044, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$9, this_ptr, _zephir_prop_4, 1023, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$12, this_ptr, _zephir_prop_4, 1023, 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, 1012, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$14, this_ptr, _zephir_prop_6, 1039, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$17, this_ptr, _zephir_prop_4, 1023, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_30$$20, this_ptr, _zephir_prop_4, 1023, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_32$$21, this_ptr, _zephir_prop_4, 1023, 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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_34$$14, this_ptr, _zephir_prop_7, 1040, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_37$$23, this_ptr, _zephir_prop_4, 1023, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_41$$27, this_ptr, _zephir_prop_4, 1023, 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, 1010, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1037, 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, 1002, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 1029, 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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_0, 1040, 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, 1014, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$10, this_ptr, _zephir_prop_1, 1041, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$11, this_ptr, _zephir_prop_2, 1023, 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, 1015, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$10, this_ptr, _zephir_prop_3, 1042, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$6, this_ptr, _zephir_prop_0, 1023, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$8, this_ptr, _zephir_prop_0, 1023, 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, 1010, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1037, 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, 1006, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1033, 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, 1007, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1034, 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, 1013, &models); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1012, &modelsInstances); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1014, &sqlAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1017, &sqlAliasesModelsInstances); + 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_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, 1006, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1033, 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, 1007, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1034, 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, 1008, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1035, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$11, this_ptr, _zephir_prop_3, 1023, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$13, this_ptr, _zephir_prop_3, 1023, 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, 1006, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1033, 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, 1007, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 1034, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1008, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1035, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$17, this_ptr, _zephir_prop_3, 1023, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19$$27, this_ptr, _zephir_prop_3, 1023, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_33$$31, this_ptr, _zephir_prop_3, 1023, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_43$$36, this_ptr, _zephir_prop_3, 1023, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_53$$46, this_ptr, _zephir_prop_3, 1023, 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, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_66$$50, this_ptr, _zephir_prop_3, 1023, 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, 1013, &models); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1012, &modelsInstances); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1014, &sqlAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1015, &sqlAliasesModels); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1016, &sqlModelsAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1017, &sqlAliasesModelsInstances); + 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); } else { zephir_memory_observe(&tempModels); - zephir_read_property_cached(&tempModels, this_ptr, _zephir_prop_4, 1013, PH_NOISY_CC); + zephir_read_property_cached(&tempModels, this_ptr, _zephir_prop_4, 1040, PH_NOISY_CC); zephir_memory_observe(&tempModelsInstances); - zephir_read_property_cached(&tempModelsInstances, this_ptr, _zephir_prop_5, 1012, PH_NOISY_CC); + zephir_read_property_cached(&tempModelsInstances, this_ptr, _zephir_prop_5, 1039, PH_NOISY_CC); zephir_memory_observe(&tempSqlAliases); - zephir_read_property_cached(&tempSqlAliases, this_ptr, _zephir_prop_6, 1014, PH_NOISY_CC); + zephir_read_property_cached(&tempSqlAliases, this_ptr, _zephir_prop_6, 1041, PH_NOISY_CC); zephir_memory_observe(&tempSqlAliasesModels); - zephir_read_property_cached(&tempSqlAliasesModels, this_ptr, _zephir_prop_7, 1015, PH_NOISY_CC); + zephir_read_property_cached(&tempSqlAliasesModels, this_ptr, _zephir_prop_7, 1042, PH_NOISY_CC); zephir_memory_observe(&tempSqlModelsAliases); - zephir_read_property_cached(&tempSqlModelsAliases, this_ptr, _zephir_prop_8, 1016, PH_NOISY_CC); + zephir_read_property_cached(&tempSqlModelsAliases, this_ptr, _zephir_prop_8, 1043, PH_NOISY_CC); zephir_memory_observe(&tempSqlAliasesModelsInstances); - zephir_read_property_cached(&tempSqlAliasesModelsInstances, this_ptr, _zephir_prop_9, 1017, PH_NOISY_CC); + zephir_read_property_cached(&tempSqlAliasesModelsInstances, this_ptr, _zephir_prop_9, 1044, 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, 1018, PH_NOISY_CC); + zephir_read_property_cached(&_114, this_ptr, _zephir_prop_10, 1045, 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, 1013, &tempModels); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1012, &tempModelsInstances); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1014, &tempSqlAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1015, &tempSqlAliasesModels); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1016, &tempSqlModelsAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1017, &tempSqlAliasesModelsInstances); + 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); } 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, 1006, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1033, 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, 1007, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1034, 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, 1013, &models); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1012, &modelsInstances); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1014, &sqlAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1015, &sqlAliasesModels); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1016, &sqlModelsAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1017, &sqlAliasesModelsInstances); + 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_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, 1007, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1034, 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 dd531229ff..b5e50789f3 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, 1020, &conditions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1047, &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, 1020, &conditions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1047, &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, 1020, &_7$$7); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1021, &mergedParams); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1022, &mergedTypes); + 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_memory_observe(&bind); if (zephir_array_isset_string_fetch(&bind, params, SL("bind"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1021, &bind); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1048, &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, 1022, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1049, &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, 1023, &distinct); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1050, &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, 1024, &fromClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1051, &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, 1025, &columns); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1052, &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, 1026, &joinsClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1053, &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, 1027, &havingClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1054, &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, 1028, &orderClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1055, &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, 1029, &limit); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1056, &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, 1030, &offset); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 1057, &offset); } } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1029, &limitClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1056, &limitClause); } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1029, &limitClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1056, &limitClause); } } if (zephir_array_isset_string_fetch(&offsetClause, params, SL("offset"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 1030, &offsetClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 1057, &offsetClause); } if (zephir_array_isset_string_fetch(&forUpdate, params, SL("for_update"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 1031, &forUpdate); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 1058, &forUpdate); } if (zephir_array_isset_string_fetch(&sharedLock, params, SL("shared_lock"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_12, 1032, &sharedLock); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_12, 1059, &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, 1020, params); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1047, params); } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 1033, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 1060, 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, 1024, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1051, 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, 1024, &models); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1051, &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, 1027, PH_NOISY_CC); + zephir_read_property_cached(¤tConditions, this_ptr, _zephir_prop_0, 1054, 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, 1020, PH_NOISY_CC); + zephir_read_property_cached(¤tConditions, this_ptr, _zephir_prop_0, 1047, 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, 1025, columns); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1052, 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, 1023, distinct); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1050, 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, 1031, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1058, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1031, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1058, &__$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, 1024, models); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1051, 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, 1024, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1051, 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, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1060, 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, 1033, &container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1060, &container); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1024, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1051, 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, 1020, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1047, 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, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1050, 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, 1025, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1052, 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, 1026, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 1053, 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, 1034, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 1061, 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, 1027, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_7, 1054, 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, 1028, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_8, 1055, 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, 1029, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_9, 1056, 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, 1030, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_105$$88, this_ptr, _zephir_prop_10, 1057, 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, 1031, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_11, 1058, 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, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1060, 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, 1021, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1048, 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, 1022, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1049, 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, 1032, PH_NOISY_CC); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_3, 1059, 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, 1032, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_3, 1059, 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, 1035, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1062, 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, 1035, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$7, this_ptr, _zephir_prop_4, 1062, 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, 1034, group); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1061, 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, 1027, &conditions_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1054, &conditions_zv); zephir_memory_observe(¤tBindParams); - zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_1, 1021, PH_NOISY_CC); + zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_1, 1048, 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, 1021, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1048, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1021, &bindParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1048, &bindParams); } zephir_memory_observe(¤tBindTypes); - zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_2, 1022, PH_NOISY_CC); + zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_2, 1049, 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, 1022, &_1$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1049, &_1$$5); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1022, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1049, &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, 1029, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1056, &_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, 1030, &_3$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1057, &_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, 1030, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1057, &_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, 1027, PH_NOISY_CC); + zephir_read_property_cached(¤tConditions, this_ptr, _zephir_prop_0, 1054, 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, 1020, PH_NOISY_CC); + zephir_read_property_cached(¤tConditions, this_ptr, _zephir_prop_0, 1047, 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, 1028, orderBy); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1055, 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, 1021, PH_NOISY_CC); + zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_0, 1048, 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, 1021, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1048, &_0$$4); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1021, &bindParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1048, &bindParams); } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1021, &bindParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1048, &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, 1022, PH_NOISY_CC); + zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_0, 1049, 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, 1022, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1049, &_0$$4); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1022, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1049, &bindTypes); } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1022, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1049, &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, 1033, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1060, 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, 1035, &resultsetRowClass_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1062, &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, 1020, &conditions_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1047, &conditions_zv); if (zephir_fast_count_int(&bindParams) > 0) { zephir_memory_observe(¤tBindParams); - zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_1, 1021, PH_NOISY_CC); + zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_1, 1048, 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, 1021, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1048, &_0$$4); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1021, &bindParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1048, &bindParams); } } if (zephir_fast_count_int(&bindTypes) > 0) { - zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_2, 1022, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_2, 1049, 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, 1022, &_1$$7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1049, &_1$$7); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1022, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1049, &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, 1036, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 1063, 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, 1036, &nextHiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1063, &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, 1036, PH_NOISY_CC); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 1063, 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, 1036, &_14); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1063, &_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, 1036, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 1063, 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, 1036, &nextHiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1063, &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, 1036, PH_NOISY_CC); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 1063, 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, 1036, &_14); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1063, &_14); RETURN_THIS(); } diff --git a/ext/phalcon/mvc/model/query/status.zep.c b/ext/phalcon/mvc/model/query/status.zep.c index 95db53e531..d7eda0db2e 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, 1037, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1064, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1037, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1064, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1038, model); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1065, 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, 1038, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1065, 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 676a8e39ce..11e9d37e9a 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, 1039, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1040, &referencedModel_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1041, fields); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1042, referencedFields); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1043, &options); + 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_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, 1043, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1070, 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, 1043, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1070, 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, 1043, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1070, 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, 1043, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1070, 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, 1039, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1066, 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, 1043, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1070, 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, 1044, intermediateFields); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1045, &intermediateModel_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1046, intermediateReferencedFields); + 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); } 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 523f829ab6..dfb0205d8c 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, 1047, columnTypes); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1048, &resultsetRowClass_zv); + 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_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, 1049, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1076, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cache, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1047, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1074, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&columnTypes, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1050, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1077, 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, 1051, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1078, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1051, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1078, &__$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, 1052, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1079, &_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, 1053, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1080, &_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, 1049, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1076, &_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, 1047, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1074, &_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, 1050, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1077, &_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, 1054, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1081, 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, 1055, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1082, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&row, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1051, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1078, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1054, &row); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1081, &row); RETURN_CCTOR(&row); } if (Z_TYPE_P(&row) != IS_ARRAY) { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1054, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1081, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1054, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1081, &__$false); } RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1050, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1077, 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, 1048, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$6, this_ptr, _zephir_prop_4, 1075, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_STRING_IDENTICAL(&_2$$6, "")) { - zephir_read_property_cached(&_3$$7, this_ptr, _zephir_prop_4, 1048, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$7, this_ptr, _zephir_prop_4, 1075, 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, 1047, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_5, 1074, 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, 1054, &activeRow); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1081, &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, 1049, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1076, 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, 1047, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1074, 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, 1050, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1077, 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, 1051, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1078, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1051, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1078, &__$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, 1052, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1079, &_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, 1053, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1080, &_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, 1049, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1076, &_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, 1047, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1074, &_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, 1050, &_11); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1077, &_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 4f07d40859..e8d73adb2e 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, 1056, model); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1057, columnMap); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1083, model); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1084, columnMap); if (keepSnapshots) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1058, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1085, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1058, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1085, &__$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, 1056, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1083, 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, 1059, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1086, 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, 1057, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1084, 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, 1060, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1087, 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, 1058, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1085, 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, 1056, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1083, &_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, 1061, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1088, &_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, 1062, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1089, &_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, 1059, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1086, &_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, 1057, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1084, &_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, 1060, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1087, &_6); if (zephir_array_isset_string_fetch(&keepSnapshots, &data, SL("keepSnapshots"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1058, &keepSnapshots); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1085, &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, 1063, 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, 1064, 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); if (Z_TYPE_P(&row) != IS_ARRAY) { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1063, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1090, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1063, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1090, &__$false); } RETURN_MM_NULL(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1060, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1087, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&hydrateMode, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1057, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1084, 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, 1056, PH_NOISY_CC); + zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_4, 1083, 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, 1056, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$7, this_ptr, _zephir_prop_4, 1083, 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, 1056, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_5, 1058, PH_NOISY_CC | PH_READONLY); + 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); 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, 1056, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_10$$9, this_ptr, _zephir_prop_5, 1058, PH_NOISY_CC | PH_READONLY); + 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); 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, 1063, &activeRow); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1090, &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, 1056, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1083, 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, 1059, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1086, 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, 1057, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1084, 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, 1060, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1087, 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, 1058, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_4, 1085, 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, 1061, PH_NOISY_CC); + zephir_read_property_cached(&records, this_ptr, _zephir_prop_0, 1088, PH_NOISY_CC); if (Z_TYPE_P(&records) != IS_ARRAY) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_1, 1065, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_1, 1092, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&result, &_0$$3); - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_2, 1064, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_2, 1091, 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, 1064, &__$null); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1061, &records); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1091, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1088, &records); } _1 = renameColumns; if (_1) { zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_3, 1056, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_3, 1083, 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, 1057, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_4, 1084, 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, 1056, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1083, &_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, 1061, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1088, &_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, 1062, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1089, &_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, 1059, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1086, &_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, 1057, &_11); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1084, &_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, 1060, &_12); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1087, &_12); if (zephir_array_isset_string_fetch(&keepSnapshots, &resultset, SL("keepSnapshots"), 1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1058, &keepSnapshots); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1085, &keepSnapshots); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/mvc/model/row.zep.c b/ext/phalcon/mvc/model/row.zep.c index b15eb4d6e0..a676368398 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, 299, this_ptr); + ZEPHIR_RETURN_CALL_FUNCTION("get_object_vars", NULL, 313, 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 5f5ac324f5..1682c12b07 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, 1066, &connection); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1093, &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, 1066, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1093, 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, 1067, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1094, 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, 1066, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1093, 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, 1068, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1095, 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, 1067, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1094, 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, 1066, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1093, 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, 1067, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1094, 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, 1066, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1093, 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, 1069, rollbackRecord); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1096, rollbackRecord); } - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 1070, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 1097, 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, 1069, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$7, this_ptr, _zephir_prop_2, 1096, 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, 1071, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1098, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1071, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1098, &__$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, 1068, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1095, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1068, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1095, &__$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, 1069, record); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1096, 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, 1067, manager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1094, 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, 1070, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1097, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1070, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1097, &__$false); } RETURN_THISW(); } diff --git a/ext/phalcon/mvc/model/transaction/failed.zep.c b/ext/phalcon/mvc/model/transaction/failed.zep.c index ef7b73720c..af2beee459 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, 1072, record); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1099, 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, 1072, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1099, 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 b6e177e453..23b4b6249b 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, 1073, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1100, 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, 1074, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1101, 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, 1074, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1101, &_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, 1074, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1101, 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, 1075, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1102, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1076, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1103, 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, 1075, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1102, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1075, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1102, &__$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, 1073, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1100, 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, 1077, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1104, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 1074, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 1101, 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, 1078, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_3, 1105, 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, 1077, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1104, 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, 1074, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1101, 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, 1078, &service_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1105, &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, 1073, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1100, 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, 1076, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1103, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1076, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1103, &__$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, 1074, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1101, 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, 1074, &newTransactions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1101, &newTransactions); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/mvc/model/validationfailed.zep.c b/ext/phalcon/mvc/model/validationfailed.zep.c index 89af4e9486..397462adc4 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, 1079, model); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1080, &validationMessages); + 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_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/annotations.zep.c b/ext/phalcon/mvc/router/annotations.zep.c index fd3a78e599..c3b000218d 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, 1081, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1108, 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, 1082, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1109, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&handlers, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1083, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1110, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&controllerSuffix, &_0); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "annotations"); @@ -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, 1084, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1111, &__$null); ZEPHIR_OBS_NVAR(&moduleName); zephir_array_isset_long_fetch(&moduleName, &scope, 2, 0); ZEPHIR_INIT_NVAR(&_14$$4); @@ -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, 1084, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1111, &__$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, 1085, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1112, 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, 1084, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1111, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&routePrefix, &_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1086, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1113, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_2) != IS_NULL) { - zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_2, 1086, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_2, 1113, 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, 1084, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1111, &_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, 1085, &actionSuffix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1112, &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, 1086, callback); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1113, 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, 1086, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1113, &_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, 1083, &controllerSuffix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1110, &controllerSuffix_zv); RETURN_THISW(); } diff --git a/ext/phalcon/mvc/router/group.zep.c b/ext/phalcon/mvc/router/group.zep.c index c9ac861800..bf3181ddc6 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, 1087, paths); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1114, 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, 1088, beforeMatch); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1115, 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, 1089, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1116, &_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, 1090, &hostname_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1117, &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, 1087, paths); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1114, 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, 1091, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1118, &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, 1087, PH_NOISY_CC); + zephir_read_property_cached(&defaultPaths, this_ptr, _zephir_prop_0, 1114, 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,7 +962,7 @@ 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, 1091, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1118, 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); diff --git a/ext/phalcon/mvc/router/route.zep.c b/ext/phalcon/mvc/router/route.zep.c index fa11336fdc..ef6c3cd1f5 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, 1092, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1119, &_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, 1093, callback); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1120, 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, 1094, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1121, 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, 1095, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1122, 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, 1094, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1121, &__$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, 1094, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1121, &__$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, 1094, ®exHostName); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1121, ®exHostName); RETURN_CCTOR(®exHostName); } @@ -733,7 +733,7 @@ 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, 1096, PH_NOISY_CC | PH_READONLY); + 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_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, 1097, callback); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1124, 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, 1098, &pattern_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1099, &compiledPattern); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1096, &routePaths); + 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_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, 1100, group); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1127, 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, 1095, &hostname_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1122, &hostname_zv); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1094, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1121, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1094, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1121, &__$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, 1101, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1128, &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, 1092, &routeId_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1119, &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, 1102, httpMethods); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1129, httpMethods); RETURN_THISW(); } diff --git a/ext/phalcon/mvc/url.zep.c b/ext/phalcon/mvc/url.zep.c index 27b2442b29..6c723cd45c 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, 1103, router); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1130, 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, 1103, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$9, this_ptr, _zephir_prop_0, 1130, 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, 1104, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$11, this_ptr, _zephir_prop_1, 1131, 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, 1103, &router); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1130, &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, 1105, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1132, 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, 1105, &baseUri); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1132, &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, 1106, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1133, 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, 1107, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1134, 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, 1107, &basePath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1134, &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, 1105, &baseUri_zv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1106, PH_NOISY_CC | PH_READONLY); + 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); if (Z_TYPE_P(&_0) == IS_NULL) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1106, &baseUri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1133, &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, 1106, &staticBaseUri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1133, &staticBaseUri_zv); RETURN_THISW(); } diff --git a/ext/phalcon/mvc/view.zep.c b/ext/phalcon/mvc/view.zep.c index 0fb93eba51..7560275e3f 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, 1108, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1135, &options); ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1109, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1136, &_0); ZEPHIR_INIT_VAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1110, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1137, &_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, 1110, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1137, 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, 1111, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1138, &_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, 1112, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1139, &_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, 1113, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1140, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1113, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1140, &__$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, 1114, level); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1141, 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, 1113, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1140, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1113, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1140, &__$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, 1115, PH_NOISY_CC); + zephir_read_property_cached(&activeRenderPath, this_ptr, _zephir_prop_0, 1142, 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, 1116, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1143, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&basePath, &_0); zephir_memory_observe(&engines); - zephir_read_property_cached(&engines, this_ptr, _zephir_prop_1, 1109, PH_NOISY_CC); + zephir_read_property_cached(&engines, this_ptr, _zephir_prop_1, 1136, 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, 1110, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1137, 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, 1110, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1137, &_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, 1117, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1144, 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, 1110, &viewParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1137, &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, 1118, &pickView); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1145, &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, 1119, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1113, PH_NOISY_CC | PH_READONLY); + 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); 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, 1120, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1147, &_1$$3); RETURN_MM_BOOL(0); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1121, &controllerName_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1122, &actionName_zv); + 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_CALL_METHOD(NULL, this_ptr, "setvars", NULL, 0, ¶ms); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_5, 1123, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_5, 1150, 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, 1124, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_6, 1151, 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, 1118, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_7, 1145, 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, 1125, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_8, 1152, 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, 1120, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1147, &_8); silence = 1; - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_9, 1114, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_9, 1141, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&disabledLevels, &_2); zephir_memory_observe(&_9); - zephir_read_property_cached(&_9, this_ptr, _zephir_prop_10, 1126, PH_NOISY_CC); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_10, 1153, 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, 1119, &_10$$15); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1146, &_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, 1119, &_11$$17); - zephir_read_property_cached(&_11$$17, this_ptr, _zephir_prop_11, 1112, PH_NOISY_CC | PH_READONLY); + 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_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, 1119, &_19$$21); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1146, &_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, 1119, &_21$$23); - zephir_read_property_cached(&_21$$23, this_ptr, _zephir_prop_12, 1111, PH_NOISY_CC | PH_READONLY); + 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_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, 1119, &_29$$27); - zephir_read_property_cached(&_29$$27, this_ptr, _zephir_prop_13, 1127, PH_NOISY_CC | PH_READONLY); + 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); 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, 1119, &_31$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1146, &_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, 1109, &engines); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1136, &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, 1113, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1140, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1113, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1140, &__$false); } if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1128, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1155, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1128, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1155, &__$false); } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 5); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1126, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1153, &_0); ZEPHIR_INIT_VAR(&_1); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1120, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1147, &_1); ZEPHIR_INIT_NVAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1112, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1139, &_1); ZEPHIR_INIT_VAR(&_2); array_init(&_2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1111, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1138, &_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, 1116, &basePath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1143, &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, 1125, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1152, 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, 1124, &layout_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1151, &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, 1123, &layoutsDir_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1150, &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, 1127, &viewPath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1154, &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, 1117, &partialsDir_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1144, &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, 1126, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1153, &_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, 1111, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1138, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1111, templateAfter); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1138, 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, 1112, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1139, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1112, templateBefore); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1139, 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, 1110, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1137, PH_NOISY_CC | PH_READONLY); zephir_fast_array_merge(&_0$$3, &_1$$3, ¶ms); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1110, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1137, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1110, ¶ms); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1137, ¶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, 1129, &_2$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1156, &_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, 1129, &newViewsDir); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1156, &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, 1120, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1147, &_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, 1116, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1143, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&basePath, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1110, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1137, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&viewParams, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1125, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1152, 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, 1115, &_10$$8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1142, &_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, 1115, &_20$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1142, &_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, 1115, &_34$$21); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1142, &_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, 1115, &_44$$26); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1142, &_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, 1115, &viewEnginePaths); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1142, &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, 1129, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1156, 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, 1129, PH_NOISY_CC); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1156, 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, 1128, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1155, 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, 1130, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1157, 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, 1109, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 1136, 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, 1128, &engines); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1155, &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, 1110, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1137, 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, 1109, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1136, 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, 1110, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1137, 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, 1120, &content_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1147, &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 f047059a5c..e6235c128c 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, 1131, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$7, this_ptr, _zephir_prop_0, 1158, 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 8ea7bf36bc..54ef33f20e 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, 1132, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1159, 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, 1133, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1160, 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, 1134, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1161, 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, 1135, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 1162, 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, 1136, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_3, 1163, 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, 1133, &compiler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1160, &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, 1135, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1162, 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, 1137, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1164, 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, 1134, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$11, this_ptr, _zephir_prop_1, 1161, 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, 1137, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1164, 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, 1136, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1163, &options); ZEPHIR_MM_RESTORE(); } @@ -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, 407, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &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 0475e07ed4..645f1caaa2 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, 1138, view); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1165, 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, 1139, PH_NOISY_CC); + zephir_read_property_cached(&level, this_ptr, _zephir_prop_0, 1166, 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, 1140, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_1, 1167, 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, 1140, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 1167, 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, 1141, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1168, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1141, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1168, &__$false); } if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1142, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1169, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1142, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1169, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1143, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1170, &__$null); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1144, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1171, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1139, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1166, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1145, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1172, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1146, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1173, &_0); ZEPHIR_INIT_VAR(&compilation); ZVAL_NULL(&compilation); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_7, 1147, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_7, 1174, 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, 1148, &compiledTemplatePath); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1175, &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, 1149, PH_NOISY_CC); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1149, &autoescape); + 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_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, 1149, &oldAutoescape); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1176, &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, 1149, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 1176, 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, 1150, &path_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1177, &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, 1139, PH_NOISY_CC); + zephir_read_property_cached(&level, this_ptr, _zephir_prop_0, 1166, 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, 1151, PH_NOISY_CC); + zephir_read_property_cached(&loopContext, this_ptr, _zephir_prop_1, 1178, 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, 1153, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1180, 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, 1150, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1177, &_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, 1154, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1181, 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, 1154, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1181, 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, 1154, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_0, 1181, 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, 1155, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_1, 1182, 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, 1142, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$15, this_ptr, _zephir_prop_2, 1169, 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, 1156, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$16, this_ptr, _zephir_prop_3, 1183, 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, 1146, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$17, this_ptr, _zephir_prop_4, 1173, 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, 1140, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_5, 1167, 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, 1140, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$5, this_ptr, _zephir_prop_5, 1167, 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, 1140, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$28, this_ptr, _zephir_prop_5, 1167, 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, 1147, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1174, 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, 1157, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1184, 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, 1150, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 1177, PH_NOISY_CC | PH_READONLY); zephir_unique_path_key(&_1$$3, &_2$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1157, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1184, &_1$$3); } zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1157, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1184, 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, 1157, PH_NOISY_CC); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_0, 1184, 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, 1157, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$5, this_ptr, _zephir_prop_0, 1184, 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, 1157, &_5$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1184, &_5$$5); } } zephir_memory_observe(&_8); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 1157, PH_NOISY_CC); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 1184, 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, 1140, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1167, 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, 1147, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1174, &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, 1157, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1184, &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, 1150, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1177, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(¤tPath, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1147, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1174, 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, 1149, &autoescape); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1176, &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, 1141, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_3, 1168, 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, 1143, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$7, this_ptr, _zephir_prop_4, 1170, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&blocks, &_6$$7); - zephir_read_property_cached(&_6$$7, this_ptr, _zephir_prop_5, 1142, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$7, this_ptr, _zephir_prop_5, 1169, 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, 1156, &name); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1183, &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, 1156, &name); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1183, &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, 1150, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 1177, 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, 1138, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1165, 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, 1154, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 1181, 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, 1158, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 1185, 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, 1140, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$30, this_ptr, _zephir_prop_2, 1167, 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, 1140, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$30, this_ptr, _zephir_prop_2, 1167, 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, 1140, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$41, this_ptr, _zephir_prop_2, 1167, 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, 1140, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_30$$41, this_ptr, _zephir_prop_2, 1167, 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, 1141, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1168, 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, 1154, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1181, 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, 1143, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_34$$20, this_ptr, _zephir_prop_2, 1170, 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, 1143, &blocks); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1170, &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, 1141, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1168, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1141, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1168, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1142, &tempCompilation); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1169, &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, 1143, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_89$$54, this_ptr, _zephir_prop_2, 1170, 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, 1143, &blocks); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1170, &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, 1141, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1168, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1141, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1168, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1142, &tempCompilation); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1169, &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, 1145, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&level, this_ptr, _zephir_prop_4, 1172, 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 380c939cc1..79b660fc28 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, 1159, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1186, &options); ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1160, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1187, &_0); ZEPHIR_INIT_VAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1161, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1188, &_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, 1161, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1188, 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, 1161, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1188, 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, 1161, &viewParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1188, &viewParams); } ZEPHIR_CALL_FUNCTION(NULL, "ob_end_clean", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1162, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1189, 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, 1160, &engines); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1187, &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, 1161, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1188, 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, 1163, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1190, 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, 1161, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1188, 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, 1161, ¶ms); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1188, ¶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, 1164, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1191, &_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, 1165, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1192, 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, 1166, PH_NOISY_CC); + zephir_read_property_cached(&di, this_ptr, _zephir_prop_1, 1193, PH_NOISY_CC); ZEPHIR_INIT_NVAR(&engines); array_init(&engines); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 1160, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 1187, 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, 1165, &engines); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1192, &engines); } else { - zephir_read_property_cached(&_20$$19, this_ptr, _zephir_prop_0, 1165, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$19, this_ptr, _zephir_prop_0, 1192, 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, 1163, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1190, 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, 1167, &path_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1194, &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, 1164, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1191, 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, 1161, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1188, 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, 1160, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1187, 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, 1161, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1188, 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, 1162, &content_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1189, &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 24d086dbd8..c3c8a40522 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, 1168, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1195, 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, 1169, 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); } @@ -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, 1168, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1195, 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, 1170, &content_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1197, &content_zv); RETURN_THISW(); } diff --git a/ext/phalcon/paginator/adapter/model.zep.c b/ext/phalcon/paginator/adapter/model.zep.c index 1f78094c74..5773a80e25 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, 1171, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1198, PH_NOISY_CC); limit = zephir_get_intval(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1172, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1199, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&config, &_1); zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1173, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1200, 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, 1171, PH_NOISY_CC); + zephir_read_property_cached(&_14, this_ptr, _zephir_prop_0, 1198, 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 ede12fa3f6..30f70e57bc 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, 1174, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1201, 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, 1175, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1202, PH_NOISY_CC); show = zephir_get_intval(&_2); zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1176, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1203, PH_NOISY_CC); pageNumber = zephir_get_intval(&_3); if (pageNumber <= 0) { pageNumber = 1; @@ -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, 1175, PH_NOISY_CC); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1202, 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 9cd5dd16af..c4a37fe257 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, 1177, &columns); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1204, &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, 1178, PH_NOISY_CC); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1177, PH_NOISY_CC | PH_READONLY); + 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_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, 1179, PH_NOISY_CC); + zephir_read_property_cached(&limit, this_ptr, _zephir_prop_2, 1206, PH_NOISY_CC); zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1180, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1207, 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, 1179, PH_NOISY_CC); + zephir_read_property_cached(&_44, this_ptr, _zephir_prop_2, 1206, 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, 1178, builder); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1205, builder); RETURN_THISW(); } diff --git a/ext/phalcon/paginator/adapter/querybuildercursor.zep.c b/ext/phalcon/paginator/adapter/querybuildercursor.zep.c index a1518b7333..7f30e003cb 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, 1181, &cursorColumn); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1208, &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, 1182, &cursor); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1209, &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, 1182, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1209, 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, 1182, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1209, 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, 1183, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1210, 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, 1184, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1211, PH_NOISY_CC); limit = zephir_get_intval(&_2); zephir_memory_observe(¤tCursor); - zephir_read_property_cached(¤tCursor, this_ptr, _zephir_prop_2, 1182, PH_NOISY_CC); + zephir_read_property_cached(¤tCursor, this_ptr, _zephir_prop_2, 1209, 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, 1181, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_3, 1208, 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, 1181, PH_NOISY_CC); + zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_3, 1208, 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, 1181, PH_NOISY_CC); + zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_3, 1208, 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, 1184, PH_NOISY_CC); + zephir_read_property_cached(&_13, this_ptr, _zephir_prop_1, 1211, 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, 1182, cursor); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1209, 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, 1183, builder); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1210, builder); RETURN_THISW(); } diff --git a/ext/phalcon/paginator/exceptions/missingrequiredparameter.zep.c b/ext/phalcon/paginator/exceptions/missingrequiredparameter.zep.c index f60a802caf..bdf1af7a82 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, 1185, ¶meter_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1212, ¶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 7f5e1ee3fb..c1c695da90 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, 1186, &aliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1213, &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, 1187, &properties); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1214, &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, 1187, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1214, 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, 1186, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1213, 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 b5e98a6458..b0db2b163c 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, 1188, &host_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1215, &host_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, port); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1189, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1216, &_0); if (persistent) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1190, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1217, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1190, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1217, &__$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, 1191, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1218, &_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, 1192, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1219, 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, 1190, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1217, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { - zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_2, 1188, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 1189, PH_NOISY_CC | PH_READONLY); + 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); 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, 1188, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6$$5, this_ptr, _zephir_prop_3, 1189, PH_NOISY_CC | PH_READONLY); + 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); 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, 1192, &connection); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1219, &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, 1192, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1219, 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, 1192, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1219, &__$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, 1191, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 1218, 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, 1192, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1219, 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, 1193, &tube_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1220, &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, 1192, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1219, 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, 1193, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1220, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_STRING(&_0, "default")) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1193, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1220, 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, 1191, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1218, 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, 1191, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 1218, 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 69e0d6f202..4ad13e2be9 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, 1194, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1221, &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, 1194, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1221, 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 bcdf41d88c..596555eb14 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, 1195, connection); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1196, 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_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, 1195, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1222, 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, 1195, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1222, 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, 1195, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1222, 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, 1195, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1222, 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, 1195, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 1222, 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, 1195, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1222, 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 3e0e746d82..c2c485411d 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, 1197, &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, 1198, &_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, 1199, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1226, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1199, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1226, &__$false); } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, ttr); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1200, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1227, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1201, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1228, &_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, 1202, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1229, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1202, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1229, 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, 1202, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1229, &__$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, 1201, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1228, 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, 1202, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1229, 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, 1202, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1229, &_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, 1197, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1198, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1199, PH_NOISY_CC | PH_READONLY); + 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_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 5efc703ee5..b3a49ddcb5 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, 1203, &jobId_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1230, &jobId_zv); } diff --git a/ext/phalcon/queue/adapter/beanstalk/beanstalkproducer.zep.c b/ext/phalcon/queue/adapter/beanstalk/beanstalkproducer.zep.c index afb46a4704..92a622e419 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, 1204, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1231, 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, 1205, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1232, 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, 1205, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1232, 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, 1206, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 1233, 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, 1206, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 1233, 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, 1204, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 1231, 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, 1204, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 1231, 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, 1206, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1233, &_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, 1205, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1232, &_0); RETURN_THIS(); } diff --git a/ext/phalcon/queue/adapter/beanstalk/beanstalksubscriptionconsumer.zep.c b/ext/phalcon/queue/adapter/beanstalk/beanstalksubscriptionconsumer.zep.c index cf0057948c..7e6b441957 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, 1207, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1234, context); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1208, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1235, &_0); } diff --git a/ext/phalcon/queue/adapter/genericqueue.zep.c b/ext/phalcon/queue/adapter/genericqueue.zep.c index 2f7adb9ff6..fe66acb0d2 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, 1209, &queueName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1236, &queueName_zv); } /** diff --git a/ext/phalcon/queue/adapter/generictopic.zep.c b/ext/phalcon/queue/adapter/generictopic.zep.c index 9d04ac6c23..932fc771c6 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, 1210, &topicName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1237, &topicName_zv); } /** diff --git a/ext/phalcon/queue/adapter/memory/memoryconnectionfactory.zep.c b/ext/phalcon/queue/adapter/memory/memoryconnectionfactory.zep.c index 0f27db8807..a95abba677 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, 1211, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1238, &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 644356fc6b..d4b18da750 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, 1212, context); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1213, 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); } /** @@ -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, 1212, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1213, PH_NOISY_CC | PH_READONLY); + 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_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, 1212, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1213, PH_NOISY_CC | PH_READONLY); + 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_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 a62fc4fe8e..d51309bc5d 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, 1214, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1241, &_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, 1214, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1241, 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, 1214, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1241, 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 c15b95e0e6..723792e160 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, 1215, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1242, 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, 1215, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1242, 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 99a2eebad4..032357d9bf 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, 1216, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1243, context); } diff --git a/ext/phalcon/queue/adapter/redis/redisconnectionfactory.zep.c b/ext/phalcon/queue/adapter/redis/redisconnectionfactory.zep.c index d2f3f2b406..ebafe6681b 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, 1217, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1244, &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, 1217, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1244, 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 273fb2100b..f6880f5b3e 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, 1218, context); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1219, 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); } /** @@ -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, 1219, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1246, 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, 1218, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 1245, 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, 1218, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1219, PH_NOISY_CC | PH_READONLY); + 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_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, 1218, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1219, PH_NOISY_CC | PH_READONLY); + 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_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 0c6b6cbf87..74e08b8be0 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, 1220, redis); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1221, &prefix_zv); + 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); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1222, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1249, &_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, 1220, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1247, 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, 1222, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1249, 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, 1220, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1247, 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, 1220, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1247, 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, 1220, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1247, 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, 1220, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 1247, 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, 1220, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 1247, 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, 1221, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1248, 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, 1221, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1248, 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, 1220, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1247, 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, 1220, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_0, 1247, 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, 1220, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$5, this_ptr, _zephir_prop_0, 1247, 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, 1220, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_0, 1247, 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, 1220, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$7, this_ptr, _zephir_prop_0, 1247, 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 56c9843411..27c33694ca 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, 1223, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1250, 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, 1224, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1251, 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, 1224, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1251, 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, 1223, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1250, 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, 1224, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1251, &_0); RETURN_THIS(); } diff --git a/ext/phalcon/queue/adapter/redis/redissubscriptionconsumer.zep.c b/ext/phalcon/queue/adapter/redis/redissubscriptionconsumer.zep.c index ea5c91d5bb..fc14330a36 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, 1225, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1252, context); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1226, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1253, &_0); } diff --git a/ext/phalcon/queue/adapter/stream/streamconnectionfactory.zep.c b/ext/phalcon/queue/adapter/stream/streamconnectionfactory.zep.c index 6a4fa9279a..c5ce54364f 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, 1227, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1254, &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, 1227, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1254, 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, 1227, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1254, 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, 1227, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1254, 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, 1227, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 1254, 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 2536201313..b615ea2500 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, 1228, context); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1229, queue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1255, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1256, queue); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1230, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1257, &_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, 1228, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1229, PH_NOISY_CC | PH_READONLY); + 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_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, 1228, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1229, PH_NOISY_CC | PH_READONLY); + 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_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 86c01e4cd4..d9748b0b3d 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, 1231, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1258, &_2); ZVAL_UNDEF(&_3); ZVAL_LONG(&_3, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1232, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1259, &_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, 1232, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1259, 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, 1232, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1259, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, this_ptr, &_0); zephir_check_call_status(); RETURN_MM(); @@ -457,11 +457,11 @@ 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, 1231, PH_NOISY_CC | PH_READONLY); + 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_check_call_status(); if (!(zephir_is_true(&_1))) { - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 1231, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 1258, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_3$$3, 0777); ZEPHIR_CALL_FUNCTION(NULL, "mkdir", NULL, 289, &_2$$3, &_3$$3, &__$true); zephir_check_call_status(); @@ -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, 1231, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1258, 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 f0691276cf..ee3694319c 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, 1233, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1260, 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, 1233, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1260, 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 a49d7d4916..3cdb572eb9 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, 1234, 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, 1235, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1262, &_0); } diff --git a/ext/phalcon/queue/adapter/traits/messagetrait.zep.c b/ext/phalcon/queue/adapter/traits/messagetrait.zep.c index fabd6a6b91..8ea941a45b 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, 1236, &body_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1237, &properties); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1238, &headers); + 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_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, 1238, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1265, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_0, &name_zv)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1238, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1265, 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, 1238, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1265, 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, 1237, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1264, 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, 1237, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1264, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_0, &name_zv)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1237, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1264, 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, 1236, &body_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1263, &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, 1238, &headers); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1265, &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, 1237, &properties); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1264, &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, 1239, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1266, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1239, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1266, &__$false); } } diff --git a/ext/phalcon/queue/adapter/traits/subscriptionconsumertrait.zep.c b/ext/phalcon/queue/adapter/traits/subscriptionconsumertrait.zep.c index b1de15fd4c..bf6975aa40 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, 1240, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1267, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_0)) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1241, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1268, 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, 1240, PH_NOISY_CC); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 1267, 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, 1240, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1267, 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, 1240, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1267, &_0); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/queue/consumer/boundprocessor.zep.c b/ext/phalcon/queue/consumer/boundprocessor.zep.c index a51cdf0f00..e883c9bf4c 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, 1242, queue); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1243, processor); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1244, 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); } 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 6722dcdf17..4cd9e2af6d 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, 1245, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1272, 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, 1245, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1272, 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, 1246, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 1273, 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, 1247, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1274, 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, 1246, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1273, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1246, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1273, &__$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, 1246, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1273, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1246, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1273, &__$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, 1248, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$11, this_ptr, _zephir_prop_2, 1275, 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, 1248, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1275, &_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, 1246, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1273, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1246, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1273, &__$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, 1246, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1273, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1246, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1273, &__$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, 1245, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 1272, 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 08a53866a3..012d65412c 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, 1249, consumer); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1250, options); + 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_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, 1249, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1276, 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, 1250, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1277, 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, 1249, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1276, 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, 1249, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$6, this_ptr, _zephir_prop_1, 1276, 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, 1249, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$6, this_ptr, _zephir_prop_1, 1276, 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, 1249, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20, this_ptr, _zephir_prop_1, 1276, 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, 407, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &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 974dc6dcdc..aed92ae57a 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, 1251, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1278, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, maxSeconds); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1252, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1279, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, maxMemory); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1253, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1280, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, jitter); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1254, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1281, &_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 ed9ca8cead..be27be844f 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, 1255, factory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1282, 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, 1255, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1282, 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 a7852ed28f..490a4ee2d6 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, 1256, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1283, &_5); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/session/adapter/redis.zep.c b/ext/phalcon/session/adapter/redis.zep.c index 310415efc7..c9f501443f 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, 1257, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1284, &_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, 1258, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1285, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1258, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1285, &__$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, 1259, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1286, &_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, 1260, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1287, &_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, 1261, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1288, &_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, 1262, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1289, &_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, 1258, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1285, 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, 1263, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 1290, 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, 1261, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1288, 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, 1264, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1291, PH_NOISY_CC | PH_READONLY); _2 = ZEPHIR_IS_TRUE_IDENTICAL(&_1); if (_2) { - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1263, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1290, 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, 1263, &lockKey); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 1262, PH_NOISY_CC | PH_READONLY); + 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_CALL_METHOD(&client, &_4, "getadapter", NULL, 0); zephir_check_call_status(); ZVAL_LONG(&_5, 16); - ZEPHIR_CALL_FUNCTION(&_6, "random_bytes", NULL, 340, &_5); + ZEPHIR_CALL_FUNCTION(&_6, "random_bytes", NULL, 303, &_5); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&token, "bin2hex", NULL, 341, &_6); + ZEPHIR_CALL_FUNCTION(&token, "bin2hex", NULL, 304, &_6); zephir_check_call_status(); attempt = 0; while (1) { - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_4, 1259, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_4, 1286, PH_NOISY_CC | PH_READONLY); if (!(ZEPHIR_GT_LONG(&_5, attempt))) { break; } - zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_2, 1263, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_5, 1257, PH_NOISY_CC | PH_READONLY); + 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_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, 1264, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1291, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1264, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1291, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1265, &token); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1292, &token); RETURN_MM_BOOL(1); } - zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_7, 1260, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_7, 1287, 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, 1264, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1291, 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, 1262, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1289, 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, 1263, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 1265, PH_NOISY_CC | PH_READONLY); + 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_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, 1264, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1291, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1264, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1291, &__$false); } ZEPHIR_INIT_NVAR(&_4); ZVAL_STRING(&_4, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1265, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1292, &_4); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/session/adapter/stream.zep.c b/ext/phalcon/session/adapter/stream.zep.c index 931acf1458..7645f6f614 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, 1266, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1267, &options); + 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_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, 1268, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1295, &_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, 1268, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1295, 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, 405, &file); + ZEPHIR_CALL_FUNCTION(&_4, "is_file", NULL, 417, &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, 1268, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1266, PH_NOISY_CC | PH_READONLY); + 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_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, 405, &file); + ZEPHIR_CALL_FUNCTION(&_9$$7, "is_file", &_10, 417, &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, 405, &file); + ZEPHIR_CALL_FUNCTION(&_18$$9, "is_file", &_10, 417, &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, 1268, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1295, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getprefixedname", NULL, 0, id); zephir_check_call_status(); ZEPHIR_INIT_VAR(&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, 1268, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1295, 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, 1268, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1295, 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, 1268, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1295, 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, 1266, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1293, 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, 403, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &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, 403, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &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, 403, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &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, 404, &filename_zv, &_0, &_1); + ZEPHIR_RETURN_CALL_FUNCTION("parse_ini_file", NULL, 416, &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 7b0e772f82..ff87f4eaf9 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, 1269, session); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1270, &name_zv); + 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); 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, 1271, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1298, &_0$$3); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1270, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1297, 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, 1269, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1270, PH_NOISY_CC | PH_READONLY); + 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_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, 1269, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1270, PH_NOISY_CC | PH_READONLY); + 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_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, 1269, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1270, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1272, PH_NOISY_CC | PH_READONLY); + 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_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, 1269, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1270, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1272, PH_NOISY_CC | PH_READONLY); + 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_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, 1271, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1298, container); } diff --git a/ext/phalcon/session/manager.zep.c b/ext/phalcon/session/manager.zep.c index aa871c4a3f..0578c3789c 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, 1273, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1300, 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, 1273, &_2$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1300, &_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, 1274, adapter); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1301, 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, 1273, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1300, &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, 1275, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1276, &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_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, 1274, PH_NOISY_CC); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 1301, 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, 1274, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 1301, 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, 1275, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1302, PH_NOISY_CC); if (1 != ZEPHIR_IS_EMPTY(&_0)) { - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1275, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1302, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&prefix); ZEPHIR_CONCAT_VS(&prefix, &_1, "#"); } else { diff --git a/ext/phalcon/storage/adapterfactory.zep.c b/ext/phalcon/storage/adapterfactory.zep.c index aa83f5944c..dd93e7e08c 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, 1277, factory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1304, 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, 1277, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1304, 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 cad5f28fd3..0102d7ef8e 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, 1278, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1305, 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, 1278, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1305, 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, 1279, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1306, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1279, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1306, &__$false); } ZEPHIR_INIT_NVAR(&result); ZVAL_STRING(&result, ""); } else { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1279, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1306, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1279, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1306, &__$false); } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1278, &result); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1305, &result); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/storage/serializer/json.zep.c b/ext/phalcon/storage/serializer/json.zep.c index 022f4ae8ce..ef7a0fb6dd 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, 1280, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1307, &_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, 1281, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1308, &_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, 1282, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1309, 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, 1280, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1282, PH_NOISY_CC | PH_READONLY); + 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_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, 1282, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1309, data); } else { - zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_1, 1281, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_1, 1308, 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, 1282, &_2$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1309, &_2$$4); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/storage/serializer/php.zep.c b/ext/phalcon/storage/serializer/php.zep.c index e7b3b82c0e..ffbc01e7e9 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, 1283, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1310, 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, 1283, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1310, 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, 1283, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1310, data); RETURN_MM_NULL(); } ZEPHIR_INIT_VAR(&_1); @@ -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, 1284, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1311, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1284, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1311, &__$false); } ZEPHIR_INIT_NVAR(&result); ZVAL_STRING(&result, ""); } else { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1284, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1311, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1284, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1311, &__$false); } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1283, &result); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1310, &result); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/support/collection/readonlycollection.zep.c b/ext/phalcon/support/collection/readonlycollection.zep.c index 2e30abe5f9..34480f32fb 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, 1285, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1312, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1285, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1312, &__$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, 1285, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1312, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1285, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1312, &__$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, 1285, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1312, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1285, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1312, &__$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, 1285, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1312, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1285, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1312, &__$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, 1285, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1312, 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 512fe67f93..c9366494a8 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, 1286, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1313, &_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, 1287, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1314, &_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, 1288, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1315, &_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, 1286, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1289, PH_NOISY_CC | PH_READONLY); + 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_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, 1286, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1289, PH_NOISY_CC | PH_READONLY); + 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_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, 1286, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1313, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getversion", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -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, 1286, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1287, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1290, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 1291, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_4, 1292, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_5, 1293, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_6, 1289, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_7, 1288, PH_NOISY_CC | PH_READONLY); + 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_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, 1290, &result); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1317, &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, 1286, renderer); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1313, 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, 1291, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1318, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1291, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1318, &__$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, 1293, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1320, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1293, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1320, &__$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, 1292, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1319, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1292, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1319, &__$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, 1289, &uri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1316, &uri_zv); RETURN_THISW(); } diff --git a/ext/phalcon/support/debug/dump.zep.c b/ext/phalcon/support/debug/dump.zep.c index 56abbe9013..27073d69e5 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, 1294, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1321, &_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, 1295, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1322, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1295, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1322, &__$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, 1296, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1323, 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, 1295, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1322, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1295, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1322, &__$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, 1297, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1324, &_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, 1294, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1321, 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, 1297, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1324, 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, 1295, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_47$$9, this_ptr, _zephir_prop_0, 1322, 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, 299, variable); + ZEPHIR_CALL_FUNCTION(&_52$$12, "get_object_vars", NULL, 313, 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) { @@ -1163,7 +1163,7 @@ PHP_METHOD(Phalcon_Support_Debug_Dump, output) ZEPHIR_CALL_METHOD(NULL, &reflect, "__construct", NULL, 233, variable); zephir_check_call_status(); ZVAL_LONG(&_76$$15, ((1 | 2) | 4)); - ZEPHIR_CALL_METHOD(&props, &reflect, "getproperties", NULL, 311, &_76$$15); + ZEPHIR_CALL_METHOD(&props, &reflect, "getproperties", NULL, 325, &_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, 1298, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_107$$9, this_ptr, _zephir_prop_1, 1325, 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 39f6ad2665..6ed4d39c7f 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, 1299, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1326, 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 f8a7fc0211..cfa01e1adb 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, 1300, &functionName_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1301, type); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1302, className); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1303, classLink); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1304, functionLink); + 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); if (hasArgs) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1305, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1332, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1305, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1332, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1306, &args); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1307, file); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1308, line); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1309, fragment); + 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_MM_RESTORE(); } diff --git a/ext/phalcon/support/debug/report/exceptionreport.zep.c b/ext/phalcon/support/debug/report/exceptionreport.zep.c index 8e4ce90ed5..447f5c663c 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, 1310, &className_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1311, &message_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1312, &file_zv); + 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); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, line); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1313, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1340, &_0); if (showBackTrace) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1314, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1341, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1314, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1341, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1315, &uri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1342, &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, 1316, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1343, 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, 1317, &backtrace); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1344, &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, 1318, &includedFiles); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1345, &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, 1319, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1346, &_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, 1320, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1347, &_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, 1321, &request); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1348, &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, 1322, &server); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1349, &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, 1316, &variables); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1343, &variables); RETURN_THIS(); } diff --git a/ext/phalcon/support/debug/reportbuilder.zep.c b/ext/phalcon/support/debug/reportbuilder.zep.c index 4ea476d563..07a4cb7f58 100644 --- a/ext/phalcon/support/debug/reportbuilder.zep.c +++ b/ext/phalcon/support/debug/reportbuilder.zep.c @@ -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, 407, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &name_zv); 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 9b1385159b..d84d551f3b 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, 407, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &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 60ae4db374..1dce2ea851 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, 378, &collection); + ZEPHIR_CALL_FUNCTION(&_0, "array_unique", NULL, 390, &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/str/dynamic.zep.c b/ext/phalcon/support/helper/str/dynamic.zep.c index d658af9196..49fda8b49a 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, 454, &words); + ZEPHIR_CALL_FUNCTION(&_8$$6, "array_rand", &_9, 466, &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 b2962a83de..a7ddbe5a40 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, 1323, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1350, 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, 1323, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1350, 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/time/clock/frozenclock.zep.c b/ext/phalcon/time/clock/frozenclock.zep.c index 26bde914c8..6c2cfd30a1 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, 1324, now); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1351, 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, 1324, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_0, 1351, 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); @@ -149,7 +149,7 @@ PHP_METHOD(Phalcon_Time_Clock_FrozenClock, adjust) ZVAL_LONG(&_8$$6, 2); ZEPHIR_CALL_FUNCTION(NULL, "set_error_handler", NULL, 286, &_7$$6, &_8$$6); zephir_check_call_status(); - zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_0, 1324, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_0, 1351, 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); @@ -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, 1324, &modified); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1351, &modified); RETURN_THIS(); } @@ -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, 1324, now); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1351, now); RETURN_THISW(); } diff --git a/ext/phalcon/time/clock/systemclock.zep.c b/ext/phalcon/time/clock/systemclock.zep.c index 12bf42c68e..50a80e24b0 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, 1325, timezone); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1352, timezone); } /** @@ -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, 1325, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1352, 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/infotrait.zep.c b/ext/phalcon/traits/php/infotrait.zep.c index 0a0b986fd6..5fc3e36ded 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, 407, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &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 7d43c4ff1b..cf1338362c 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, 403, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &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, 403, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &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, 403, &input_zv); + ZEPHIR_CALL_FUNCTION(&value, "ini_get", NULL, 415, &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, 404, &filename_zv, &_0, &_1); + ZEPHIR_RETURN_CALL_FUNCTION("parse_ini_file", NULL, 416, &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 335cf774ce..e9a27f66be 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, 408, &filename_zv, &_0, &ndocs, &callbacks); + ZEPHIR_RETURN_CALL_FUNCTION("yaml_parse_file", NULL, 420, &filename_zv, &_0, &ndocs, &callbacks); ZEPHIR_UNREF(&ndocs); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/translate/adapter/csv.zep.c b/ext/phalcon/translate/adapter/csv.zep.c index 457e2e0515..9a99abdfd9 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, 1326, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1353, 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, 1326, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1353, 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 7fbbac1a1b..7a9a13a604 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, 1327, &domain_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1354, &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, 1328, directory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1355, 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, 1329, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1356, &_1); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, category); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1330, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1329, PH_NOISY_CC | PH_READONLY); + 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); if (!ZEPHIR_IS_FALSE_IDENTICAL(&_0)) { - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 1329, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 1356, 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, 1329, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 1356, 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, 1329, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 1356, 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, 1329, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 1356, 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, 407, &name_zv); + ZEPHIR_RETURN_CALL_FUNCTION("extension_loaded", NULL, 419, &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 e48ec1bc83..222a5622c7 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, 1331, &data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1358, &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, 1331, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1358, 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, 1331, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1358, 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 2407e41a1c..c267a37711 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, 1332, ¶meter_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1359, ¶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 89ab79c868..37cbec4f1c 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, 1333, interpolator); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1360, 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, 1333, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1360, 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);