From d3ea0cf18e81593408d9b7e000eec328a56207db Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Thu, 29 Oct 2026 11:36:07 -0500 Subject: [PATCH 1/4] [CP-17703] - optimizing cache/storage events Assisted-by: Claude Code --- phalcon/Cache/AbstractCache.zep | 60 ++++++++++--- phalcon/Storage/Adapter/AbstractAdapter.zep | 60 ++++++++++--- .../unit/Cache/Cache/GetEventsManagerTest.php | 90 +++++++++++++++++++ tests/unit/Storage/Adapter/EventsTest.php | 82 +++++++++++++++++ 4 files changed, 264 insertions(+), 28 deletions(-) diff --git a/phalcon/Cache/AbstractCache.zep b/phalcon/Cache/AbstractCache.zep index cf8c2d56c9..d05ecf59c4 100644 --- a/phalcon/Cache/AbstractCache.zep +++ b/phalcon/Cache/AbstractCache.zep @@ -120,11 +120,19 @@ abstract class AbstractCache implements CacheInterface, EventsAwareInterface this->checkKey(key); - this->fireManagerEvent("cache:beforeDelete", key); + /** + * Fire the events only when an events manager is set. With no events + * manager, fireManagerEvent() does nothing. + */ + if null !== this->eventsManager { + this->fireManagerEvent("cache:beforeDelete", key); + } let result = this->adapter->delete(key); - this->fireManagerEvent("cache:afterDelete", key); + if null !== this->eventsManager { + this->fireManagerEvent("cache:afterDelete", key); + } return result; } @@ -140,7 +148,9 @@ abstract class AbstractCache implements CacheInterface, EventsAwareInterface this->checkKeys(keys); - this->fireManagerEvent("cache:beforeDeleteMultiple", keys); + if null !== this->eventsManager { + this->fireManagerEvent("cache:beforeDeleteMultiple", keys); + } let keysArray = []; for key in keys { @@ -150,7 +160,9 @@ abstract class AbstractCache implements CacheInterface, EventsAwareInterface let result = this->adapter->deleteMultiple(keysArray); - this->fireManagerEvent("cache:afterDeleteMultiple", keys); + if null !== this->eventsManager { + this->fireManagerEvent("cache:afterDeleteMultiple", keys); + } return result; } @@ -164,11 +176,15 @@ abstract class AbstractCache implements CacheInterface, EventsAwareInterface this->checkKey(key); - this->fireManagerEvent("cache:beforeGet", key); + if null !== this->eventsManager { + this->fireManagerEvent("cache:beforeGet", key); + } let result = this->adapter->get(key, defaultValue); - this->fireManagerEvent("cache:afterGet", key); + if null !== this->eventsManager { + this->fireManagerEvent("cache:afterGet", key); + } return result; } @@ -186,7 +202,9 @@ abstract class AbstractCache implements CacheInterface, EventsAwareInterface this->checkKeys(keys); - this->fireManagerEvent("cache:beforeGetMultiple", keys); + if null !== this->eventsManager { + this->fireManagerEvent("cache:beforeGetMultiple", keys); + } let results = []; let adapterClass = this->adapter; @@ -246,7 +264,9 @@ abstract class AbstractCache implements CacheInterface, EventsAwareInterface } } - this->fireManagerEvent("cache:afterGetMultiple", keys); + if null !== this->eventsManager { + this->fireManagerEvent("cache:afterGetMultiple", keys); + } return results; } @@ -260,11 +280,15 @@ abstract class AbstractCache implements CacheInterface, EventsAwareInterface this->checkKey(key); - this->fireManagerEvent("cache:beforeHas", key); + if null !== this->eventsManager { + this->fireManagerEvent("cache:beforeHas", key); + } let result = this->adapter->has(key); - this->fireManagerEvent("cache:afterHas", key); + if null !== this->eventsManager { + this->fireManagerEvent("cache:afterHas", key); + } return result; } @@ -281,11 +305,15 @@ abstract class AbstractCache implements CacheInterface, EventsAwareInterface this->checkKey(key); - this->fireManagerEvent("cache:beforeSet", key); + if null !== this->eventsManager { + this->fireManagerEvent("cache:beforeSet", key); + } let result = this->adapter->set(key, value, ttl); - this->fireManagerEvent("cache:afterSet", key); + if null !== this->eventsManager { + this->fireManagerEvent("cache:afterSet", key); + } return result; } @@ -307,7 +335,9 @@ abstract class AbstractCache implements CacheInterface, EventsAwareInterface this->checkKey(key); } - this->fireManagerEvent("cache:beforeSetMultiple", keys); + if null !== this->eventsManager { + this->fireManagerEvent("cache:beforeSetMultiple", keys); + } let result = true; for key, value in values { @@ -316,7 +346,9 @@ abstract class AbstractCache implements CacheInterface, EventsAwareInterface } } - this->fireManagerEvent("cache:afterSetMultiple", keys); + if null !== this->eventsManager { + this->fireManagerEvent("cache:afterSetMultiple", keys); + } return result; } diff --git a/phalcon/Storage/Adapter/AbstractAdapter.zep b/phalcon/Storage/Adapter/AbstractAdapter.zep index f4a650c14a..3de28af287 100644 --- a/phalcon/Storage/Adapter/AbstractAdapter.zep +++ b/phalcon/Storage/Adapter/AbstractAdapter.zep @@ -133,11 +133,19 @@ abstract class AbstractAdapter implements AdapterInterface, EventsAwareInterface let key = this->getKeyWithoutPrefix(key); - this->fireManagerEvent(this->eventType . ":beforeDecrement", key); + /** + * Fire the events only when an events manager is set. With no events + * manager, fireManagerEvent() does nothing. + */ + if null !== this->eventsManager { + this->fireManagerEvent(this->eventType . ":beforeDecrement", key); + } let result = this->doDecrement(key, value); - this->fireManagerEvent(this->eventType . ":afterDecrement", key); + if null !== this->eventsManager { + this->fireManagerEvent(this->eventType . ":afterDecrement", key); + } return result; } @@ -151,11 +159,15 @@ abstract class AbstractAdapter implements AdapterInterface, EventsAwareInterface let key = this->getKeyWithoutPrefix(key); - this->fireManagerEvent(this->eventType . ":beforeDelete", key); + if null !== this->eventsManager { + this->fireManagerEvent(this->eventType . ":beforeDelete", key); + } let result = this->doDelete(key); - this->fireManagerEvent(this->eventType . ":afterDelete", key); + if null !== this->eventsManager { + this->fireManagerEvent(this->eventType . ":afterDelete", key); + } return result; } @@ -177,11 +189,15 @@ abstract class AbstractAdapter implements AdapterInterface, EventsAwareInterface let keys = filteredKeys; - this->fireManagerEvent(this->eventType . ":beforeDeleteMultiple", keys); + if null !== this->eventsManager { + this->fireManagerEvent(this->eventType . ":beforeDeleteMultiple", keys); + } let result = this->doDeleteMultiple(keys); - this->fireManagerEvent(this->eventType . ":afterDeleteMultiple", keys); + if null !== this->eventsManager { + this->fireManagerEvent(this->eventType . ":afterDeleteMultiple", keys); + } return result; } @@ -195,11 +211,15 @@ abstract class AbstractAdapter implements AdapterInterface, EventsAwareInterface let key = this->getKeyWithoutPrefix(key); - this->fireManagerEvent(this->eventType . ":beforeGet", key); + if null !== this->eventsManager { + this->fireManagerEvent(this->eventType . ":beforeGet", key); + } let result = this->doGet(key, defaultValue); - this->fireManagerEvent(this->eventType . ":afterGet", key); + if null !== this->eventsManager { + this->fireManagerEvent(this->eventType . ":afterGet", key); + } return result; } @@ -260,11 +280,15 @@ abstract class AbstractAdapter implements AdapterInterface, EventsAwareInterface let key = this->getKeyWithoutPrefix(key); - this->fireManagerEvent(this->eventType . ":beforeHas", key); + if null !== this->eventsManager { + this->fireManagerEvent(this->eventType . ":beforeHas", key); + } let result = this->doHas(key); - this->fireManagerEvent(this->eventType . ":afterHas", key); + if null !== this->eventsManager { + this->fireManagerEvent(this->eventType . ":afterHas", key); + } return result; } @@ -278,11 +302,15 @@ abstract class AbstractAdapter implements AdapterInterface, EventsAwareInterface let key = this->getKeyWithoutPrefix(key); - this->fireManagerEvent(this->eventType . ":beforeIncrement", key); + if null !== this->eventsManager { + this->fireManagerEvent(this->eventType . ":beforeIncrement", key); + } let result = this->doIncrement(key, value); - this->fireManagerEvent(this->eventType . ":afterIncrement", key); + if null !== this->eventsManager { + this->fireManagerEvent(this->eventType . ":afterIncrement", key); + } return result; } @@ -300,11 +328,15 @@ abstract class AbstractAdapter implements AdapterInterface, EventsAwareInterface let key = this->getKeyWithoutPrefix(key); - this->fireManagerEvent(this->eventType . ":beforeSet", key); + if null !== this->eventsManager { + this->fireManagerEvent(this->eventType . ":beforeSet", key); + } let result = this->doSet(key, value, ttl); - this->fireManagerEvent(this->eventType . ":afterSet", key); + if null !== this->eventsManager { + this->fireManagerEvent(this->eventType . ":afterSet", key); + } return result; } diff --git a/tests/unit/Cache/Cache/GetEventsManagerTest.php b/tests/unit/Cache/Cache/GetEventsManagerTest.php index 6b3b8d9e59..5d9164c048 100644 --- a/tests/unit/Cache/Cache/GetEventsManagerTest.php +++ b/tests/unit/Cache/Cache/GetEventsManagerTest.php @@ -89,6 +89,96 @@ static function () use (&$counter) { $this->assertEquals($expected, $counter); } + /** + * With an events manager, each operation calls fireManagerEvent(). + * + * @issue https://github.com/phalcon/cphalcon/issues/17703 + * @author Phalcon Team + * @since 2026-10-28 + */ + public function testCacheCacheFireManagerEventWithEventsManager(): void + { + $serializer = new SerializerFactory(); + $factory = new AdapterFactory($serializer); + $instance = $factory->newInstance('memory'); + + $cache = new class ($instance) extends Cache { + public int $fireCalls = 0; + + protected function fireManagerEvent( + string $eventName, + mixed $data = null, + bool $cancellable = true, + bool $stopOnFalse = false + ): mixed { + $this->fireCalls++; + + return parent::fireManagerEvent( + $eventName, + $data, + $cancellable, + $stopOnFalse + ); + } + }; + + $cache->setEventsManager(new Manager()); + + $cache->set('a', 1); + $cache->get('a'); + $cache->has('a'); + $cache->delete('a'); + $cache->setMultiple(['b' => 2]); + $cache->getMultiple(['b']); + $cache->deleteMultiple(['b']); + + $this->assertSame(18, $cache->fireCalls); + } + + /** + * With no events manager, the operations do not call fireManagerEvent(). + * + * @issue https://github.com/phalcon/cphalcon/issues/17703 + * @author Phalcon Team + * @since 2026-10-28 + */ + public function testCacheCacheFireManagerEventWithoutEventsManager(): void + { + $serializer = new SerializerFactory(); + $factory = new AdapterFactory($serializer); + $instance = $factory->newInstance('memory'); + + $cache = new class ($instance) extends Cache { + public int $fireCalls = 0; + + protected function fireManagerEvent( + string $eventName, + mixed $data = null, + bool $cancellable = true, + bool $stopOnFalse = false + ): mixed { + $this->fireCalls++; + + return parent::fireManagerEvent( + $eventName, + $data, + $cancellable, + $stopOnFalse + ); + } + }; + + $cache->set('a', 1); + $cache->get('a'); + $cache->has('a'); + $cache->delete('a'); + $cache->setMultiple(['b' => 2]); + $cache->getMultiple(['b']); + $cache->deleteMultiple(['b']); + + $this->assertSame(0, $cache->fireCalls); + } + /** * @author n[oO]ne * @since 2024-06-07 diff --git a/tests/unit/Storage/Adapter/EventsTest.php b/tests/unit/Storage/Adapter/EventsTest.php index ed8f8fa444..2733420b51 100644 --- a/tests/unit/Storage/Adapter/EventsTest.php +++ b/tests/unit/Storage/Adapter/EventsTest.php @@ -684,4 +684,86 @@ static function (Event $event) use (&$counter): void { $expected = 2; $this->assertEquals($expected, $counter); } + + /** + * With an events manager, each operation calls fireManagerEvent(). + * + * @issue https://github.com/phalcon/cphalcon/issues/17703 + * @author Phalcon Team + * @since 2026-10-28 + */ + public function testStorageAdapterEventsFireManagerEventWithEventsManager(): void + { + $adapter = new class (new SerializerFactory()) extends Memory { + public int $fireCalls = 0; + + protected function fireManagerEvent( + string $eventName, + mixed $data = null, + bool $cancellable = true, + bool $stopOnFalse = false + ): mixed { + $this->fireCalls++; + + return parent::fireManagerEvent( + $eventName, + $data, + $cancellable, + $stopOnFalse + ); + } + }; + + $adapter->setEventsManager(new Manager()); + + $adapter->set('a', 1); + $adapter->get('a'); + $adapter->has('a'); + $adapter->increment('a'); + $adapter->decrement('a'); + $adapter->delete('a'); + $adapter->deleteMultiple(['a']); + + $this->assertSame(14, $adapter->fireCalls); + } + + /** + * With no events manager, the operations do not call fireManagerEvent(). + * + * @issue https://github.com/phalcon/cphalcon/issues/17703 + * @author Phalcon Team + * @since 2026-10-28 + */ + public function testStorageAdapterEventsFireManagerEventWithoutEventsManager(): void + { + $adapter = new class (new SerializerFactory()) extends Memory { + public int $fireCalls = 0; + + protected function fireManagerEvent( + string $eventName, + mixed $data = null, + bool $cancellable = true, + bool $stopOnFalse = false + ): mixed { + $this->fireCalls++; + + return parent::fireManagerEvent( + $eventName, + $data, + $cancellable, + $stopOnFalse + ); + } + }; + + $adapter->set('a', 1); + $adapter->get('a'); + $adapter->has('a'); + $adapter->increment('a'); + $adapter->decrement('a'); + $adapter->delete('a'); + $adapter->deleteMultiple(['a']); + + $this->assertSame(0, $adapter->fireCalls); + } } From 6eef93ebbab245a2fe99d2dccc603fe333811445 Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Thu, 29 Oct 2026 14:52:09 -0500 Subject: [PATCH 2/4] [CP-17703] - optimizing events in acl --- phalcon/Acl/Adapter/Memory.zep | 26 +++--- .../unit/Acl/Adapter/Memory/IsAllowedTest.php | 80 +++++++++++++++++++ 2 files changed, 97 insertions(+), 9 deletions(-) diff --git a/phalcon/Acl/Adapter/Memory.zep b/phalcon/Acl/Adapter/Memory.zep index 0185dfb05f..65df1965e3 100644 --- a/phalcon/Acl/Adapter/Memory.zep +++ b/phalcon/Acl/Adapter/Memory.zep @@ -756,15 +756,23 @@ class Memory extends AbstractAdapter */ let this->accessGranted = allowed ? Enum::ALLOW : Enum::DENY; - this->fireManagerEvent( - "acl:afterCheckAccess", - [ - "role": roleName, - "component": componentName, - "access": access, - "granted": this->accessGranted - ] - ); + /** + * Fire the event only when an events manager is set. With no events + * manager, fireManagerEvent() does nothing. The beforeCheckAccess + * call above has no such check, because an override of + * fireManagerEvent() can deny access there. + */ + if null !== this->eventsManager { + this->fireManagerEvent( + "acl:afterCheckAccess", + [ + "role": roleName, + "component": componentName, + "access": access, + "granted": this->accessGranted + ] + ); + } return allowed; } diff --git a/tests/unit/Acl/Adapter/Memory/IsAllowedTest.php b/tests/unit/Acl/Adapter/Memory/IsAllowedTest.php index 040124e960..1ff7551e66 100755 --- a/tests/unit/Acl/Adapter/Memory/IsAllowedTest.php +++ b/tests/unit/Acl/Adapter/Memory/IsAllowedTest.php @@ -300,6 +300,86 @@ function ($event, $source, $data) use (&$seen) { $this->assertSame([Enum::DENY, Enum::ALLOW, Enum::ALLOW], $seen); } + /** + * With an events manager, isAllowed() fires the two events in order. + * + * @issue https://github.com/phalcon/cphalcon/issues/17703 + * @author Phalcon Team + * @since 2026-10-29 + */ + public function testAclAdapterMemoryIsAllowedFireManagerEventWithEventsManager(): void + { + $acl = new class () extends Memory { + public array $fired = []; + + protected function fireManagerEvent( + string $eventName, + mixed $data = null, + bool $cancellable = true, + bool $stopOnFalse = false + ): mixed { + $this->fired[] = $eventName; + + return parent::fireManagerEvent( + $eventName, + $data, + $cancellable, + $stopOnFalse + ); + } + }; + + $acl->setEventsManager(new EventsManager()); + $acl->addRole('Member'); + $acl->addComponent('Post', ['update']); + $acl->allow('Member', 'Post', 'update'); + + $this->assertTrue($acl->isAllowed('Member', 'Post', 'update')); + + $expected = ['acl:beforeCheckAccess', 'acl:afterCheckAccess']; + $this->assertSame($expected, $acl->fired); + } + + /** + * With no events manager, isAllowed() fires only the beforeCheckAccess + * event, because an override of fireManagerEvent() can deny access there. + * + * @issue https://github.com/phalcon/cphalcon/issues/17703 + * @author Phalcon Team + * @since 2026-10-29 + */ + public function testAclAdapterMemoryIsAllowedFireManagerEventWithoutEventsManager(): void + { + $acl = new class () extends Memory { + public array $fired = []; + + protected function fireManagerEvent( + string $eventName, + mixed $data = null, + bool $cancellable = true, + bool $stopOnFalse = false + ): mixed { + $this->fired[] = $eventName; + + return parent::fireManagerEvent( + $eventName, + $data, + $cancellable, + $stopOnFalse + ); + } + }; + + $acl->addRole('Member'); + $acl->addComponent('Post', ['update']); + $acl->allow('Member', 'Post', 'update'); + + $this->assertTrue($acl->isAllowed('Member', 'Post', 'update')); + + $expected = ['acl:beforeCheckAccess']; + $this->assertSame($expected, $acl->fired); + } + /** * Every callable form is accepted as a rule: array callables, static * method strings and closures. From 8c02aa6ecf0ca2977a71237adedf5c01b75d32f8 Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Thu, 29 Oct 2026 15:13:57 -0500 Subject: [PATCH 3/4] [CP-17703] - updating changelog Assisted-by: Claude Code --- CHANGELOG-5.0.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG-5.0.md b/CHANGELOG-5.0.md index 1324a10e25..918f6022e3 100644 --- a/CHANGELOG-5.0.md +++ b/CHANGELOG-5.0.md @@ -20,6 +20,7 @@ All notable changes are documented here. The format is based on [Keep a Changelo - Faster construction of the validators in `Phalcon\Filter\Validation`. [#17697](https://github.com/phalcon/cphalcon/issues/17697) - Faster ACL build in `Phalcon\Acl\Adapter\Memory`. [#17701](https://github.com/phalcon/cphalcon/issues/17701) - Faster construction of `Phalcon\Config\Config` and its adapters when the config has no type. [#17702](https://github.com/phalcon/cphalcon/issues/17702) +- Faster `Phalcon\Cache\Cache`, the `Phalcon\Storage` adapters and `Phalcon\Acl\Adapter\Memory::isAllowed()` when no events manager is set. [#17703](https://github.com/phalcon/cphalcon/issues/17703) ### Added From f4eef80d156fd07d47413e666fb05378729ed125 Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Thu, 29 Oct 2026 15:37:44 -0500 Subject: [PATCH 4/4] [CP-17703] - refreshing ext --- ext/phalcon/15__closure.zep.c | 2 +- ext/phalcon/16__closure.zep.c | 2 +- ext/phalcon/acl/adapter/memory.zep.c | 106 ++-- ext/phalcon/acl/adapter/storage.zep.c | 46 +- ext/phalcon/acl/component.zep.c | 4 +- ext/phalcon/acl/role.zep.c | 4 +- ext/phalcon/adr/application.zep.c | 48 +- ext/phalcon/adr/dispatcher.zep.c | 24 +- ext/phalcon/adr/errorresponder.zep.c | 24 +- ext/phalcon/adr/eventfulhandler.zep.c | 14 +- ext/phalcon/adr/input/input.zep.c | 8 +- .../adr/middleware/corsmiddleware.zep.c | 28 +- .../middleware/methodoverridemiddleware.zep.c | 2 +- ext/phalcon/adr/pipeline.zep.c | 22 +- .../adr/responder/formatresponder.zep.c | 8 +- ext/phalcon/adr/responder/redirect.zep.c | 8 +- ext/phalcon/adr/responder/statusmapper.zep.c | 6 +- .../adr/responder/statusresponder.zep.c | 6 +- ext/phalcon/adr/responder/viewresponder.zep.c | 12 +- ext/phalcon/adr/router/router.zep.c | 36 +- ext/phalcon/adr/router/routermatch.zep.c | 8 +- ext/phalcon/annotations/adapter/apcu.zep.c | 10 +- ext/phalcon/annotations/adapter/memory.zep.c | 2 +- ext/phalcon/annotations/adapter/stream.zep.c | 4 +- ext/phalcon/annotations/annotation.zep.c | 14 +- ext/phalcon/annotations/collection.zep.c | 20 +- .../annotations/models/metadata/column.zep.c | 24 +- .../annotations/models/metadata/source.zep.c | 2 +- ext/phalcon/annotations/reflection.zep.c | 14 +- .../annotations/router/routeprefix.zep.c | 2 +- ext/phalcon/assets/collection.zep.c | 44 +- ext/phalcon/assets/manager.zep.c | 48 +- .../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 | 16 +- .../adapter/config/memoryadapterconfig.zep.c | 2 +- .../adapter/config/modeladapterconfig.zep.c | 2 +- .../adapter/config/streamadapterconfig.zep.c | 2 +- ext/phalcon/auth/adapter/memory.zep.c | 6 +- ext/phalcon/auth/adapter/model.zep.c | 4 +- ext/phalcon/auth/adapter/stream.zep.c | 2 +- ext/phalcon/auth/authuser.zep.c | 6 +- .../guard/config/sessionguardconfig.zep.c | 14 +- .../auth/guard/config/tokenguardconfig.zep.c | 4 +- ext/phalcon/auth/guard/session.zep.c | 84 +-- ext/phalcon/auth/guard/token.zep.c | 26 +- ext/phalcon/auth/guard/userremember.zep.c | 6 +- ext/phalcon/auth/manager.zep.c | 32 +- ext/phalcon/auth/managerfactory.zep.c | 24 +- .../auth/micro/authmicrolistener.zep.c | 4 +- ext/phalcon/autoload/loader.zep.c | 88 +-- ext/phalcon/cache/abstractcache.zep.c | 506 +++++++++++------- ext/phalcon/cache/adapterfactory.zep.c | 4 +- ext/phalcon/cache/cachefactory.zep.c | 4 +- ext/phalcon/cli/console.zep.c | 48 +- ext/phalcon/cli/dispatcher.zep.c | 18 +- ext/phalcon/cli/router.zep.c | 76 +-- ext/phalcon/cli/router/route.zep.c | 44 +- ext/phalcon/cli/task.zep.c | 14 +- ext/phalcon/config/adapter/grouped.zep.c | 4 +- .../exceptions/cannotloadconfigfile.zep.c | 2 +- .../exceptions/missingconfigoption.zep.c | 2 +- ext/phalcon/container/container.zep.c | 88 +-- ext/phalcon/container/containerfactory.zep.c | 2 +- .../definition/servicedefinition.zep.c | 122 ++--- .../container/resolver/lazy/arrayvalues.zep.c | 12 +- .../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 | 6 +- .../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/newcall.zep.c | 12 +- .../container/resolver/lazy/newinstance.zep.c | 4 +- .../container/resolver/lazy/staticcall.zep.c | 12 +- ext/phalcon/datamapper/pdo/connection.zep.c | 32 +- .../datamapper/pdo/connection/decorated.zep.c | 2 +- .../datamapper/pdo/connectionlocator.zep.c | 26 +- .../datamapper/pdo/profiler/profiler.zep.c | 38 +- ext/phalcon/datamapper/query/bind.zep.c | 22 +- ext/phalcon/datamapper/query/delete.zep.c | 4 +- ext/phalcon/datamapper/query/insert.zep.c | 14 +- .../datamapper/query/queryfactory.zep.c | 4 +- ext/phalcon/datamapper/query/select.zep.c | 48 +- ext/phalcon/datamapper/query/update.zep.c | 12 +- ext/phalcon/db/adapter/pdo/mysql.zep.c | 12 +- ext/phalcon/db/adapter/pdo/postgresql.zep.c | 10 +- ext/phalcon/db/adapter/pdo/sqlite.zep.c | 16 +- ext/phalcon/db/check.zep.c | 4 +- ext/phalcon/db/column.zep.c | 60 +-- .../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 | 42 +- ext/phalcon/db/index.zep.c | 22 +- ext/phalcon/db/profiler.zep.c | 22 +- ext/phalcon/db/profiler/item.zep.c | 14 +- ext/phalcon/db/rawvalue.zep.c | 6 +- ext/phalcon/db/reference.zep.c | 16 +- ext/phalcon/db/result/pdoresult.zep.c | 60 +-- ext/phalcon/di/factorydefault.zep.c | 2 +- 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 | 88 +-- 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 +- .../security/uuid/sysnodeprovider.zep.c | 8 +- .../encryption/security/uuid/version1.zep.c | 6 +- .../encryption/security/uuid/version3.zep.c | 2 +- .../encryption/security/uuid/version4.zep.c | 2 +- .../encryption/security/uuid/version5.zep.c | 2 +- .../encryption/security/uuid/version6.zep.c | 6 +- .../encryption/security/uuid/version7.zep.c | 2 +- ext/phalcon/events/event.zep.c | 20 +- ext/phalcon/events/manager.zep.c | 192 +++---- .../events/traits/eventsawaretrait.zep.c | 14 +- ext/phalcon/filter/filter.zep.c | 20 +- ext/phalcon/filter/validation.zep.c | 68 +-- .../traits/validatorcompositetrait.zep.c | 2 +- .../validation/validator/callback.zep.c | 12 +- .../filter/validation/validator/files.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 | 16 +- ext/phalcon/forms/form.zep.c | 112 ++-- ext/phalcon/forms/formslocator.zep.c | 14 +- ext/phalcon/forms/loader/arrayloader.zep.c | 4 +- ext/phalcon/forms/loader/jsonloader.zep.c | 4 +- ext/phalcon/forms/loader/yamlloader.zep.c | 4 +- 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 | 66 +-- ext/phalcon/html/helper/button.zep.c | 6 +- ext/phalcon/html/helper/doctype.zep.c | 46 +- ext/phalcon/html/helper/element.zep.c | 6 +- ext/phalcon/html/helper/friendlytitle.zep.c | 4 +- .../html/helper/input/checkboxgroup.zep.c | 8 +- ext/phalcon/html/helper/input/generic.zep.c | 4 +- .../html/helper/input/radiogroup.zep.c | 4 +- ext/phalcon/html/helper/input/select.zep.c | 36 +- .../html/helper/input/select/arraydata.zep.c | 4 +- .../helper/input/select/resultsetdata.zep.c | 28 +- ext/phalcon/html/helper/input/textarea.zep.c | 6 +- ext/phalcon/html/helper/label.zep.c | 6 +- ext/phalcon/html/helper/ol.zep.c | 8 +- ext/phalcon/html/helper/preload.zep.c | 6 +- ext/phalcon/html/helper/style.zep.c | 8 +- ext/phalcon/html/helper/title.zep.c | 38 +- ext/phalcon/html/helper/voidtag.zep.c | 4 +- ext/phalcon/html/tagfactory.zep.c | 26 +- ext/phalcon/http/cookie.zep.c | 126 ++--- ext/phalcon/http/request.zep.c | 72 +-- .../http/request/bag/abstractbag.zep.c | 22 +- ext/phalcon/http/request/file.zep.c | 24 +- ext/phalcon/http/response.zep.c | 78 +-- ext/phalcon/http/response/cookies.zep.c | 52 +- ext/phalcon/http/response/headers.zep.c | 20 +- ext/phalcon/image/adapter/gd.zep.c | 210 ++++---- ext/phalcon/image/adapter/imagick.zep.c | 130 ++--- ext/phalcon/logger/abstractlogger.zep.c | 42 +- 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 | 28 +- .../messages/traits/messageshelpertrait.zep.c | 18 +- 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 | 148 ++--- ext/phalcon/mvc/micro/collection.zep.c | 12 +- ext/phalcon/mvc/micro/lazyloader.zep.c | 8 +- ext/phalcon/mvc/model.zep.c | 310 +++++------ ext/phalcon/mvc/model/binder.zep.c | 14 +- ext/phalcon/mvc/model/criteria.zep.c | 52 +- ext/phalcon/mvc/model/eager/loader.zep.c | 10 +- ext/phalcon/mvc/model/manager.zep.c | 152 +++--- 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 | 4 +- ext/phalcon/mvc/model/query.zep.c | 328 ++++++------ 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 | 104 ++-- ext/phalcon/mvc/model/transaction.zep.c | 40 +- .../mvc/model/transaction/failed.zep.c | 4 +- .../mvc/model/transaction/manager.zep.c | 40 +- ext/phalcon/mvc/model/validationfailed.zep.c | 4 +- ext/phalcon/mvc/router.zep.c | 338 ++++++------ ext/phalcon/mvc/router/annotations.zep.c | 28 +- ext/phalcon/mvc/router/group.zep.c | 16 +- ext/phalcon/mvc/router/route.zep.c | 52 +- 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 | 22 +- .../mvc/view/engine/volt/compiler.zep.c | 166 +++--- 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 | 42 +- .../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 | 24 +- .../traits/subscriptionconsumertrait.zep.c | 8 +- .../queue/consumer/boundprocessor.zep.c | 6 +- .../queue/consumer/queueconsumer.zep.c | 30 +- ext/phalcon/queue/consumer/worker.zep.c | 16 +- .../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 | 56 +- ext/phalcon/session/adapter/stream.zep.c | 22 +- ext/phalcon/session/bag.zep.c | 30 +- ext/phalcon/session/manager.zep.c | 20 +- .../storage/adapter/abstractadapter.zep.c | 302 +++++++---- ext/phalcon/storage/adapter/apcu.zep.c | 4 +- .../storage/adapter/libmemcached.zep.c | 12 +- ext/phalcon/storage/adapter/memory.zep.c | 30 +- .../storage/adapter/rediscluster.zep.c | 12 +- ext/phalcon/storage/adapter/stream.zep.c | 10 +- ext/phalcon/storage/adapter/weak.zep.c | 30 +- ext/phalcon/storage/adapterfactory.zep.c | 4 +- ext/phalcon/storage/serializer/base64.zep.c | 14 +- ext/phalcon/storage/serializer/igbinary.zep.c | 24 +- ext/phalcon/storage/serializer/json.zep.c | 16 +- ext/phalcon/storage/serializer/php.zep.c | 20 +- .../collection/readonlycollection.zep.c | 18 +- ext/phalcon/support/debug.zep.c | 50 +- ext/phalcon/support/debug/dump.zep.c | 24 +- .../support/debug/renderer/htmlrenderer.zep.c | 4 +- .../support/debug/report/backtraceitem.zep.c | 22 +- .../debug/report/exceptionreport.zep.c | 30 +- .../debug/traits/templateawaretrait.zep.c | 4 +- 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/factory/factorytrait.zep.c | 10 +- ext/phalcon/translate/adapter/csv.zep.c | 4 +- ext/phalcon/translate/adapter/gettext.zep.c | 18 +- .../translate/adapter/nativearray.zep.c | 6 +- .../exceptions/missingrequiredparameter.zep.c | 2 +- ext/phalcon/translate/translatefactory.zep.c | 4 +- 299 files changed, 4342 insertions(+), 4158 deletions(-) diff --git a/ext/phalcon/15__closure.zep.c b/ext/phalcon/15__closure.zep.c index 96f617b120..4332e5249a 100644 --- a/ext/phalcon/15__closure.zep.c +++ b/ext/phalcon/15__closure.zep.c @@ -48,7 +48,7 @@ PHP_METHOD(phalcon_15__closure, __invoke) zephir_read_property(&ioc, this_ptr, SL("ioc"), PH_NOISY_CC); this_ptr = &__$zephir_this; - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1414, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1415, 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/16__closure.zep.c b/ext/phalcon/16__closure.zep.c index 81ecac1a66..a02893a331 100644 --- a/ext/phalcon/16__closure.zep.c +++ b/ext/phalcon/16__closure.zep.c @@ -48,7 +48,7 @@ PHP_METHOD(phalcon_16__closure, __invoke) zephir_read_property(&ioc, this_ptr, SL("ioc"), PH_NOISY_CC); this_ptr = &__$zephir_this; - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1415, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1416, 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/memory.zep.c b/ext/phalcon/acl/adapter/memory.zep.c index ac5f54835b..34f9b79ce5 100644 --- a/ext/phalcon/acl/adapter/memory.zep.c +++ b/ext/phalcon/acl/adapter/memory.zep.c @@ -1417,9 +1417,9 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, isAllowed) zend_bool allowed = 0, _0, _1, _8; zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval parameters, _4, _13; + zval parameters, _4, _13$$11; zend_string *access = NULL; - zval *roleName = NULL, roleName_sub, *componentName = NULL, componentName_sub, access_zv, *parameters_param = NULL, __$null, accessKey, accessList, componentObject, haveAccess, funcAccess, funcList, roleObject, ruleResult, _2, _3, _5, _6, _9, _12, _14, _7$$6, _10$$8, _11$$8; + zval *roleName = NULL, roleName_sub, *componentName = NULL, componentName_sub, access_zv, *parameters_param = NULL, __$null, accessKey, accessList, componentObject, haveAccess, funcAccess, funcList, roleObject, ruleResult, _2, _3, _5, _6, _9, _12, _7$$6, _10$$8, _11$$8, _14$$11, _15$$11; zval *this_ptr = getThis(); ZVAL_UNDEF(&roleName_sub); @@ -1440,13 +1440,14 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, isAllowed) ZVAL_UNDEF(&_6); ZVAL_UNDEF(&_9); ZVAL_UNDEF(&_12); - ZVAL_UNDEF(&_14); ZVAL_UNDEF(&_7$$6); ZVAL_UNDEF(&_10$$8); ZVAL_UNDEF(&_11$$8); + ZVAL_UNDEF(&_14$$11); + ZVAL_UNDEF(&_15$$11); ZVAL_UNDEF(¶meters); ZVAL_UNDEF(&_4); - ZVAL_UNDEF(&_13); + ZVAL_UNDEF(&_13$$11); static zend_string *_zephir_prop_0 = NULL; static zend_string *_zephir_prop_1 = NULL; static zend_string *_zephir_prop_2 = NULL; @@ -1458,6 +1459,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, isAllowed) static zend_string *_zephir_prop_8 = NULL; static zend_string *_zephir_prop_9 = NULL; static zend_string *_zephir_prop_10 = NULL; + static zend_string *_zephir_prop_11 = NULL; if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("activeRole", 10, 1); } @@ -1491,6 +1493,9 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, isAllowed) if (UNEXPECTED(!_zephir_prop_10)) { _zephir_prop_10 = zend_string_init("defaultAccess", 13, 1); } + if (UNEXPECTED(!_zephir_prop_11)) { + _zephir_prop_11 = zend_string_init("eventsManager", 13, 1); + } bool is_null_true = 1; ZEND_PARSE_PARAMETERS_START(3, 4) @@ -1621,18 +1626,21 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, isAllowed) ZVAL_LONG(&_12, 0); } zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 266, &_12); - ZEPHIR_INIT_VAR(&_13); - zephir_create_array(&_13, 4, 0); - zephir_array_update_string(&_13, SL("role"), roleName, PH_COPY | PH_SEPARATE); - zephir_array_update_string(&_13, SL("component"), componentName, PH_COPY | PH_SEPARATE); - zephir_array_update_string(&_13, SL("access"), &access_zv, PH_COPY | PH_SEPARATE); - zephir_memory_observe(&_14); - zephir_read_property_cached(&_14, this_ptr, _zephir_prop_5, 266, PH_NOISY_CC); - zephir_array_update_string(&_13, SL("granted"), &_14, PH_COPY | PH_SEPARATE); - ZEPHIR_INIT_NVAR(&_5); - ZVAL_STRING(&_5, "acl:afterCheckAccess"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_5, &_13); - zephir_check_call_status(); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_11, 271, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_6) != IS_NULL) { + ZEPHIR_INIT_VAR(&_13$$11); + zephir_create_array(&_13$$11, 4, 0); + zephir_array_update_string(&_13$$11, SL("role"), roleName, PH_COPY | PH_SEPARATE); + zephir_array_update_string(&_13$$11, SL("component"), componentName, PH_COPY | PH_SEPARATE); + zephir_array_update_string(&_13$$11, SL("access"), &access_zv, PH_COPY | PH_SEPARATE); + zephir_memory_observe(&_14$$11); + zephir_read_property_cached(&_14$$11, this_ptr, _zephir_prop_5, 266, PH_NOISY_CC); + zephir_array_update_string(&_13$$11, SL("granted"), &_14$$11, PH_COPY | PH_SEPARATE); + ZEPHIR_INIT_VAR(&_15$$11); + ZVAL_STRING(&_15$$11, "acl:afterCheckAccess"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_15$$11, &_13$$11); + zephir_check_call_status(); + } RETURN_MM_BOOL(allowed); } @@ -1707,7 +1715,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, setNoArgumentsDefaultAction) zephir_fetch_params_without_memory_grow(1, 0, &defaultAccess_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, defaultAccess); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 271, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 272, &_0); } /** @@ -1813,7 +1821,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, allowOrDeny) } else { _7$$5 = access; } - zephir_is_iterable(_7$$5, 0, "phalcon/Acl/Adapter/Memory.zep", 833); + zephir_is_iterable(_7$$5, 0, "phalcon/Acl/Adapter/Memory.zep", 841); if (Z_TYPE_P(_7$$5) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_7$$5), _9$$5) { @@ -1826,7 +1834,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, allowOrDeny) object_init_ex(&_11$$7, phalcon_acl_exceptions_accessrulenotfound_ce); ZEPHIR_CALL_METHOD(NULL, &_11$$7, "__construct", &_12, 250, &accessName, &componentName_zv); zephir_check_call_status(); - zephir_throw_exception_debug(&_11$$7, "phalcon/Acl/Adapter/Memory.zep", 829); + zephir_throw_exception_debug(&_11$$7, "phalcon/Acl/Adapter/Memory.zep", 837); ZEPHIR_MM_RESTORE(); return; } @@ -1856,7 +1864,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, allowOrDeny) object_init_ex(&_15$$9, phalcon_acl_exceptions_accessrulenotfound_ce); ZEPHIR_CALL_METHOD(NULL, &_15$$9, "__construct", &_12, 250, &accessName, &componentName_zv); zephir_check_call_status(); - zephir_throw_exception_debug(&_15$$9, "phalcon/Acl/Adapter/Memory.zep", 829); + zephir_throw_exception_debug(&_15$$9, "phalcon/Acl/Adapter/Memory.zep", 837); ZEPHIR_MM_RESTORE(); return; } @@ -1870,7 +1878,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, allowOrDeny) } else { _16$$5 = access; } - zephir_is_iterable(_16$$5, 0, "phalcon/Acl/Adapter/Memory.zep", 841); + zephir_is_iterable(_16$$5, 0, "phalcon/Acl/Adapter/Memory.zep", 849); if (Z_TYPE_P(_16$$5) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_16$$5), _18$$5) { @@ -1919,7 +1927,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, allowOrDeny) object_init_ex(&_22$$16, phalcon_acl_exceptions_accessrulenotfound_ce); ZEPHIR_CALL_METHOD(NULL, &_22$$16, "__construct", &_12, 250, access, &componentName_zv); zephir_check_call_status(); - zephir_throw_exception_debug(&_22$$16, "phalcon/Acl/Adapter/Memory.zep", 846); + zephir_throw_exception_debug(&_22$$16, "phalcon/Acl/Adapter/Memory.zep", 854); ZEPHIR_MM_RESTORE(); return; } @@ -2069,7 +2077,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, canAccess) array_init(&checkRoleToInherits); zephir_read_property_cached(&_1$$6, this_ptr, _zephir_prop_1, 260, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2$$6); - zephir_array_fetch(&_2$$6, &_1$$6, &roleName_zv, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 939); + zephir_array_fetch(&_2$$6, &_1$$6, &roleName_zv, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 947); if (Z_TYPE_P(&_2$$6) == IS_STRING) { ZEPHIR_INIT_VAR(&_4$$6); zephir_string_to_char_array(&_4$$6, &_2$$6); @@ -2077,7 +2085,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, canAccess) } else { _3$$6 = &_2$$6; } - zephir_is_iterable(_3$$6, 0, "phalcon/Acl/Adapter/Memory.zep", 943); + zephir_is_iterable(_3$$6, 0, "phalcon/Acl/Adapter/Memory.zep", 951); if (Z_TYPE_P(_3$$6) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_3$$6), _5$$6) { @@ -2121,7 +2129,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, canAccess) break; } ZEPHIR_OBS_NVAR(&checkRoleToInherit); - zephir_array_fetch_long(&checkRoleToInherit, &checkRoleToInherits, pendingIndex, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 953); + zephir_array_fetch_long(&checkRoleToInherit, &checkRoleToInherits, pendingIndex, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 961); pendingIndex++; if (zephir_array_isset_value(&usedRoleToInherits, &checkRoleToInherit)) { continue; @@ -2150,7 +2158,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, canAccess) if (zephir_array_isset_value(&_11$$9, &checkRoleToInherit)) { zephir_read_property_cached(&_12$$14, this_ptr, _zephir_prop_1, 260, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_13$$14); - zephir_array_fetch(&_13$$14, &_12$$14, &checkRoleToInherit, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 995); + zephir_array_fetch(&_13$$14, &_12$$14, &checkRoleToInherit, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 1003); if (Z_TYPE_P(&_13$$14) == IS_STRING) { ZEPHIR_INIT_NVAR(&_15$$14); zephir_string_to_char_array(&_15$$14, &_13$$14); @@ -2158,7 +2166,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, canAccess) } else { _14$$14 = &_13$$14; } - zephir_is_iterable(_14$$14, 0, "phalcon/Acl/Adapter/Memory.zep", 998); + zephir_is_iterable(_14$$14, 0, "phalcon/Acl/Adapter/Memory.zep", 1006); if (Z_TYPE_P(_14$$14) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_14$$14), _16$$14) { @@ -2250,7 +2258,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, checkExists) ZEPHIR_CONCAT_VSVSV(&_1$$3, &elementName_zv, " '", &element_zv, "' does not exist in the ", &suffix_zv); ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 7, &_1$$3); zephir_check_call_status(); - zephir_throw_exception_debug(&_0$$3, "phalcon/Acl/Adapter/Memory.zep", 1020); + zephir_throw_exception_debug(&_0$$3, "phalcon/Acl/Adapter/Memory.zep", 1028); ZEPHIR_MM_RESTORE(); return; } @@ -2403,7 +2411,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) } else { _4 = &reflectionParameters; } - zephir_is_iterable(_4, 0, "phalcon/Acl/Adapter/Memory.zep", 1131); + zephir_is_iterable(_4, 0, "phalcon/Acl/Adapter/Memory.zep", 1139); if (Z_TYPE_P(_4) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_4), _6) { @@ -2442,7 +2450,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) } if (_14$$5) { hasRole = 1; - zephir_array_append(¶metersForFunction, roleObject, PH_SEPARATE, "phalcon/Acl/Adapter/Memory.zep", 1084); + zephir_array_append(¶metersForFunction, roleObject, PH_SEPARATE, "phalcon/Acl/Adapter/Memory.zep", 1092); SEPARATE_ZVAL(&userParametersSizeShouldBe); zephir_decrement(&userParametersSizeShouldBe); continue; @@ -2459,7 +2467,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) } if (_17$$5) { hasComponent = 1; - zephir_array_append(¶metersForFunction, componentObject, PH_SEPARATE, "phalcon/Acl/Adapter/Memory.zep", 1096); + zephir_array_append(¶metersForFunction, componentObject, PH_SEPARATE, "phalcon/Acl/Adapter/Memory.zep", 1104); SEPARATE_ZVAL(&userParametersSizeShouldBe); zephir_decrement(&userParametersSizeShouldBe); continue; @@ -2467,13 +2475,13 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) _18$$5 = zephir_array_isset_value(parameters, ¶meterToCheck); if (_18$$5) { ZEPHIR_OBS_NVAR(&_19$$5); - zephir_array_fetch(&_19$$5, parameters, ¶meterToCheck, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 1107); + zephir_array_fetch(&_19$$5, parameters, ¶meterToCheck, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 1115); _18$$5 = Z_TYPE_P(&_19$$5) == IS_OBJECT; } _20$$5 = _18$$5; if (_20$$5) { ZEPHIR_OBS_NVAR(&_22$$5); - zephir_array_fetch(&_22$$5, parameters, ¶meterToCheck, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 1108); + zephir_array_fetch(&_22$$5, parameters, ¶meterToCheck, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 1116); ZEPHIR_CALL_METHOD(&_21$$5, &reflectionClass, "isInstance", &_13, 255, &_22$$5); zephir_check_call_status(); _20$$5 = !zephir_is_true(&_21$$5); @@ -2483,7 +2491,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) object_init_ex(&_23$$8, phalcon_acl_exceptions_parametertypemismatch_ce); ZEPHIR_INIT_NVAR(&_24$$8); ZEPHIR_OBS_NVAR(&_25$$8); - zephir_array_fetch(&_25$$8, parameters, ¶meterToCheck, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 1115); + zephir_array_fetch(&_25$$8, parameters, ¶meterToCheck, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 1123); zephir_get_class(&_24$$8, &_25$$8, 0); ZEPHIR_CALL_METHOD(&_26$$8, &reflectionClass, "getName", &_27, 256); zephir_check_call_status(); @@ -2491,15 +2499,15 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) ZEPHIR_CONCAT_SSSVSVSVSVSVS(&_28$$8, "Your passed parameter does not have the ", "same class as the parameter in defined function ", "when checking if ", &roleName_zv, " can ", &access_zv, " ", &componentName_zv, ". Class passed: ", &_24$$8, " , Class in defined function: ", &_26$$8, "."); ZEPHIR_CALL_METHOD(NULL, &_23$$8, "__construct", &_29, 7, &_28$$8); zephir_check_call_status(); - zephir_throw_exception_debug(&_23$$8, "phalcon/Acl/Adapter/Memory.zep", 1118); + zephir_throw_exception_debug(&_23$$8, "phalcon/Acl/Adapter/Memory.zep", 1126); ZEPHIR_MM_RESTORE(); return; } } if (zephir_array_isset_value(parameters, ¶meterToCheck)) { ZEPHIR_OBS_NVAR(&_30$$9); - zephir_array_fetch(&_30$$9, parameters, ¶meterToCheck, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 1127); - zephir_array_append(¶metersForFunction, &_30$$9, PH_SEPARATE, "phalcon/Acl/Adapter/Memory.zep", 1127); + zephir_array_fetch(&_30$$9, parameters, ¶meterToCheck, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 1135); + zephir_array_append(¶metersForFunction, &_30$$9, PH_SEPARATE, "phalcon/Acl/Adapter/Memory.zep", 1135); } } ZEND_HASH_FOREACH_END(); } else { @@ -2553,7 +2561,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) } if (_38$$11) { hasRole = 1; - zephir_array_append(¶metersForFunction, roleObject, PH_SEPARATE, "phalcon/Acl/Adapter/Memory.zep", 1084); + zephir_array_append(¶metersForFunction, roleObject, PH_SEPARATE, "phalcon/Acl/Adapter/Memory.zep", 1092); SEPARATE_ZVAL(&userParametersSizeShouldBe); zephir_decrement(&userParametersSizeShouldBe); continue; @@ -2570,7 +2578,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) } if (_41$$11) { hasComponent = 1; - zephir_array_append(¶metersForFunction, componentObject, PH_SEPARATE, "phalcon/Acl/Adapter/Memory.zep", 1096); + zephir_array_append(¶metersForFunction, componentObject, PH_SEPARATE, "phalcon/Acl/Adapter/Memory.zep", 1104); SEPARATE_ZVAL(&userParametersSizeShouldBe); zephir_decrement(&userParametersSizeShouldBe); continue; @@ -2578,13 +2586,13 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) _42$$11 = zephir_array_isset_value(parameters, ¶meterToCheck); if (_42$$11) { ZEPHIR_OBS_NVAR(&_43$$11); - zephir_array_fetch(&_43$$11, parameters, ¶meterToCheck, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 1107); + zephir_array_fetch(&_43$$11, parameters, ¶meterToCheck, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 1115); _42$$11 = Z_TYPE_P(&_43$$11) == IS_OBJECT; } _44$$11 = _42$$11; if (_44$$11) { ZEPHIR_OBS_NVAR(&_46$$11); - zephir_array_fetch(&_46$$11, parameters, ¶meterToCheck, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 1108); + zephir_array_fetch(&_46$$11, parameters, ¶meterToCheck, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 1116); ZEPHIR_CALL_METHOD(&_45$$11, &reflectionClass, "isInstance", &_13, 255, &_46$$11); zephir_check_call_status(); _44$$11 = !zephir_is_true(&_45$$11); @@ -2594,7 +2602,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) object_init_ex(&_47$$14, phalcon_acl_exceptions_parametertypemismatch_ce); ZEPHIR_INIT_NVAR(&_48$$14); ZEPHIR_OBS_NVAR(&_49$$14); - zephir_array_fetch(&_49$$14, parameters, ¶meterToCheck, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 1115); + zephir_array_fetch(&_49$$14, parameters, ¶meterToCheck, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 1123); zephir_get_class(&_48$$14, &_49$$14, 0); ZEPHIR_CALL_METHOD(&_50$$14, &reflectionClass, "getName", &_27, 256); zephir_check_call_status(); @@ -2602,15 +2610,15 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) ZEPHIR_CONCAT_SSSVSVSVSVSVS(&_51$$14, "Your passed parameter does not have the ", "same class as the parameter in defined function ", "when checking if ", &roleName_zv, " can ", &access_zv, " ", &componentName_zv, ". Class passed: ", &_48$$14, " , Class in defined function: ", &_50$$14, "."); ZEPHIR_CALL_METHOD(NULL, &_47$$14, "__construct", &_29, 7, &_51$$14); zephir_check_call_status(); - zephir_throw_exception_debug(&_47$$14, "phalcon/Acl/Adapter/Memory.zep", 1118); + zephir_throw_exception_debug(&_47$$14, "phalcon/Acl/Adapter/Memory.zep", 1126); ZEPHIR_MM_RESTORE(); return; } } if (zephir_array_isset_value(parameters, ¶meterToCheck)) { ZEPHIR_OBS_NVAR(&_52$$15); - zephir_array_fetch(&_52$$15, parameters, ¶meterToCheck, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 1127); - zephir_array_append(¶metersForFunction, &_52$$15, PH_SEPARATE, "phalcon/Acl/Adapter/Memory.zep", 1127); + zephir_array_fetch(&_52$$15, parameters, ¶meterToCheck, PH_NOISY, "phalcon/Acl/Adapter/Memory.zep", 1135); + zephir_array_append(¶metersForFunction, &_52$$15, PH_SEPARATE, "phalcon/Acl/Adapter/Memory.zep", 1135); } } } @@ -2631,7 +2639,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) zephir_check_call_status(); _56$$18 = haveAccess == 1; if (_56$$18) { - zephir_read_property_cached(&_57$$18, this_ptr, _zephir_prop_1, 271, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_57$$18, this_ptr, _zephir_prop_1, 272, PH_NOISY_CC | PH_READONLY); _56$$18 = ZEPHIR_IS_LONG(&_57$$18, 1); } RETURN_MM_BOOL(_56$$18); @@ -2661,7 +2669,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, invokeRule) ZEPHIR_CONCAT_SSVSVSVS(&_63, "You did not provide all necessary parameters for the ", "defined function when checking if '", &roleName_zv, "' can '", &access_zv, "' for '", &componentName_zv, "'."); ZEPHIR_CALL_METHOD(NULL, &_62, "__construct", &_29, 7, &_63); zephir_check_call_status(); - zephir_throw_exception_debug(&_62, "phalcon/Acl/Adapter/Memory.zep", 1172); + zephir_throw_exception_debug(&_62, "phalcon/Acl/Adapter/Memory.zep", 1180); ZEPHIR_MM_RESTORE(); return; } @@ -2703,7 +2711,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, toComponentName) object_init_ex(&_0$$3, phalcon_acl_exceptions_invalidcomponentimplementation_ce); ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 257); zephir_check_call_status(); - zephir_throw_exception_debug(&_0$$3, "phalcon/Acl/Adapter/Memory.zep", 1194); + zephir_throw_exception_debug(&_0$$3, "phalcon/Acl/Adapter/Memory.zep", 1202); ZEPHIR_MM_RESTORE(); return; } @@ -2748,7 +2756,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Memory, toRoleName) object_init_ex(&_0$$3, phalcon_acl_exceptions_invalidroleimplementation_ce); ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 258); zephir_check_call_status(); - zephir_throw_exception_debug(&_0$$3, "phalcon/Acl/Adapter/Memory.zep", 1219); + zephir_throw_exception_debug(&_0$$3, "phalcon/Acl/Adapter/Memory.zep", 1227); ZEPHIR_MM_RESTORE(); return; } diff --git a/ext/phalcon/acl/adapter/storage.zep.c b/ext/phalcon/acl/adapter/storage.zep.c index 75a9c486c4..5e66159d34 100644 --- a/ext/phalcon/acl/adapter/storage.zep.c +++ b/ext/phalcon/acl/adapter/storage.zep.c @@ -110,8 +110,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, 385, storage); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 386, &key_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 386, storage); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 387, &key_zv); ZEPHIR_CALL_METHOD(NULL, this_ptr, "load", NULL, 0); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -225,8 +225,8 @@ 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, 385, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 386, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 386, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 387, 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) { @@ -621,20 +621,20 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, load) } zephir_memory_observe(&_68); zephir_array_fetch_string(&_68, &data, SL("access"), PH_NOISY, "phalcon/Acl/Adapter/Storage.zep", 149); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 387, &_68); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 388, &_68); zephir_memory_observe(&_69); zephir_array_fetch_string(&_69, &data, SL("accessList"), PH_NOISY, "phalcon/Acl/Adapter/Storage.zep", 150); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 388, &_69); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 389, &rebuiltComponents); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 389, &_69); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 390, &rebuiltComponents); zephir_memory_observe(&_70); zephir_array_fetch_string(&_70, &data, SL("componentsNames"), PH_NOISY, "phalcon/Acl/Adapter/Storage.zep", 152); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 390, &_70); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 391, &rebuiltRoles); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 391, &_70); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 392, &rebuiltRoles); zephir_memory_observe(&_71); zephir_array_fetch_string(&_71, &data, SL("roleInherits"), PH_NOISY, "phalcon/Acl/Adapter/Storage.zep", 154); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 392, &_71); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 393, &defaultAccess); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 394, &noArgumentsDefaultAction); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 393, &_71); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 394, &defaultAccess); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 395, &noArgumentsDefaultAction); RETURN_MM_BOOL(1); } @@ -727,10 +727,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, 387, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 388, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&access, &_0); ZEPHIR_INIT_VAR(&_1); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 395, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 396, PH_NOISY_CC | PH_READONLY); zephir_array_keys(&_1, &_0); if (Z_TYPE_P(&_1) == IS_STRING) { ZEPHIR_INIT_VAR(&_3); @@ -751,7 +751,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, save) ZEPHIR_INIT_NVAR(&accessKey); ZEPHIR_INIT_VAR(&components); array_init(&components); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 389, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 390, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_6) == IS_STRING) { ZEPHIR_INIT_VAR(&_8); zephir_string_to_char_array(&_8, &_6); @@ -804,7 +804,7 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, save) ZEPHIR_INIT_NVAR(&componentName); ZEPHIR_INIT_VAR(&roles); array_init(&roles); - zephir_read_property_cached(&_16, this_ptr, _zephir_prop_3, 391, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16, this_ptr, _zephir_prop_3, 392, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_16) == IS_STRING) { ZEPHIR_INIT_VAR(&_18); zephir_string_to_char_array(&_18, &_16); @@ -855,28 +855,28 @@ PHP_METHOD(Phalcon_Acl_Adapter_Storage, save) } ZEPHIR_INIT_NVAR(&roleObject); ZEPHIR_INIT_NVAR(&roleName); - zephir_read_property_cached(&_26, this_ptr, _zephir_prop_4, 385, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_27, this_ptr, _zephir_prop_5, 386, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_26, this_ptr, _zephir_prop_4, 386, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_27, this_ptr, _zephir_prop_5, 387, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_28); zephir_create_array(&_28, 9, 0); add_assoc_long_ex(&_28, SL("version"), 1); zephir_array_update_string(&_28, SL("access"), &access, PH_COPY | PH_SEPARATE); zephir_memory_observe(&_29); - zephir_read_property_cached(&_29, this_ptr, _zephir_prop_6, 388, PH_NOISY_CC); + zephir_read_property_cached(&_29, this_ptr, _zephir_prop_6, 389, PH_NOISY_CC); zephir_array_update_string(&_28, SL("accessList"), &_29, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_28, SL("components"), &components, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_29); - zephir_read_property_cached(&_29, this_ptr, _zephir_prop_7, 390, PH_NOISY_CC); + zephir_read_property_cached(&_29, this_ptr, _zephir_prop_7, 391, PH_NOISY_CC); zephir_array_update_string(&_28, SL("componentsNames"), &_29, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_28, SL("roles"), &roles, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_29); - zephir_read_property_cached(&_29, this_ptr, _zephir_prop_8, 392, PH_NOISY_CC); + zephir_read_property_cached(&_29, this_ptr, _zephir_prop_8, 393, PH_NOISY_CC); zephir_array_update_string(&_28, SL("roleInherits"), &_29, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_29); - zephir_read_property_cached(&_29, this_ptr, _zephir_prop_9, 393, PH_NOISY_CC); + zephir_read_property_cached(&_29, this_ptr, _zephir_prop_9, 394, PH_NOISY_CC); zephir_array_update_string(&_28, SL("defaultAccess"), &_29, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_29); - zephir_read_property_cached(&_29, this_ptr, _zephir_prop_10, 394, PH_NOISY_CC); + zephir_read_property_cached(&_29, this_ptr, _zephir_prop_10, 395, PH_NOISY_CC); zephir_array_update_string(&_28, SL("noArgumentsDefaultAction"), &_29, PH_COPY | PH_SEPARATE); ZEPHIR_RETURN_CALL_METHOD(&_26, "set", NULL, 0, &_27, &_28); zephir_check_call_status(); diff --git a/ext/phalcon/acl/component.zep.c b/ext/phalcon/acl/component.zep.c index b39c02d1c8..757b76a7a0 100644 --- a/ext/phalcon/acl/component.zep.c +++ b/ext/phalcon/acl/component.zep.c @@ -83,8 +83,8 @@ PHP_METHOD(Phalcon_Acl_Component, __construct) ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_acl_exceptions_forbiddendelimiter_ce, "component", "phalcon/Acl/Component.zep", 31); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 396, &name_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 397, &description_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 397, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 398, &description_zv); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/acl/role.zep.c b/ext/phalcon/acl/role.zep.c index ba3e973989..7c16169c30 100644 --- a/ext/phalcon/acl/role.zep.c +++ b/ext/phalcon/acl/role.zep.c @@ -83,8 +83,8 @@ PHP_METHOD(Phalcon_Acl_Role, __construct) ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_acl_exceptions_forbiddendelimiter_ce, "role", "phalcon/Acl/Role.zep", 31); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 398, &name_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 399, &description_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 399, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 400, &description_zv); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/adr/application.zep.c b/ext/phalcon/adr/application.zep.c index 33a0598d7b..99657ef50e 100644 --- a/ext/phalcon/adr/application.zep.c +++ b/ext/phalcon/adr/application.zep.c @@ -137,7 +137,7 @@ PHP_METHOD(Phalcon_ADR_Application, __construct) ZEPHIR_CALL_METHOD(container, &_1$$3, "newContainer", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 343, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 344, container); ZEPHIR_MM_RESTORE(); } @@ -170,7 +170,7 @@ PHP_METHOD(Phalcon_ADR_Application, bind) ZVAL_STR_COPY(&interfaceName_zv, interfaceName); zephir_memory_observe(&concrete_zv); ZVAL_STR_COPY(&concrete_zv, concrete); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 343, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 344, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "bind", NULL, 0, &interfaceName_zv, &concrete_zv); zephir_check_call_status(); RETURN_THIS(); @@ -226,7 +226,7 @@ PHP_METHOD(Phalcon_ADR_Application, define) } else { zephir_get_arrval(¶meters, parameters_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 343, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 344, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&definition, &_0, "set", NULL, 0, &className_zv, &className_zv); zephir_check_call_status(); zephir_is_iterable(¶meters, 0, "phalcon/ADR/Application.zep", 96); @@ -301,7 +301,7 @@ PHP_METHOD(Phalcon_ADR_Application, extend) extender = 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, 343, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 344, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "extend", NULL, 0, &name_zv, extender); zephir_check_call_status(); RETURN_THIS(); @@ -335,7 +335,7 @@ PHP_METHOD(Phalcon_ADR_Application, factory) factory = 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, 343, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 344, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &name_zv, factory); zephir_check_call_status(); RETURN_THIS(); @@ -437,42 +437,42 @@ PHP_METHOD(Phalcon_ADR_Application, handle) 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(&_0, this_ptr, _zephir_prop_0, 344, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "Phalcon\\Contracts\\ADR\\Router\\Router"); ZEPHIR_CALL_METHOD(&router, &_0, "get", NULL, 0, &_1); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 343, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 344, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "Phalcon\\Contracts\\ADR\\Dispatcher"); ZEPHIR_CALL_METHOD(&dispatcher, &_2, "get", NULL, 0, &_1); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 343, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 344, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "Phalcon\\Contracts\\Events\\Manager"); ZEPHIR_CALL_METHOD(&events, &_3, "get", NULL, 0, &_1); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 344, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 345, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_STRING_IDENTICAL(&_4, "")) { - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 344, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 345, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &router, "setBaseNamespace", NULL, 0, &_5$$3); zephir_check_call_status(); } - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 345, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 346, PH_NOISY_CC | PH_READONLY); if (!(ZEPHIR_IS_EMPTY(&_6))) { - zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_2, 345, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_2, 346, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &router, "setMiddlewareMap", NULL, 0, &_7$$4); zephir_check_call_status(); } - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_3, 346, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_3, 347, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_STRING_IDENTICAL(&_8, "")) { - zephir_read_property_cached(&_9$$5, this_ptr, _zephir_prop_3, 346, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$5, this_ptr, _zephir_prop_3, 347, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &router, "setActionDirectory", NULL, 0, &_9$$5); zephir_check_call_status(); } - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_4, 347, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_4, 348, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_STRING_IDENTICAL(&_10, "")) { - zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_4, 347, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_4, 348, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &router, "setWordSeparator", NULL, 0, &_11$$6); zephir_check_call_status(); } @@ -498,7 +498,7 @@ PHP_METHOD(Phalcon_ADR_Application, handle) goto try_end_1; } - zephir_read_property_cached(&_14$$7, this_ptr, _zephir_prop_0, 343, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$7, this_ptr, _zephir_prop_0, 344, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_16$$7); ZVAL_STRING(&_16$$7, "Phalcon\\Contracts\\ADR\\Router\\AttributeFilter"); ZEPHIR_CALL_METHOD(&_15$$7, &_14$$7, "get", NULL, 0, &_16$$7); @@ -580,7 +580,7 @@ PHP_METHOD(Phalcon_ADR_Application, handle) /* try_start_2: */ - zephir_read_property_cached(&_32$$12, this_ptr, _zephir_prop_0, 343, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_32$$12, this_ptr, _zephir_prop_0, 344, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_34$$12); ZVAL_STRING(&_34$$12, "Phalcon\\ADR\\ErrorResponder"); ZEPHIR_CALL_METHOD(&_33$$12, &_32$$12, "get", NULL, 0, &_34$$12); @@ -656,9 +656,9 @@ PHP_METHOD(Phalcon_ADR_Application, secureWith) ZVAL_STR_COPY(&prefix_zv, prefix); ZEPHIR_INIT_VAR(&list); array_init(&list); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 345, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 346, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, &prefix_zv)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 345, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 346, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&list); zephir_array_fetch(&list, &_1$$3, &prefix_zv, PH_NOISY, "phalcon/ADR/Application.zep", 212); } @@ -695,7 +695,7 @@ PHP_METHOD(Phalcon_ADR_Application, set) definition = 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, 343, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 344, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &name_zv, definition); zephir_check_call_status(); RETURN_THIS(); @@ -720,7 +720,7 @@ PHP_METHOD(Phalcon_ADR_Application, setActionDirectory) Z_PARAM_STR(actionDirectory) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&actionDirectory_zv, actionDirectory); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 346, &actionDirectory_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 347, &actionDirectory_zv); RETURN_THISW(); } @@ -743,7 +743,7 @@ PHP_METHOD(Phalcon_ADR_Application, setBaseNamespace) Z_PARAM_STR(baseNamespace) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&baseNamespace_zv, baseNamespace); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 344, &baseNamespace_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 345, &baseNamespace_zv); RETURN_THISW(); } @@ -766,7 +766,7 @@ PHP_METHOD(Phalcon_ADR_Application, setWordSeparator) Z_PARAM_STR(wordSeparator) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&wordSeparator_zv, wordSeparator); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 347, &wordSeparator_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 348, &wordSeparator_zv); RETURN_THISW(); } diff --git a/ext/phalcon/adr/dispatcher.zep.c b/ext/phalcon/adr/dispatcher.zep.c index 489726ac89..0cee59c9fb 100644 --- a/ext/phalcon/adr/dispatcher.zep.c +++ b/ext/phalcon/adr/dispatcher.zep.c @@ -121,9 +121,9 @@ PHP_METHOD(Phalcon_ADR_Dispatcher, __construct) } else { zephir_get_arrval(&globalMiddleware, globalMiddleware_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 348, container); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 349, events); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 350, &globalMiddleware); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 349, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 350, events); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 351, &globalMiddleware); ZEPHIR_MM_RESTORE(); } @@ -185,7 +185,7 @@ PHP_METHOD(Phalcon_ADR_Dispatcher, dispatch) } else { zephir_get_arrval(&routeMiddleware, routeMiddleware_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 348, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 349, 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))) { @@ -205,21 +205,21 @@ PHP_METHOD(Phalcon_ADR_Dispatcher, dispatch) zephir_fast_array_merge(&middleware, &_2, &_3); ZEPHIR_INIT_VAR(&terminal); object_init_ex(&terminal, phalcon_adr_eventfulhandler_ce); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 349, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 350, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &terminal, "__construct", NULL, 321, &action, &_4); zephir_check_call_status(); ZEPHIR_INIT_VAR(&pipeline); object_init_ex(&pipeline, phalcon_adr_pipeline_ce); ZEPHIR_CALL_METHOD(NULL, &pipeline, "__construct", NULL, 322, &middleware, &terminal); zephir_check_call_status(); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 349, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 350, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_6); ZVAL_STRING(&_6, "pipeline:beforeDispatch"); ZEPHIR_CALL_METHOD(NULL, &_5, "fire", NULL, 0, &_6, this_ptr, request); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&response, &pipeline, "__invoke", NULL, 323, request); zephir_check_call_status(); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 349, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 350, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_6); ZVAL_STRING(&_6, "pipeline:afterDispatch"); ZEPHIR_CALL_METHOD(NULL, &_7, "fire", NULL, 0, &_6, this_ptr, &response); @@ -264,7 +264,7 @@ PHP_METHOD(Phalcon_ADR_Dispatcher, resolveAll) { ZEPHIR_INIT_NVAR(&className); ZVAL_COPY(&className, _0); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 348, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 349, 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", 99); @@ -287,7 +287,7 @@ PHP_METHOD(Phalcon_ADR_Dispatcher, resolveAll) } ZEPHIR_CALL_METHOD(&className, &classes, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 348, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 349, 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", 99); @@ -318,12 +318,12 @@ PHP_METHOD(Phalcon_ADR_Dispatcher, resolveGlobal) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 351, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 352, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 350, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 351, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "resolveAll", NULL, 320, &_2$$3); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 351, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 352, &_1$$3); } RETURN_MM_MEMBER_TYPED(getThis(), "resolvedGlobal", IS_ARRAY); } diff --git a/ext/phalcon/adr/errorresponder.zep.c b/ext/phalcon/adr/errorresponder.zep.c index 9e66cb3d64..0465364328 100644 --- a/ext/phalcon/adr/errorresponder.zep.c +++ b/ext/phalcon/adr/errorresponder.zep.c @@ -133,18 +133,18 @@ PHP_METHOD(Phalcon_ADR_ErrorResponder, __construct) } else { zephir_get_arrval(&exceptionMap, exceptionMap_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 352, chain); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 353, logger); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 353, chain); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 354, logger); if (debug) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 354, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 355, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 354, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 355, &__$false); } ZEPHIR_CALL_METHOD(&_0, this_ptr, "defaultMap", NULL, 325); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_1); zephir_add_function(&_1, &exceptionMap, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 355, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 356, &_1); ZEPHIR_MM_RESTORE(); } @@ -192,7 +192,7 @@ PHP_METHOD(Phalcon_ADR_ErrorResponder, handle) zephir_fetch_params(1, 3, 0, &request, &response, &exception); ZEPHIR_CALL_METHOD(&ref, this_ptr, "correlationId", NULL, 326, request); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 353, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 354, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, exception, 0); ZEPHIR_CALL_METHOD(&_2, exception, "getMessage", NULL, 0); @@ -226,7 +226,7 @@ PHP_METHOD(Phalcon_ADR_ErrorResponder, handle) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&payload, &_8, "withResult", NULL, 0, &_9); zephir_check_call_status(); - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_1, 352, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_1, 353, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_10, "__invoke", NULL, 0, request, response, &payload); zephir_check_call_status(); RETURN_MM(); @@ -321,7 +321,7 @@ PHP_METHOD(Phalcon_ADR_ErrorResponder, details) } else { zephir_get_strval(&status, status_param); } - 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, 355, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { zephir_create_array(return_value, 3, 0); ZEPHIR_CALL_METHOD(&_1$$3, exception, "getMessage", NULL, 0); @@ -420,9 +420,9 @@ PHP_METHOD(Phalcon_ADR_ErrorResponder, resolveStatus) zephir_fetch_params(1, 1, 0, &exception); ZEPHIR_INIT_VAR(&className); zephir_get_class(&className, exception, 0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 355, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 356, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, &className)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 355, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 356, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2$$3); zephir_array_fetch(&_2$$3, &_1$$3, &className, PH_NOISY, "phalcon/ADR/ErrorResponder.zep", 170); RETURN_CCTOR(&_2$$3); @@ -449,9 +449,9 @@ PHP_METHOD(Phalcon_ADR_ErrorResponder, resolveStatus) { ZEPHIR_INIT_NVAR(&ancestor); ZVAL_COPY(&ancestor, _9); - zephir_read_property_cached(&_10$$4, this_ptr, _zephir_prop_0, 355, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$4, this_ptr, _zephir_prop_0, 356, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_10$$4, &ancestor)) { - zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_0, 355, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_0, 356, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_12$$5); zephir_array_fetch(&_12$$5, &_11$$5, &ancestor, PH_NOISY, "phalcon/ADR/ErrorResponder.zep", 180); RETURN_CCTOR(&_12$$5); diff --git a/ext/phalcon/adr/eventfulhandler.zep.c b/ext/phalcon/adr/eventfulhandler.zep.c index 6c79afd728..37bd55daa6 100644 --- a/ext/phalcon/adr/eventfulhandler.zep.c +++ b/ext/phalcon/adr/eventfulhandler.zep.c @@ -73,8 +73,8 @@ PHP_METHOD(Phalcon_ADR_EventfulHandler, __construct) Z_PARAM_OBJECT_OF_CLASS(events, phalcon_contracts_events_manager_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(2, 0, &action, &events); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 356, action); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 357, events); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 357, action); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 358, events); } PHP_METHOD(Phalcon_ADR_EventfulHandler, __invoke) @@ -107,17 +107,17 @@ PHP_METHOD(Phalcon_ADR_EventfulHandler, __invoke) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &request); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 357, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 356, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 358, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 357, 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, 356, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 357, 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, 357, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 356, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 358, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 357, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "adr:afterExecuteAction"); ZEPHIR_CALL_METHOD(NULL, &_4, "fire", NULL, 0, &_2, &_5, &response); diff --git a/ext/phalcon/adr/input/input.zep.c b/ext/phalcon/adr/input/input.zep.c index 87304bbcc5..2dfb139b24 100644 --- a/ext/phalcon/adr/input/input.zep.c +++ b/ext/phalcon/adr/input/input.zep.c @@ -85,7 +85,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, 358, &data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 359, &data); ZEPHIR_MM_RESTORE(); } @@ -208,9 +208,9 @@ PHP_METHOD(Phalcon_ADR_Input_Input, get) defaultValue = &__$null; } ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 358, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 359, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_1, &key_zv)) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 358, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 359, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_0); zephir_array_fetch(&_0, &_2, &key_zv, PH_NOISY, "phalcon/ADR/Input/Input.zep", 83); } else { @@ -236,7 +236,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, 358, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 359, 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 index 23993481e8..92bb4d32f5 100644 --- a/ext/phalcon/adr/middleware/corsmiddleware.zep.c +++ b/ext/phalcon/adr/middleware/corsmiddleware.zep.c @@ -152,7 +152,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, __construct) ZVAL_STRING(&_2, "origins"); ZEPHIR_CALL_METHOD(&_0, this_ptr, "getArrVal", NULL, 0, &config, &_2, &_1); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 359, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 360, &_0); ZEPHIR_INIT_VAR(&_4); zephir_create_array(&_4, 6, 0); ZEPHIR_INIT_NVAR(&_2); @@ -177,7 +177,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, __construct) ZVAL_STRING(&_2, "methods"); ZEPHIR_CALL_METHOD(&_3, this_ptr, "getArrVal", NULL, 0, &config, &_2, &_4); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 360, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 361, &_3); ZEPHIR_INIT_VAR(&_6); zephir_create_array(&_6, 2, 0); ZEPHIR_INIT_NVAR(&_2); @@ -190,7 +190,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, __construct) ZVAL_STRING(&_2, "headers"); ZEPHIR_CALL_METHOD(&_5, this_ptr, "getArrVal", NULL, 0, &config, &_2, &_6); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 361, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 362, &_5); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "credentials"); ZVAL_BOOL(&_8, 0); @@ -198,7 +198,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, __construct) ZVAL_STRING(&_9, "bool"); ZEPHIR_CALL_METHOD(&_7, this_ptr, "getArrVal", NULL, 0, &config, &_2, &_8, &_9); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 362, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 363, &_7); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "maxAge"); ZVAL_LONG(&_8, 0); @@ -206,7 +206,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, __construct) ZVAL_STRING(&_9, "int"); ZEPHIR_CALL_METHOD(&_10, this_ptr, "getArrVal", NULL, 0, &config, &_2, &_8, &_9); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 363, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 364, &_10); ZEPHIR_MM_RESTORE(); } @@ -286,23 +286,23 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, __invoke) ZEPHIR_CALL_METHOD(NULL, this_ptr, "applyHeaders", NULL, 0, &response, &origin); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_6$$4); - zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 360, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 361, 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, 335, &_7$$4, &_6$$4); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_7$$4); - zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_1, 361, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_1, 362, 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, 335, &_9$$4, &_7$$4); zephir_check_call_status(); - zephir_read_property_cached(&_10$$4, this_ptr, _zephir_prop_2, 363, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$4, this_ptr, _zephir_prop_2, 364, 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, 363, PH_NOISY_CC); + zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_2, 364, PH_NOISY_CC); zephir_cast_to_string(&_12$$5, &_11$$5); ZEPHIR_INIT_VAR(&_13$$5); ZVAL_STRING(&_13$$5, "Access-Control-Max-Age"); @@ -355,10 +355,10 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, applyHeaders) response = ZEND_CALL_ARG(execute_data, 1); zephir_memory_observe(&origin_zv); ZVAL_STR_COPY(&origin_zv, origin); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 362, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 363, PH_NOISY_CC | PH_READONLY); _1 = zephir_is_true(&_0); if (_1) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 359, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 360, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_3, "in_array", NULL, 88, &origin_zv, &_2, &__$true); zephir_check_call_status(); _1 = !zephir_is_true(&_3); @@ -370,7 +370,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, applyHeaders) ZVAL_STRING(&_4, "Access-Control-Allow-Origin"); ZEPHIR_CALL_METHOD(NULL, response, "setHeader", NULL, 0, &_4, &origin_zv); zephir_check_call_status(); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 362, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 363, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_5)) { ZEPHIR_INIT_VAR(&_6$$4); ZVAL_STRING(&_6$$4, "Access-Control-Allow-Credentials"); @@ -408,7 +408,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, isAllowed) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&origin_zv); ZVAL_STR_COPY(&origin_zv, origin); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 359, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 360, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "*"); ZEPHIR_CALL_FUNCTION(&_2, "in_array", NULL, 88, &_1, &_0, &__$true); @@ -416,7 +416,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_CorsMiddleware, isAllowed) if (zephir_is_true(&_2)) { RETURN_MM_BOOL(1); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 359, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 360, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_FUNCTION("in_array", NULL, 88, &origin_zv, &_3, &__$true); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/adr/middleware/methodoverridemiddleware.zep.c b/ext/phalcon/adr/middleware/methodoverridemiddleware.zep.c index 23b80f8770..c678a76ab5 100644 --- a/ext/phalcon/adr/middleware/methodoverridemiddleware.zep.c +++ b/ext/phalcon/adr/middleware/methodoverridemiddleware.zep.c @@ -108,7 +108,7 @@ PHP_METHOD(Phalcon_ADR_Middleware_MethodOverrideMiddleware, __invoke) zephir_cast_to_string(&_4$$3, &_2$$3); ZEPHIR_INIT_VAR(&spoofed); zephir_fast_strtoupper(&spoofed, &_4$$3); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 364, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 365, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_6$$3, "in_array", NULL, 88, &spoofed, &_5$$3, &__$true); zephir_check_call_status(); if (zephir_is_true(&_6$$3)) { diff --git a/ext/phalcon/adr/pipeline.zep.c b/ext/phalcon/adr/pipeline.zep.c index 67c9e2dbf3..485050c9d3 100644 --- a/ext/phalcon/adr/pipeline.zep.c +++ b/ext/phalcon/adr/pipeline.zep.c @@ -104,11 +104,11 @@ PHP_METHOD(Phalcon_ADR_Pipeline, __construct) index = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 365, &middleware); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 366, terminal); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 366, &middleware); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 367, terminal); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, index); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 367, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 368, &_0); ZEPHIR_MM_RESTORE(); } @@ -151,24 +151,24 @@ PHP_METHOD(Phalcon_ADR_Pipeline, __invoke) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &request); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 367, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 365, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 368, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 366, 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, 366, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 367, 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, 365, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 366, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&mw); zephir_memory_observe(&_4); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 367, PH_NOISY_CC); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 368, PH_NOISY_CC); zephir_array_fetch(&mw, &_3, &_4, PH_NOISY, "phalcon/ADR/Pipeline.zep", 52); ZEPHIR_INIT_VAR(&next); object_init_ex(&next, phalcon_adr_pipeline_ce); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 365, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 366, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 367, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 366, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 367, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 368, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_8); ZVAL_LONG(&_8, 1); ZEPHIR_INIT_VAR(&_9); diff --git a/ext/phalcon/adr/responder/formatresponder.zep.c b/ext/phalcon/adr/responder/formatresponder.zep.c index 6c577ac856..b69c4b26c1 100644 --- a/ext/phalcon/adr/responder/formatresponder.zep.c +++ b/ext/phalcon/adr/responder/formatresponder.zep.c @@ -81,7 +81,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, 368, &formatters); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 369, &formatters); ZEPHIR_MM_RESTORE(); } @@ -127,7 +127,7 @@ PHP_METHOD(Phalcon_ADR_Responder_FormatResponder, __invoke) zephir_fetch_params(1, 3, 0, &request, &response, &payload); ZEPHIR_INIT_VAR(&chosen); ZVAL_NULL(&chosen); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 368, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 369, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_0)) { RETVAL_ZVAL(response, 1, 0); RETURN_MM(); @@ -138,7 +138,7 @@ PHP_METHOD(Phalcon_ADR_Responder_FormatResponder, __invoke) zephir_check_call_status(); zephir_cast_to_string(&_3, &_1); ZEPHIR_CPY_WRT(&accept, &_3); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 368, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 369, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_4) == IS_STRING) { ZEPHIR_INIT_NVAR(&_2); zephir_string_to_char_array(&_2, &_4); @@ -187,7 +187,7 @@ PHP_METHOD(Phalcon_ADR_Responder_FormatResponder, __invoke) } ZEPHIR_INIT_NVAR(&formatter); if (Z_TYPE_P(&chosen) == IS_NULL) { - zephir_read_property_cached(&_11$$8, this_ptr, _zephir_prop_0, 368, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$8, this_ptr, _zephir_prop_0, 369, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&chosen); zephir_array_fetch_long(&chosen, &_11$$8, 0, PH_NOISY, "phalcon/ADR/Responder/FormatResponder.zep", 62); } diff --git a/ext/phalcon/adr/responder/redirect.zep.c b/ext/phalcon/adr/responder/redirect.zep.c index 5655ace141..0b098d7dd0 100644 --- a/ext/phalcon/adr/responder/redirect.zep.c +++ b/ext/phalcon/adr/responder/redirect.zep.c @@ -104,14 +104,14 @@ PHP_METHOD(Phalcon_ADR_Responder_Redirect, __construct) external = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 369, &url_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 370, &url_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, status); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 370, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 371, &_0); if (external) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 371, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 372, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 371, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 372, &__$false); } } diff --git a/ext/phalcon/adr/responder/statusmapper.zep.c b/ext/phalcon/adr/responder/statusmapper.zep.c index 0d5197bf58..a427b511ae 100644 --- a/ext/phalcon/adr/responder/statusmapper.zep.c +++ b/ext/phalcon/adr/responder/statusmapper.zep.c @@ -110,7 +110,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, 372, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 373, &_1); ZEPHIR_MM_RESTORE(); } @@ -143,9 +143,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, 372, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 373, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_1, &status_zv)) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 372, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 373, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_0); zephir_array_fetch(&_0, &_2, &status_zv, PH_NOISY, "phalcon/ADR/Responder/StatusMapper.zep", 72); } else { diff --git a/ext/phalcon/adr/responder/statusresponder.zep.c b/ext/phalcon/adr/responder/statusresponder.zep.c index 8466c22759..2193c45a9c 100644 --- a/ext/phalcon/adr/responder/statusresponder.zep.c +++ b/ext/phalcon/adr/responder/statusresponder.zep.c @@ -81,9 +81,9 @@ PHP_METHOD(Phalcon_ADR_Responder_StatusResponder, __construct) object_init_ex(&_0$$3, phalcon_adr_responder_statusmapper_ce); ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 337); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 373, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 374, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 373, mapper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 374, mapper); } ZEPHIR_MM_RESTORE(); } @@ -119,7 +119,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, 373, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 374, 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/responder/viewresponder.zep.c b/ext/phalcon/adr/responder/viewresponder.zep.c index 923c1cd9d4..4e6450aaff 100644 --- a/ext/phalcon/adr/responder/viewresponder.zep.c +++ b/ext/phalcon/adr/responder/viewresponder.zep.c @@ -107,9 +107,9 @@ PHP_METHOD(Phalcon_ADR_Responder_ViewResponder, __construct) zephir_memory_observe(&template_zv); ZVAL_STR_COPY(&template_zv, template); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 374, renderer); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 375, statusMapper); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 376, &template_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 375, renderer); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 376, statusMapper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 377, &template_zv); ZEPHIR_MM_RESTORE(); } @@ -156,13 +156,13 @@ PHP_METHOD(Phalcon_ADR_Responder_ViewResponder, __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, 374, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 376, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 375, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 377, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, this_ptr, "viewData", NULL, 338, payload); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&html, &_0, "render", NULL, 0, &_1, &_2); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 375, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 376, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_6, payload, "getStatus", NULL, 0); zephir_check_call_status(); zephir_cast_to_string(&_7, &_6); diff --git a/ext/phalcon/adr/router/router.zep.c b/ext/phalcon/adr/router/router.zep.c index c54265f315..40394d0655 100644 --- a/ext/phalcon/adr/router/router.zep.c +++ b/ext/phalcon/adr/router/router.zep.c @@ -243,7 +243,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, classFor) zephir_fast_explode_str(&segments, SL("/"), &uri, ZEND_LONG_MAX); } if (ZEPHIR_IS_EMPTY(&segments)) { - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 377, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 378, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_VSV(return_value, &_2$$3, "\\", &verb); RETURN_MM(); } @@ -264,7 +264,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, classFor) zephir_array_append(&parts, &_6$$4, PH_SEPARATE, "phalcon/ADR/Router/Router.zep", 140); } ZEND_HASH_FOREACH_END(); ZEPHIR_INIT_NVAR(&segment); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 377, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 378, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_9); zephir_fast_join_str(&_9, SL("\\"), &parts); ZEPHIR_INIT_VAR(&_10); @@ -314,7 +314,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, match) 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, 378, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 379, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_STRING_IDENTICAL(&_0, "")) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_adr_exceptions_actiondirectorynotset_ce); @@ -496,7 +496,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, pathFor) if (Z_TYPE_P(&_0) == IS_NULL) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 377, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 378, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2, (zephir_fast_strlen_ev(&_1) + 1)); ZEPHIR_INIT_VAR(&_3); zephir_substr(&_3, &className_zv, zephir_get_intval(&_2), 0, ZEPHIR_SUBSTR_NO_LENGTH); @@ -606,7 +606,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, setActionDirectory) ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "/"); zephir_fast_trim(&_0, &actionDirectory_zv, &_1, ZEPHIR_TRIM_RIGHT); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 378, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 379, &_0); RETURN_THIS(); } @@ -636,7 +636,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, setBaseNamespace) ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "\\"); zephir_fast_trim(&_0, &baseNamespace_zv, &_1, ZEPHIR_TRIM_RIGHT); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 377, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 378, &_0); RETURN_THIS(); } @@ -663,7 +663,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, setMiddlewareMap) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &middlewareMap_param); zephir_get_arrval(&middlewareMap, middlewareMap_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 379, &middlewareMap); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 380, &middlewareMap); RETURN_THIS(); } @@ -683,7 +683,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, setWordSeparator) Z_PARAM_STR(wordSeparator) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&wordSeparator_zv, wordSeparator); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 380, &wordSeparator_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 381, &wordSeparator_zv); RETURN_THISW(); } @@ -772,8 +772,8 @@ PHP_METHOD(Phalcon_ADR_Router_Router, camelize) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&segment_zv); ZVAL_STR_COPY(&segment_zv, segment); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 380, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 380, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 381, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 381, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_2, "ucwords", NULL, 354, &segment_zv, &_1); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_3); @@ -808,7 +808,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, decamelize) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&part_zv); ZVAL_STR_COPY(&part_zv, part); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 380, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 381, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZEPHIR_CONCAT_SVS(&_1, "$1", &_0, "$2"); ZEPHIR_INIT_VAR(&_2); @@ -899,7 +899,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, deriveCandidates) zephir_fast_explode_str(&segments, SL("/"), &uri, ZEND_LONG_MAX); } if (ZEPHIR_IS_EMPTY(&segments)) { - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 377, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 378, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&className); ZEPHIR_CONCAT_VSV(&className, &_2$$3, "\\", &verb); zephir_create_array(return_value, 1, 0); @@ -938,7 +938,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, deriveCandidates) array_init(return_value); RETURN_MM(); } - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 377, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 378, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_11); zephir_fast_join_str(&_11, SL(""), &parts); ZEPHIR_INIT_NVAR(&className); @@ -981,7 +981,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, hasSubNamespace) if (zephir_memnstr_str(&subNamespace_zv, SL(".."), "phalcon/ADR/Router/Router.zep", 369)) { RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 378, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 379, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "\\"); @@ -1161,7 +1161,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, middlewareFor) ZVAL_STR_COPY(&className_zv, className); ZEPHIR_INIT_VAR(&stacked); array_init(&stacked); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 379, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 380, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); @@ -1181,7 +1181,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, middlewareFor) } ZEPHIR_INIT_NVAR(&list); ZVAL_COPY(&list, _3); - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_1, 377, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_1, 378, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&full); ZEPHIR_CONCAT_VV(&full, &_6$$3, &prefix); ZVAL_LONG(&_7$$3, zephir_fast_strlen_ev(&full)); @@ -1213,7 +1213,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, middlewareFor) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&list, _1, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_13$$5, this_ptr, _zephir_prop_1, 377, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$5, this_ptr, _zephir_prop_1, 378, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&full); ZEPHIR_CONCAT_VV(&full, &_13$$5, &prefix); ZVAL_LONG(&_14$$5, zephir_fast_strlen_ev(&full)); @@ -1283,7 +1283,7 @@ PHP_METHOD(Phalcon_ADR_Router_Router, verbOf) 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, 377, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 378, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&prefix); ZEPHIR_CONCAT_VS(&prefix, &_0, "\\"); ZVAL_LONG(&_1, zephir_fast_strlen_ev(&prefix)); diff --git a/ext/phalcon/adr/router/routermatch.zep.c b/ext/phalcon/adr/router/routermatch.zep.c index 3e66558b62..676da79942 100644 --- a/ext/phalcon/adr/router/routermatch.zep.c +++ b/ext/phalcon/adr/router/routermatch.zep.c @@ -142,10 +142,10 @@ PHP_METHOD(Phalcon_ADR_Router_RouterMatch, __construct) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 381, &action_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 382, &attributes); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 383, &middleware); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 384, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 382, &action_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 383, &attributes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 384, &middleware); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 385, &name_zv); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/annotations/adapter/apcu.zep.c b/ext/phalcon/annotations/adapter/apcu.zep.c index bb06b109f7..9a567d26fe 100644 --- a/ext/phalcon/annotations/adapter/apcu.zep.c +++ b/ext/phalcon/annotations/adapter/apcu.zep.c @@ -99,11 +99,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, 400, &prefix); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 401, &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, 401, &ttl); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 402, &ttl); } ZEPHIR_MM_RESTORE(); } @@ -136,7 +136,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, 400, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 401, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); ZEPHIR_CONCAT_SVV(&_2, "_PHAN", &_1, &key_zv); zephir_fast_strtolower(&_0, &_2); @@ -181,11 +181,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, 400, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 401, 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, 401, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 402, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_FUNCTION("apcu_store", NULL, 290, &_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 113a84580e..a56b5f0a72 100644 --- a/ext/phalcon/annotations/adapter/memory.zep.c +++ b/ext/phalcon/annotations/adapter/memory.zep.c @@ -102,7 +102,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, 402, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 403, 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 868b0dcd4f..c0c7919f2f 100644 --- a/ext/phalcon/annotations/adapter/stream.zep.c +++ b/ext/phalcon/annotations/adapter/stream.zep.c @@ -95,7 +95,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, 403, &annotationsDir); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 404, &annotationsDir); } ZEPHIR_MM_RESTORE(); } @@ -267,7 +267,7 @@ PHP_METHOD(Phalcon_Annotations_Adapter_Stream, getFilePath) ZEPHIR_CONCAT_VSV(&_2$$3, &name, "_", &_1$$3); ZEPHIR_CPY_WRT(&name, &_2$$3); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 403, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 404, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_VVS(return_value, &_3, &name, ".php"); RETURN_MM(); } diff --git a/ext/phalcon/annotations/annotation.zep.c b/ext/phalcon/annotations/annotation.zep.c index 5ce0d8e6bb..ecf6076334 100644 --- a/ext/phalcon/annotations/annotation.zep.c +++ b/ext/phalcon/annotations/annotation.zep.c @@ -130,7 +130,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", 76); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 404, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 405, &_0$$3); } zephir_memory_observe(&exprArguments); if (zephir_array_isset_string_fetch(&exprArguments, &reflectionData, SL("arguments"), 0)) { @@ -191,8 +191,8 @@ PHP_METHOD(Phalcon_Annotations_Annotation, __construct) } } ZEPHIR_INIT_NVAR(&argument); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 405, &arguments); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 406, &exprArguments); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 406, &arguments); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 407, &exprArguments); } ZEPHIR_MM_RESTORE(); } @@ -223,7 +223,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, 405, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 406, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&argument, &_0, position, 0)) { RETURN_CCTOR(&argument); } @@ -438,7 +438,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, 405, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 406, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&argument, &_0, &name_zv, 0)) { RETURN_CCTOR(&argument); } @@ -490,7 +490,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, 405, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 406, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, position)); } @@ -507,7 +507,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, 405, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 406, 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 7d4c36c89e..1905761b58 100644 --- a/ext/phalcon/annotations/collection.zep.c +++ b/ext/phalcon/annotations/collection.zep.c @@ -152,7 +152,7 @@ PHP_METHOD(Phalcon_Annotations_Collection, __construct) } } ZEPHIR_INIT_NVAR(&annotationData); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 407, &annotations); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 408, &annotations); ZEPHIR_MM_RESTORE(); } @@ -169,7 +169,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, 407, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 408, PH_NOISY_CC | PH_READONLY); RETURN_LONG(zephir_fast_count_int(&_0)); } @@ -199,8 +199,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, 407, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 408, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 408, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 409, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&annotation, &_0, &_1, 0))) { RETURN_MM_BOOL(0); } @@ -240,7 +240,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, 407, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 408, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&annotations, &_0); if (Z_TYPE_P(&annotations) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); @@ -334,7 +334,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, 407, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 408, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&annotations, &_0); if (Z_TYPE_P(&annotations) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); @@ -427,7 +427,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, 407, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 408, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&annotations, &_0); if (Z_TYPE_P(&annotations) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); @@ -510,7 +510,7 @@ PHP_METHOD(Phalcon_Annotations_Collection, rewind) } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 408, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 409, &_0); } /** @@ -531,8 +531,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, 407, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 408, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 408, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 409, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &_1)); } diff --git a/ext/phalcon/annotations/models/metadata/column.zep.c b/ext/phalcon/annotations/models/metadata/column.zep.c index 5c7b6c17ce..bce69add48 100644 --- a/ext/phalcon/annotations/models/metadata/column.zep.c +++ b/ext/phalcon/annotations/models/metadata/column.zep.c @@ -198,32 +198,32 @@ PHP_METHOD(Phalcon_Annotations_Models_MetaData_Column, __construct) defaultValue = &defaultValue_sub; defaultValue = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 409, &column_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 410, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 410, &column_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 411, &type_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, length); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 411, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 412, &_0); if (nullable) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 412, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 413, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 412, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 413, &__$false); } if (skipOnInsert) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 413, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 414, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 413, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 414, &__$false); } if (skipOnUpdate) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 414, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 415, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 414, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 415, &__$false); } if (allowEmptyString) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 415, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 416, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 415, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 416, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 416, defaultValue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 417, defaultValue); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/annotations/models/metadata/source.zep.c b/ext/phalcon/annotations/models/metadata/source.zep.c index 0f36f4e765..6de0029a91 100644 --- a/ext/phalcon/annotations/models/metadata/source.zep.c +++ b/ext/phalcon/annotations/models/metadata/source.zep.c @@ -60,6 +60,6 @@ PHP_METHOD(Phalcon_Annotations_Models_MetaData_Source, __construct) Z_PARAM_STR(table) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&table_zv, table); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 417, &table_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 418, &table_zv); } diff --git a/ext/phalcon/annotations/reflection.zep.c b/ext/phalcon/annotations/reflection.zep.c index 0c114ce05f..7882775a4f 100644 --- a/ext/phalcon/annotations/reflection.zep.c +++ b/ext/phalcon/annotations/reflection.zep.c @@ -115,7 +115,7 @@ PHP_METHOD(Phalcon_Annotations_Reflection, __construct) } else { zephir_get_arrval(&reflectionData, reflectionData_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 418, &reflectionData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 419, &reflectionData); ZEPHIR_MM_RESTORE(); } @@ -146,16 +146,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, 419, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 420, 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, 418, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 419, 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, 85, &reflectionClass); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 419, &_2$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 420, &_2$$4); } } RETURN_MM_MEMBER(getThis(), "classAnnotations"); @@ -195,7 +195,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, 418, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 419, 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) { @@ -295,7 +295,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, 418, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 419, 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) { @@ -395,7 +395,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, 418, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 419, 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/annotations/router/routeprefix.zep.c b/ext/phalcon/annotations/router/routeprefix.zep.c index 563399786a..ef2d11b8e0 100644 --- a/ext/phalcon/annotations/router/routeprefix.zep.c +++ b/ext/phalcon/annotations/router/routeprefix.zep.c @@ -61,6 +61,6 @@ PHP_METHOD(Phalcon_Annotations_Router_RoutePrefix, __construct) Z_PARAM_STR(prefix) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&prefix_zv, prefix); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 420, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 421, &prefix_zv); } diff --git a/ext/phalcon/assets/collection.zep.c b/ext/phalcon/assets/collection.zep.c index 8a094cdba3..c0c6156aea 100644 --- a/ext/phalcon/assets/collection.zep.c +++ b/ext/phalcon/assets/collection.zep.c @@ -505,7 +505,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, 421, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 422, PH_NOISY_CC | PH_READONLY); RETURN_LONG(zephir_fast_count_int(&_0)); } @@ -561,7 +561,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, 421, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 422, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 19, &_0); zephir_check_call_status(); RETURN_MM(); @@ -610,7 +610,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, 422, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 423, 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); @@ -679,7 +679,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, 421, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 422, PH_NOISY_CC | PH_READONLY); RETURN_MM_BOOL(zephir_array_isset_value(&_0, &key)); } @@ -714,9 +714,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, 423, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 424, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 423, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 424, &__$false); } RETURN_THISW(); } @@ -746,7 +746,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, 424, &attributes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 425, &attributes); RETURN_THIS(); } @@ -768,9 +768,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, 425, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 426, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 425, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 426, &__$false); } RETURN_THISW(); } @@ -800,7 +800,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, 426, &filters); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 427, &filters); RETURN_THIS(); } @@ -823,7 +823,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, 427, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 428, &prefix_zv); RETURN_THISW(); } @@ -848,9 +848,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, 428, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 429, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 428, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 429, &__$false); } RETURN_THISW(); } @@ -874,7 +874,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, 429, &version_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 430, &version_zv); RETURN_THISW(); } @@ -1006,7 +1006,7 @@ 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, 430, PH_NOISY_CC); + zephir_read_property_cached(&flag, this_ptr, _zephir_prop_0, 431, PH_NOISY_CC); ZEPHIR_CALL_METHOD(&attrs, this_ptr, "processAttributes", NULL, 378, &attributes); zephir_check_call_status(); if (Z_TYPE_P(isLocal) != IS_NULL) { @@ -1161,7 +1161,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, 424, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 425, PH_NOISY_CC); zephir_get_arrval(&_2, &_1); ZEPHIR_CPY_WRT(&_0, &_2); } @@ -1190,7 +1190,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, 424, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 425, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } @@ -1777,9 +1777,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, 430, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 431, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 430, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 431, &__$false); } RETURN_THISW(); } @@ -1803,7 +1803,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, 431, &sourcePath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 432, &sourcePath_zv); RETURN_THISW(); } @@ -1826,7 +1826,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, 422, &targetPath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 423, &targetPath_zv); RETURN_THISW(); } @@ -1849,7 +1849,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, 432, &targetUri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 433, &targetUri_zv); RETURN_THISW(); } diff --git a/ext/phalcon/assets/manager.zep.c b/ext/phalcon/assets/manager.zep.c index bade347960..87ccfcf30b 100644 --- a/ext/phalcon/assets/manager.zep.c +++ b/ext/phalcon/assets/manager.zep.c @@ -114,8 +114,8 @@ PHP_METHOD(Phalcon_Assets_Manager, __construct) } else { zephir_get_arrval(&options, options_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 433, tagFactory); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 434, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 434, tagFactory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 435, &options); ZEPHIR_MM_RESTORE(); } @@ -741,7 +741,7 @@ 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, 435, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 436, 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); @@ -751,7 +751,7 @@ PHP_METHOD(Phalcon_Assets_Manager, get) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 435, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 436, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_3); zephir_array_fetch(&_3, &_2, &name_zv, PH_NOISY, "phalcon/Assets/Manager.zep", 280); RETURN_CCTOR(&_3); @@ -848,7 +848,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, 435, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 436, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &name_zv)); } @@ -974,7 +974,7 @@ PHP_METHOD(Phalcon_Assets_Manager, output) zephir_create_array(&callback, 2, 0); zephir_array_fast_append(&callback, this_ptr); zephir_array_fast_append(&callback, &callbackMethod); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 434, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 435, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_1); ZEPHIR_CALL_METHOD(&_2, collection, "getAssets", NULL, 0); zephir_check_call_status(); @@ -1068,7 +1068,7 @@ PHP_METHOD(Phalcon_Assets_Manager, output) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&html, this_ptr, "doCallback", &_19, 390, &callback, &_17$$12, &prefixedPath, &_18$$12); zephir_check_call_status(); - zephir_read_property_cached(&_20$$12, this_ptr, _zephir_prop_1, 436, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$12, this_ptr, _zephir_prop_1, 437, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_20$$12)) { zend_print_zval(&html, 0); } else { @@ -1112,7 +1112,7 @@ PHP_METHOD(Phalcon_Assets_Manager, output) ZVAL_BOOL(&_29$$19, 1); ZEPHIR_CALL_METHOD(&html, this_ptr, "doCallback", &_19, 390, &callback, &_27$$19, &prefixedPath, &_29$$19); zephir_check_call_status(); - zephir_read_property_cached(&_29$$19, this_ptr, _zephir_prop_1, 436, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$19, this_ptr, _zephir_prop_1, 437, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_29$$19)) { zend_print_zval(&html, 0); } else { @@ -1183,7 +1183,7 @@ PHP_METHOD(Phalcon_Assets_Manager, output) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&html, this_ptr, "doCallback", &_19, 390, &callback, &_39$$26, &prefixedPath, &_40$$26); zephir_check_call_status(); - zephir_read_property_cached(&_41$$26, this_ptr, _zephir_prop_1, 436, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_41$$26, this_ptr, _zephir_prop_1, 437, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_41$$26)) { zend_print_zval(&html, 0); } else { @@ -1227,7 +1227,7 @@ PHP_METHOD(Phalcon_Assets_Manager, output) ZVAL_BOOL(&_47$$33, 1); ZEPHIR_CALL_METHOD(&html, this_ptr, "doCallback", &_19, 390, &callback, &_46$$33, &prefixedPath, &_47$$33); zephir_check_call_status(); - zephir_read_property_cached(&_47$$33, this_ptr, _zephir_prop_1, 436, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_47$$33, this_ptr, _zephir_prop_1, 437, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_47$$33)) { zend_print_zval(&html, 0); } else { @@ -1415,7 +1415,7 @@ PHP_METHOD(Phalcon_Assets_Manager, outputInline) if (ZEPHIR_IS_TRUE_IDENTICAL(&join)) { zephir_concat_self(&joinedContent, &content); } else { - zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_0, 433, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_0, 434, PH_NOISY_CC | PH_READONLY); ZVAL_BOOL(&_8$$6, 1); ZEPHIR_CALL_METHOD(&_7$$6, &_6$$6, "element", NULL, 0, type, &content, &attributes, &_8$$6); zephir_check_call_status(); @@ -1455,7 +1455,7 @@ PHP_METHOD(Phalcon_Assets_Manager, outputInline) if (ZEPHIR_IS_TRUE_IDENTICAL(&join)) { zephir_concat_self(&joinedContent, &content); } else { - zephir_read_property_cached(&_15$$9, this_ptr, _zephir_prop_0, 433, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$9, this_ptr, _zephir_prop_0, 434, PH_NOISY_CC | PH_READONLY); ZVAL_BOOL(&_17$$9, 1); ZEPHIR_CALL_METHOD(&_16$$9, &_15$$9, "element", NULL, 0, type, &content, &attributes, &_17$$9); zephir_check_call_status(); @@ -1469,7 +1469,7 @@ PHP_METHOD(Phalcon_Assets_Manager, outputInline) } ZEPHIR_INIT_NVAR(&code); if (ZEPHIR_IS_TRUE_IDENTICAL(&join)) { - zephir_read_property_cached(&_20$$10, this_ptr, _zephir_prop_0, 433, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$10, this_ptr, _zephir_prop_0, 434, PH_NOISY_CC | PH_READONLY); ZVAL_BOOL(&_22$$10, 1); ZEPHIR_CALL_METHOD(&_21$$10, &_20$$10, "element", NULL, 0, type, &joinedContent, &attributes, &_22$$10); zephir_check_call_status(); @@ -1479,7 +1479,7 @@ PHP_METHOD(Phalcon_Assets_Manager, outputInline) ZEPHIR_CONCAT_VV(&_24$$10, &_21$$10, &_23$$10); zephir_concat_self(&html, &_24$$10); } - zephir_read_property_cached(&_25$$3, this_ptr, _zephir_prop_1, 436, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$3, this_ptr, _zephir_prop_1, 437, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_25$$3)) { zend_print_zval(&html, 0); } else { @@ -1663,7 +1663,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, 434, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 435, &options); RETURN_THIS(); } @@ -1688,9 +1688,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, 436, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 437, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 436, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 437, &__$false); } RETURN_THISW(); } @@ -1899,7 +1899,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, 435, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 436, 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); @@ -1910,7 +1910,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, 435, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 436, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_3); zephir_array_fetch(&_3, &_2, &type_zv, PH_NOISY, "phalcon/Assets/Manager.zep", 818); RETURN_CCTOR(&_3); @@ -2138,7 +2138,7 @@ PHP_METHOD(Phalcon_Assets_Manager, getOutput) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&html, this_ptr, "doCallback", NULL, 390, &callback, &_1, &prefixedPath, &_2); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 436, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 437, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_3)) { zend_print_zval(&html, 0); } else { @@ -2418,10 +2418,10 @@ PHP_METHOD(Phalcon_Assets_Manager, processParameters) zephir_array_fetch(&tag, ¶ms, &name_zv, PH_NOISY, "phalcon/Assets/Manager.zep", 1064); zephir_array_unset(¶ms, &name_zv, PH_SEPARATE); if (local) { - zephir_read_property_cached(&_8$$11, this_ptr, _zephir_prop_0, 437, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$11, this_ptr, _zephir_prop_0, 438, 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, 437, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$11, this_ptr, _zephir_prop_0, 438, 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); @@ -2429,7 +2429,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, 437, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$12, this_ptr, _zephir_prop_0, 438, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_14$$12); ZVAL_STRING(&_14$$12, "url"); ZEPHIR_CALL_METHOD(&url, &_13$$12, "get", NULL, 0, &_14$$12); @@ -2447,7 +2447,7 @@ PHP_METHOD(Phalcon_Assets_Manager, processParameters) ZEPHIR_CPY_WRT(&tag, &_18$$13); } } - zephir_read_property_cached(&_19, this_ptr, _zephir_prop_1, 433, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19, this_ptr, _zephir_prop_1, 434, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&helper, &_19, "newInstance", NULL, 0, &helperClass_zv); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_20); diff --git a/ext/phalcon/assets/traits/attributestrait.zep.c b/ext/phalcon/assets/traits/attributestrait.zep.c index a1f8c8b7fe..cfc9132791 100644 --- a/ext/phalcon/assets/traits/attributestrait.zep.c +++ b/ext/phalcon/assets/traits/attributestrait.zep.c @@ -67,7 +67,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, 438, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 439, 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 1d3dcec800..32223cff53 100644 --- a/ext/phalcon/assets/traits/sourcetargettrait.zep.c +++ b/ext/phalcon/assets/traits/sourcetargettrait.zep.c @@ -108,9 +108,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, 439, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 440, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 439, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 440, &__$false); } RETURN_THISW(); } @@ -134,7 +134,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, 440, &sourcePath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 441, &sourcePath_zv); RETURN_THISW(); } @@ -157,7 +157,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, 441, &targetPath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 442, &targetPath_zv); RETURN_THISW(); } @@ -180,7 +180,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, 442, &targetUri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 443, &targetUri_zv); RETURN_THISW(); } diff --git a/ext/phalcon/auth/access/accesslocator.zep.c b/ext/phalcon/auth/access/accesslocator.zep.c index 7242dfc46d..df3939636c 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, 443, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 444, 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 35b7556f4b..eb2f8f8c30 100644 --- a/ext/phalcon/auth/access/acl.zep.c +++ b/ext/phalcon/auth/access/acl.zep.c @@ -115,16 +115,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, 444, acl); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 445, 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, 445, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 446, &_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, 446, &_1$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 447, &_1$$4); } ZEPHIR_MM_RESTORE(); } @@ -198,17 +198,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, 447, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 448, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_1, "in_array", NULL, 88, &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, 448, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 449, PH_NOISY_CC); _3 = !(ZEPHIR_IS_EMPTY(&_2)); if (_3) { - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 448, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 449, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_5, "in_array", NULL, 88, &actionName_zv, &_4, &__$true); zephir_check_call_status(); _3 = !zephir_is_true(&_5); @@ -239,7 +239,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, 446, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$6, this_ptr, _zephir_prop_2, 447, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&component); ZEPHIR_CONCAT_VVV(&component, &module, &_9$$6, &handler); } @@ -251,7 +251,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, 444, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_3, 445, 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); diff --git a/ext/phalcon/auth/adapter/config/memoryadapterconfig.zep.c b/ext/phalcon/auth/adapter/config/memoryadapterconfig.zep.c index fa9e04a94a..7655b22901 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, 449, &users); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 450, &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 3d6155fa4e..e71819fb64 100644 --- a/ext/phalcon/auth/adapter/config/modeladapterconfig.zep.c +++ b/ext/phalcon/auth/adapter/config/modeladapterconfig.zep.c @@ -93,7 +93,7 @@ PHP_METHOD(Phalcon_Auth_Adapter_Config_ModelAdapterConfig, __construct) ZVAL_STRING(&_1, "idColumn"); ZEPHIR_CALL_CE_STATIC(NULL, phalcon_auth_exceptions_configrequiresnonemptyvalue_ce, "assert", NULL, 0, &idColumn_zv, &_0, &_1); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 450, &idColumn_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 451, &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 46145aed23..e43f244441 100644 --- a/ext/phalcon/auth/adapter/config/streamadapterconfig.zep.c +++ b/ext/phalcon/auth/adapter/config/streamadapterconfig.zep.c @@ -86,7 +86,7 @@ PHP_METHOD(Phalcon_Auth_Adapter_Config_StreamAdapterConfig, __construct) ZVAL_STRING(&_2, " path"); ZEPHIR_CALL_CE_STATIC(NULL, phalcon_auth_exceptions_configrequiresnonemptyvalue_ce, "assert", NULL, 0, &file_zv, &_0, &_1, &_2); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 451, &file_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 452, &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 b75f3dfe7d..04400c6675 100644 --- a/ext/phalcon/auth/adapter/memory.zep.c +++ b/ext/phalcon/auth/adapter/memory.zep.c @@ -198,11 +198,11 @@ PHP_METHOD(Phalcon_Auth_Adapter_Memory, retrieveById) 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, 452, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 453, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_0, id))) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 452, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 453, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2); zephir_array_fetch(&_2, &_1, id, PH_NOISY, "phalcon/Auth/Adapter/Memory.zep", 71); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "hydrate", NULL, 0, &_2); @@ -228,7 +228,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, 453, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 454, 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 2e03a9ad67..5a691cd0f1 100644 --- a/ext/phalcon/auth/adapter/model.zep.c +++ b/ext/phalcon/auth/adapter/model.zep.c @@ -341,7 +341,7 @@ PHP_METHOD(Phalcon_Auth_Adapter_Model, retrieveById) zephir_fetch_params(1, 1, 0, &id); ZEPHIR_INIT_VAR(&_0); zephir_create_array(&_0, 2, 0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 454, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 455, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "getIdColumn", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_3); @@ -457,7 +457,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, 454, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 455, 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 922c237f4d..d276a862d5 100644 --- a/ext/phalcon/auth/adapter/stream.zep.c +++ b/ext/phalcon/auth/adapter/stream.zep.c @@ -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, 455, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 456, 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); diff --git a/ext/phalcon/auth/authuser.zep.c b/ext/phalcon/auth/authuser.zep.c index a52757d38e..e215644f65 100644 --- a/ext/phalcon/auth/authuser.zep.c +++ b/ext/phalcon/auth/authuser.zep.c @@ -103,7 +103,7 @@ PHP_METHOD(Phalcon_Auth_AuthUser, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 456, &data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 457, &data); ZEPHIR_MM_RESTORE(); } @@ -122,7 +122,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, 456, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 457, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&id); zephir_array_fetch_string(&id, &_0, SL("id"), PH_NOISY, "phalcon/Auth/AuthUser.zep", 49); RETURN_CCTOR(&id); @@ -145,7 +145,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, 456, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 457, 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/guard/config/sessionguardconfig.zep.c b/ext/phalcon/auth/guard/config/sessionguardconfig.zep.c index 816bdd3a59..d8777a91d2 100644 --- a/ext/phalcon/auth/guard/config/sessionguardconfig.zep.c +++ b/ext/phalcon/auth/guard/config/sessionguardconfig.zep.c @@ -181,7 +181,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Config_SessionGuardConfig, __construct) ZEPHIR_CALL_METHOD(&_1, this_ptr, "derive", NULL, 417, &_0, &suffix_zv); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 457, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 458, &_1); ZEPHIR_INIT_VAR(&_2); if (Z_TYPE_P(&rememberName_zv) != IS_NULL) { ZEPHIR_CPY_WRT(&_2, &rememberName_zv); @@ -191,7 +191,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Config_SessionGuardConfig, __construct) ZEPHIR_CALL_METHOD(&_2, this_ptr, "derive", NULL, 417, &_0, &suffix_zv); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 458, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 459, &_2); ZEPHIR_INIT_VAR(&_3); if (0 != rememberTtl) { ZEPHIR_INIT_NVAR(&_3); @@ -200,14 +200,14 @@ 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, 459, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 460, &_3); if (rememberSecure) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 460, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 461, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 460, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 461, &__$false); } - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 457, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 458, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 458, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 459, 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); diff --git a/ext/phalcon/auth/guard/config/tokenguardconfig.zep.c b/ext/phalcon/auth/guard/config/tokenguardconfig.zep.c index 0ce3026fda..3aab4bae31 100644 --- a/ext/phalcon/auth/guard/config/tokenguardconfig.zep.c +++ b/ext/phalcon/auth/guard/config/tokenguardconfig.zep.c @@ -93,8 +93,8 @@ PHP_METHOD(Phalcon_Auth_Guard_Config_TokenGuardConfig, __construct) ZVAL_STRING(&_1, "storageKey"); ZEPHIR_CALL_CE_STATIC(NULL, phalcon_auth_exceptions_configrequiresnonemptyvalue_ce, "assert", NULL, 0, &storageKey_zv, &_0, &_1); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 461, &inputKey_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 462, &storageKey_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 462, &inputKey_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 463, &storageKey_zv); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/auth/guard/session.zep.c b/ext/phalcon/auth/guard/session.zep.c index 921d55fbe1..1cf98d11ff 100644 --- a/ext/phalcon/auth/guard/session.zep.c +++ b/ext/phalcon/auth/guard/session.zep.c @@ -130,9 +130,9 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, __construct) } else { ZEPHIR_SEPARATE_PARAM(clock); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 463, request); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 464, cookies); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 465, session); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 464, request); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 465, cookies); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 466, session); if (Z_TYPE_P(config) == IS_NULL) { ZEPHIR_INIT_NVAR(config); object_init_ex(config, phalcon_auth_guard_config_sessionguardconfig_ce); @@ -143,7 +143,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, __construct) 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, 466, clock); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 467, clock); ZEPHIR_CALL_PARENT(NULL, phalcon_auth_guard_session_ce, getThis(), "__construct", NULL, 0, adapter, config); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -304,7 +304,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, 467, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 468, PH_NOISY_CC | PH_READONLY); if (remember) { ZVAL_BOOL(&_2, 1); } else { @@ -381,7 +381,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, 468, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 469, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getName", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -402,7 +402,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, 468, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 469, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getRememberName", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -458,10 +458,10 @@ 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, 465, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 466, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_1, "regenerateId", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 465, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 466, 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); @@ -469,7 +469,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, login) ZEPHIR_CALL_METHOD(NULL, &_2, "set", NULL, 0, &_3, &_4); zephir_check_call_status(); if (remember) { - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 469, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 470, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_6$$3); ZVAL_STRING(&_6$$3, "Phalcon\\Contracts\\Auth\\Adapter\\RememberAdapter"); ZEPHIR_INIT_VAR(&_7$$3); @@ -524,7 +524,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, loginById) remember = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 469, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 470, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&resolved, &_0, "retrieveById", NULL, 0, id); zephir_check_call_status(); if (Z_TYPE_P(&resolved) == IS_NULL) { @@ -603,25 +603,25 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, logout) zephir_check_call_status(); } } - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 464, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 465, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5$$3, this_ptr, "getRememberName", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_4$$3, &_3$$3, "has", NULL, 0, &_5$$3); zephir_check_call_status(); if (zephir_is_true(&_4$$3)) { - zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_0, 464, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_0, 465, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_7$$6, this_ptr, "getRememberName", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_6$$6, "delete", NULL, 0, &_7$$6); zephir_check_call_status(); } } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 465, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 466, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_8, this_ptr, "getName", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_2, "remove", NULL, 0, &_8); zephir_check_call_status(); - zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 465, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 466, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_9, "regenerateId", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_10); @@ -632,7 +632,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, 470, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 471, &__$null); ZEPHIR_MM_RESTORE(); } @@ -683,7 +683,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, 467, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 468, 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); @@ -755,7 +755,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, 470, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 471, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&user, &_2$$4); RETURN_CCTOR(&user); } @@ -798,11 +798,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, 470, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 471, 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, 465, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 466, 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); @@ -812,14 +812,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, 469, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_2, 470, 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, 470, &_5$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 471, &_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, 470, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 471, PH_NOISY_CC | PH_READONLY); _7 = Z_TYPE_P(&_6) == IS_NULL; if (_7) { _7 = Z_TYPE_P(&recaller) != IS_NULL; @@ -828,11 +828,11 @@ 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, 470, &fromRecaller); - zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_1, 465, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 471, &fromRecaller); + zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_1, 466, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_8$$6, "regenerateId", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_9$$6, this_ptr, _zephir_prop_1, 465, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$6, this_ptr, _zephir_prop_1, 466, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_10$$6, this_ptr, "getName", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_11$$6, &fromRecaller, "getAuthIdentifier", NULL, 0); @@ -882,10 +882,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, 469, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 470, 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, 467, &resolved); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 468, &resolved); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "hasValidCredentials", NULL, 0, &resolved, &credentials); zephir_check_call_status(); RETURN_MM(); @@ -972,7 +972,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, 463, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 464, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&basic, &_0, "getBasicAuth", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(&basic) == IS_NULL) { @@ -1009,7 +1009,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, 469, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 470, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&adapter, &_0); ZEPHIR_RETURN_CALL_METHOD(&adapter, "createRememberToken", NULL, 0, user); zephir_check_call_status(); @@ -1037,7 +1037,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, 464, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 465, 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); @@ -1045,7 +1045,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, 464, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 465, 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); @@ -1125,7 +1125,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, 463, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 464, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "getUserAgent", NULL, 0); zephir_check_call_status(); zephir_cast_to_string(&_2, &_1); @@ -1149,20 +1149,20 @@ 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, 464, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 465, 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, 466, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 467, 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, 468, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_3, 469, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_11, &_10, "getRememberTtl", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_12); zephir_add_function(&_12, &_9, &_11); - zephir_read_property_cached(&_13, this_ptr, _zephir_prop_3, 468, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13, this_ptr, _zephir_prop_3, 469, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_9, &_13, "getRememberSecure", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_14); @@ -1214,7 +1214,7 @@ 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, 469, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 470, PH_NOISY_CC); if (!(zephir_instance_of_ev(&_0, phalcon_contracts_auth_adapter_rememberadapter_ce))) { RETURN_MM_NULL(); } @@ -1223,19 +1223,19 @@ PHP_METHOD(Phalcon_Auth_Guard_Session, userFromRecaller) if (Z_TYPE_P(&id) == IS_NULL) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 469, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 470, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, recaller, "getToken", NULL, 421); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 463, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 464, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_4, &_3, "getUserAgent", NULL, 0); zephir_check_call_status(); zephir_cast_to_string(&_5, &_4); ZEPHIR_CALL_METHOD(&resolved, &_1, "retrieveByToken", NULL, 0, &id, &_2, &_5); zephir_check_call_status(); if (Z_TYPE_P(&resolved) != IS_NULL) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 471, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 472, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 471, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 472, &__$false); } RETURN_CCTOR(&resolved); } diff --git a/ext/phalcon/auth/guard/token.zep.c b/ext/phalcon/auth/guard/token.zep.c index 84673f61ea..e2fc74e689 100644 --- a/ext/phalcon/auth/guard/token.zep.c +++ b/ext/phalcon/auth/guard/token.zep.c @@ -72,7 +72,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, 472, request); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 473, request); ZEPHIR_CALL_PARENT(NULL, phalcon_auth_guard_token_ce, getThis(), "__construct", NULL, 0, adapter, config); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -183,8 +183,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, 472, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 473, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 473, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 474, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "getInputKey", NULL, 0); zephir_check_call_status(); ZVAL_NULL(&_3); @@ -198,7 +198,7 @@ PHP_METHOD(Phalcon_Auth_Guard_Token, getTokenForRequest) if (_5) { RETURN_CCTOR(&token); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 472, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 473, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_7); ZVAL_STRING(&_7, "Authorization"); ZEPHIR_CALL_METHOD(&_6, &_3, "getHeader", NULL, 0, &_7); @@ -242,8 +242,8 @@ 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, 472, request); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 474, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 473, request); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 475, &__$null); RETURN_THISW(); } @@ -277,7 +277,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, 474, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 475, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { RETURN_MM_MEMBER(getThis(), "user"); } @@ -286,17 +286,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, 475, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 476, 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, 473, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 474, 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, 474, &found); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 475, &found); } RETURN_MM_MEMBER(getThis(), "user"); } @@ -343,7 +343,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, 473, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 474, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&inputKey, &_0, "getInputKey", NULL, 0); zephir_check_call_status(); if (!(zephir_array_isset_value(&credentials, &inputKey))) { @@ -351,10 +351,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", 146); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 475, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 476, 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, 473, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 474, 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 d1e9f2ab53..a712a46af6 100644 --- a/ext/phalcon/auth/guard/userremember.zep.c +++ b/ext/phalcon/auth/guard/userremember.zep.c @@ -171,7 +171,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, 476, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 477, &_5); ZEPHIR_INIT_VAR(&_7); if (zephir_array_isset_value_string(&data, SL("token"))) { zephir_memory_observe(&_8); @@ -182,7 +182,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, 477, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 478, &_7); ZEPHIR_INIT_VAR(&_10); if (zephir_array_isset_value_string(&data, SL("user_agent"))) { zephir_memory_observe(&_11); @@ -193,7 +193,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, 478, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 479, &_10); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/auth/manager.zep.c b/ext/phalcon/auth/manager.zep.c index ce35fc7541..2918aabea2 100644 --- a/ext/phalcon/auth/manager.zep.c +++ b/ext/phalcon/auth/manager.zep.c @@ -90,7 +90,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, 479, accessFactory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 480, accessFactory); } /** @@ -130,7 +130,7 @@ 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, 479, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 480, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "has", NULL, 0, &accessName_zv); zephir_check_call_status(); if (!zephir_is_true(&_1)) { @@ -142,16 +142,16 @@ PHP_METHOD(Phalcon_Auth_Manager, access) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 479, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 480, 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, 480, &_4); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 480, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 481, &_4); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 481, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_6); array_init(&_6); ZEPHIR_CALL_METHOD(NULL, &_5, "setExceptActions", NULL, 0, &_6); zephir_check_call_status(); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 480, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 481, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_8); array_init(&_8); ZEPHIR_CALL_METHOD(NULL, &_7, "setOnlyActions", NULL, 0, &_8); @@ -203,7 +203,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, 479, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 480, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_3$$3, "register", NULL, 0, &name, &className); zephir_check_call_status(); } ZEND_HASH_FOREACH_END(); @@ -227,7 +227,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, 479, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_0, 480, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_6$$4, "register", NULL, 0, &name, &className); zephir_check_call_status(); } @@ -268,7 +268,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, 481, guard); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 482, guard); } RETURN_THISW(); } @@ -390,7 +390,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, 479, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 480, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getAll", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -452,7 +452,7 @@ 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, 481, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 482, 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); @@ -464,7 +464,7 @@ PHP_METHOD(Phalcon_Auth_Manager, guard) } RETURN_MM_MEMBER(getThis(), "defaultGuard"); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 482, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 483, 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); @@ -474,7 +474,7 @@ PHP_METHOD(Phalcon_Auth_Manager, guard) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 482, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 483, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_5); zephir_array_fetch(&_5, &_4, &name_zv, PH_NOISY, "phalcon/Auth/Manager.zep", 171); RETURN_CCTOR(&_5); @@ -559,7 +559,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, 480, access); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 481, access); RETURN_THISW(); } @@ -578,7 +578,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, 481, guard); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 482, guard); RETURN_THISW(); } @@ -652,7 +652,7 @@ 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, 480, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 481, 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); diff --git a/ext/phalcon/auth/managerfactory.zep.c b/ext/phalcon/auth/managerfactory.zep.c index 0b6d32566f..a51dc98080 100644 --- a/ext/phalcon/auth/managerfactory.zep.c +++ b/ext/phalcon/auth/managerfactory.zep.c @@ -176,8 +176,8 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, __construct) accessLocator = &accessLocator_sub; accessLocator = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 483, container); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 484, hasher); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 484, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 485, hasher); ZEPHIR_INIT_VAR(&_0); if (Z_TYPE_P(adapterLocator) != IS_NULL) { ZEPHIR_CPY_WRT(&_0, adapterLocator); @@ -187,7 +187,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, __construct) ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 436, container); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 485, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 486, &_0); ZEPHIR_INIT_VAR(&_1); if (Z_TYPE_P(guardLocator) != IS_NULL) { ZEPHIR_CPY_WRT(&_1, guardLocator); @@ -197,7 +197,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, __construct) ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 436, container); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 486, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 487, &_1); ZEPHIR_INIT_VAR(&_2); if (Z_TYPE_P(accessLocator) != IS_NULL) { ZEPHIR_CPY_WRT(&_2, accessLocator); @@ -207,7 +207,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, __construct) ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 436, container); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 487, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 488, &_2); ZEPHIR_MM_RESTORE(); } @@ -287,7 +287,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, load) ZEPHIR_CPY_WRT(config, &_0); ZEPHIR_INIT_VAR(&manager); object_init_ex(&manager, phalcon_auth_manager_ce); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 487, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 488, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &manager, "__construct", NULL, 437, &_1); zephir_check_call_status(); if (zephir_array_isset_value_string(config, SL("guards"))) { @@ -316,7 +316,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, load) } ZEPHIR_INIT_NVAR(&gconf); ZVAL_COPY(&gconf, _4); - zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_1, 485, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_1, 486, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_10$$3); ZEPHIR_CONCAT_SVS(&_10$$3, "guard '", &name, "'"); ZEPHIR_INIT_NVAR(&_11$$3); @@ -325,7 +325,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, load) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&adapter, this_ptr, "buildAdapter", &_12, 0, &_7$$3, &_8$$3); zephir_check_call_status(); - zephir_read_property_cached(&_13$$3, this_ptr, _zephir_prop_2, 486, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$3, this_ptr, _zephir_prop_2, 487, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_16$$3); ZEPHIR_CONCAT_SVS(&_16$$3, "guard '", &name, "'"); ZEPHIR_INIT_NVAR(&_11$$3); @@ -375,7 +375,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, load) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&gconf, _2, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_25$$4, this_ptr, _zephir_prop_1, 485, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$4, this_ptr, _zephir_prop_1, 486, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_27$$4); ZEPHIR_CONCAT_SVS(&_27$$4, "guard '", &name, "'"); ZEPHIR_INIT_NVAR(&_28$$4); @@ -384,7 +384,7 @@ PHP_METHOD(Phalcon_Auth_ManagerFactory, load) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&adapter, this_ptr, "buildAdapter", &_12, 0, &_25$$4, &_26$$4); zephir_check_call_status(); - zephir_read_property_cached(&_29$$4, this_ptr, _zephir_prop_2, 486, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$4, this_ptr, _zephir_prop_2, 487, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_31$$4); ZEPHIR_CONCAT_SVS(&_31$$4, "guard '", &name, "'"); ZEPHIR_INIT_NVAR(&_28$$4); @@ -487,7 +487,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, 484, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 485, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_5); if (zephir_array_isset_value_string(&cfg, SL("options"))) { ZEPHIR_OBS_NVAR(&_5); @@ -557,7 +557,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, 483, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 484, 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 03a2afdc47..fc071092f0 100644 --- a/ext/phalcon/auth/micro/authmicrolistener.zep.c +++ b/ext/phalcon/auth/micro/authmicrolistener.zep.c @@ -87,7 +87,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, 488, &componentName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 489, &componentName_zv); ZEPHIR_MM_RESTORE(); } @@ -146,7 +146,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, 488, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 489, 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 324729842b..c05f7b174c 100644 --- a/ext/phalcon/autoload/loader.zep.c +++ b/ext/phalcon/autoload/loader.zep.c @@ -179,9 +179,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, 489, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 490, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 489, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 490, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -325,7 +325,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, addNamespace) ZEPHIR_CALL_METHOD(&_2, this_ptr, "checkDirectories", NULL, 442, directories, &dirSeparator, &name_zv); zephir_check_call_status(); ZEPHIR_CPY_WRT(directories, &_2); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 490, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_3, &nsName))) { ZEPHIR_INIT_VAR(&_4$$3); array_init(&_4$$3); @@ -334,12 +334,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, 490, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&source); zephir_array_fetch(&source, &_5, &nsName, PH_NOISY, "phalcon/Autoload/Loader.zep", 139); } if (prepend) { - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 490, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&target); zephir_array_fetch(&target, &_6, &nsName, PH_NOISY, "phalcon/Autoload/Loader.zep", 140); } else { @@ -405,19 +405,19 @@ 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, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 492, 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, 492, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 493, &_1$$3); } result = 1; - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 492, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_3); ZVAL_LONG(&_3, 1); ZEPHIR_INIT_VAR(&_4); zephir_add_function(&_4, &_2, &_3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 491, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 492, &_4); ZEPHIR_INIT_VAR(&_5); ZEPHIR_CONCAT_SV(&_5, "Loading: ", &className_zv); ZEPHIR_CALL_METHOD(NULL, this_ptr, "addDebug", NULL, 444, &_5); @@ -440,7 +440,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoload) ZEPHIR_CONCAT_SV(&_10$$5, "Namespace: 404: ", &className_zv); ZEPHIR_CALL_METHOD(NULL, this_ptr, "addDebug", NULL, 444, &_10$$5); zephir_check_call_status(); - zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_2, 493, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_2, 494, PH_NOISY_CC | PH_READONLY); ZVAL_BOOL(&_13$$5, 1); ZEPHIR_CALL_METHOD(&_11$$5, this_ptr, "autoloadCheckDirectories", NULL, 447, &_12$$5, &className_zv, &_13$$5); zephir_check_call_status(); @@ -457,12 +457,12 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoload) } } } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 492, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_3); ZVAL_LONG(&_3, 1); ZEPHIR_INIT_VAR(&_16); zephir_sub_function(&_16, &_2, &_3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 491, &_16); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 492, &_16); RETURN_MM_BOOL(result); } @@ -585,7 +585,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, 494, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 495, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&files, &_0); if (Z_TYPE_P(&files) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); @@ -670,7 +670,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, register) prepend = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 495, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 496, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "loadFiles", NULL, 0); zephir_check_call_status(); @@ -682,9 +682,9 @@ PHP_METHOD(Phalcon_Autoload_Loader, register) ZEPHIR_CALL_METHOD(NULL, this_ptr, "registerAutoload", NULL, 448, &_1$$3); zephir_check_call_status(); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 495, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 496, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 495, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 496, &__$false); } } RETURN_THIS(); @@ -733,7 +733,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, 496, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 497, &_0$$3); } zephir_is_iterable(&classes, 0, "phalcon/Autoload/Loader.zep", 336); if (Z_TYPE_P(&classes) == IS_ARRAY) { @@ -867,7 +867,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, 497, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 498, &_0$$3); ZEPHIR_INIT_VAR(&_1$$3); ZVAL_STRING(&_1$$3, "php"); ZEPHIR_INIT_VAR(&_2$$3); @@ -957,12 +957,12 @@ PHP_METHOD(Phalcon_Autoload_Loader, setFileCheckingCallback) method = &__$null; } if (1 == zephir_is_callable(method)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 498, method); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 499, 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_7__closure_ce, SL("__invoke")); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 498, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 499, &_0$$4); } else { ZEPHIR_INIT_VAR(&_1$$5); object_init_ex(&_1$$5, phalcon_autoload_exceptions_loadermethodnotcallable_ce); @@ -1064,7 +1064,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, 490, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 491, &_0$$3); } zephir_is_iterable(&namespaces, 0, "phalcon/Autoload/Loader.zep", 443); if (Z_TYPE_P(&namespaces) == IS_ARRAY) { @@ -1133,7 +1133,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, 495, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 496, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { ZEPHIR_INIT_VAR(&_1$$3); zephir_create_array(&_1$$3, 2, 0); @@ -1144,9 +1144,9 @@ PHP_METHOD(Phalcon_Autoload_Loader, unregister) ZEPHIR_CALL_FUNCTION(NULL, "spl_autoload_unregister", NULL, 451, &_1$$3); zephir_check_call_status(); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 495, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 496, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 495, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 496, &__$false); } } RETURN_THIS(); @@ -1188,11 +1188,11 @@ 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, 498, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 499, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_1, "call_user_func", NULL, 81, &_0, &file_zv); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&_1)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 499, &file_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 500, &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); @@ -1233,7 +1233,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, 489, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 490, 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, 496, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 497, 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, 496, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 497, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&filePath); zephir_array_fetch(&filePath, &_1$$3, &className_zv, PH_NOISY, "phalcon/Autoload/Loader.zep", 543); ZEPHIR_INIT_VAR(&_2$$3); @@ -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, 497, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 498, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extensions, &_0); zephir_is_iterable(&directories, 0, "phalcon/Autoload/Loader.zep", 602); if (Z_TYPE_P(&directories) == IS_ARRAY) { @@ -1488,7 +1488,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckDirectories) ZVAL_COPY(&extension, _5$$3); ZEPHIR_INIT_NVAR(&filePath); ZEPHIR_CONCAT_VVSV(&filePath, &fixedDirectory, &localClassName, ".", &extension); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 500, &filePath); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 501, &filePath); ZEPHIR_INIT_NVAR(&_6$$4); ZVAL_STRING(&_6$$4, "loader:beforeCheckPath"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", &_7, 0, &_6$$4, &filePath); @@ -1525,7 +1525,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, 500, &filePath); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 501, &filePath); ZEPHIR_INIT_NVAR(&_14$$7); ZVAL_STRING(&_14$$7, "loader:beforeCheckPath"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", &_7, 0, &_14$$7, &filePath); @@ -1582,7 +1582,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckDirectories) ZVAL_COPY(&extension, _22$$10); ZEPHIR_INIT_NVAR(&filePath); ZEPHIR_CONCAT_VVSV(&filePath, &fixedDirectory, &localClassName, ".", &extension); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 500, &filePath); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 501, &filePath); ZEPHIR_INIT_NVAR(&_23$$11); ZVAL_STRING(&_23$$11, "loader:beforeCheckPath"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", &_7, 0, &_23$$11, &filePath); @@ -1619,7 +1619,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, 500, &filePath); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 501, &filePath); ZEPHIR_INIT_NVAR(&_28$$14); ZVAL_STRING(&_28$$14, "loader:beforeCheckPath"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", &_7, 0, &_28$$14, &filePath); @@ -1693,7 +1693,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, 490, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 491, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&namespaces, &_0); if (Z_TYPE_P(&namespaces) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); @@ -1723,7 +1723,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckNamespaces) ZEPHIR_CALL_METHOD(&_7$$3, this_ptr, "autoloadCheckDirectories", &_8, 447, &directories, &fileName); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_7$$3)) { - zephir_read_property_cached(&_9$$5, this_ptr, _zephir_prop_1, 500, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$5, this_ptr, _zephir_prop_1, 501, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_10$$5); ZEPHIR_CONCAT_SVSV(&_10$$5, "Namespace: ", &prefix, " - ", &_9$$5); ZEPHIR_CALL_METHOD(NULL, this_ptr, "addDebug", &_11, 444, &_10$$5); @@ -1760,7 +1760,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, autoloadCheckNamespaces) ZEPHIR_CALL_METHOD(&_15$$6, this_ptr, "autoloadCheckDirectories", &_8, 447, &directories, &fileName); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_15$$6)) { - zephir_read_property_cached(&_16$$8, this_ptr, _zephir_prop_1, 500, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$8, this_ptr, _zephir_prop_1, 501, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_17$$8); ZEPHIR_CONCAT_SVSV(&_17$$8, "Namespace: ", &prefix, " - ", &_16$$8); ZEPHIR_CALL_METHOD(NULL, this_ptr, "addDebug", &_11, 444, &_17$$8); @@ -1977,19 +1977,19 @@ PHP_METHOD(Phalcon_Autoload_Loader, setEventsManager) _2 = ZEPHIR_IS_TRUE_IDENTICAL(&_1); if (_2) { zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 501, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 502, PH_NOISY_CC); _2 = Z_TYPE_P(&_3) != IS_NULL; } if (_2) { zephir_memory_observe(&_4$$3); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 501, PH_NOISY_CC); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 502, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_5$$3); ZVAL_STRING(&_5$$3, "eventsManager"); ZVAL_BOOL(&_6$$3, 1); ZEPHIR_CALL_METHOD(NULL, &_4$$3, "set", NULL, 0, &_5$$3, eventsManager, &_6$$3); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 502, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 503, eventsManager); ZEPHIR_MM_RESTORE(); } @@ -2055,16 +2055,16 @@ PHP_METHOD(Phalcon_Autoload_Loader, fireManagerEvent) stopOnFalse = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 502, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 503, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { _1$$3 = stopOnFalse; if (_1$$3) { zephir_memory_observe(&_2$$3); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 502, PH_NOISY_CC); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 503, PH_NOISY_CC); _1$$3 = zephir_instance_of_ev(&_2$$3, phalcon_events_manager_ce); } if (_1$$3) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 502, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 503, PH_NOISY_CC | PH_READONLY); if (cancellable) { ZVAL_BOOL(&_4$$4, 1); } else { @@ -2075,7 +2075,7 @@ PHP_METHOD(Phalcon_Autoload_Loader, fireManagerEvent) zephir_check_call_status(); RETURN_MM(); } - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 502, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 503, PH_NOISY_CC | PH_READONLY); if (cancellable) { ZVAL_BOOL(&_7$$3, 1); } else { diff --git a/ext/phalcon/cache/abstractcache.zep.c b/ext/phalcon/cache/abstractcache.zep.c index 91f3d21b9c..93fbbe6e0a 100644 --- a/ext/phalcon/cache/abstractcache.zep.c +++ b/ext/phalcon/cache/abstractcache.zep.c @@ -82,7 +82,7 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, __construct) Z_PARAM_OBJECT_OF_CLASS(adapter, phalcon_cache_adapter_adapterinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &adapter); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 272, adapter); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 273, adapter); } /** @@ -248,7 +248,7 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doClear) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 272, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "clear", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -261,17 +261,24 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doDelete) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval key_zv, result, _0, _1; + zval key_zv, result, _0, _2, _3, _1$$3, _4$$4; zend_string *key = NULL; zval *this_ptr = getThis(); ZVAL_UNDEF(&key_zv); ZVAL_UNDEF(&result); ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); + ZVAL_UNDEF(&_3); + ZVAL_UNDEF(&_1$$3); + ZVAL_UNDEF(&_4$$4); 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("adapter", 7, 1); + _zephir_prop_0 = zend_string_init("eventsManager", 13, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("adapter", 7, 1); } ZEND_PARSE_PARAMETERS_START(1, 1) @@ -283,17 +290,23 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doDelete) ZVAL_STR_COPY(&key_zv, key); ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkKey", NULL, 0, &key_zv); zephir_check_call_status(); - ZEPHIR_INIT_VAR(&_0); - ZVAL_STRING(&_0, "cache:beforeDelete"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_0, &key_zv); - zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 272, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(&result, &_1, "delete", NULL, 0, &key_zv); - zephir_check_call_status(); - ZEPHIR_INIT_NVAR(&_0); - ZVAL_STRING(&_0, "cache:afterDelete"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_0, &key_zv); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_0) != IS_NULL) { + ZEPHIR_INIT_VAR(&_1$$3); + ZVAL_STRING(&_1$$3, "cache:beforeDelete"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_1$$3, &key_zv); + zephir_check_call_status(); + } + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 273, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(&result, &_2, "delete", NULL, 0, &key_zv); zephir_check_call_status(); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_3) != IS_NULL) { + ZEPHIR_INIT_VAR(&_4$$4); + ZVAL_STRING(&_4$$4, "cache:afterDelete"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_4$$4, &key_zv); + zephir_check_call_status(); + } RETURN_CCTOR(&result); } @@ -304,11 +317,11 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doDelete) */ PHP_METHOD(Phalcon_Cache_AbstractCache, doDeleteMultiple) { - zend_bool _5; + zend_bool _7; zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; - zephir_fcall_cache_entry *_3 = NULL; + zephir_fcall_cache_entry *_5 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *keys, keys_sub, key, keysArray, result, _0, *_1, *_2, _4, _6, _7; + zval *keys, keys_sub, key, keysArray, result, _0, *_2, _3, *_4, _6, _8, _9, _1$$3, _10$$6; zval *this_ptr = getThis(); ZVAL_UNDEF(&keys_sub); @@ -316,12 +329,19 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doDeleteMultiple) ZVAL_UNDEF(&keysArray); ZVAL_UNDEF(&result); ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_4); + ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_6); - ZVAL_UNDEF(&_7); + ZVAL_UNDEF(&_8); + ZVAL_UNDEF(&_9); + ZVAL_UNDEF(&_1$$3); + ZVAL_UNDEF(&_10$$6); 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("adapter", 7, 1); + _zephir_prop_0 = zend_string_init("eventsManager", 13, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("adapter", 7, 1); } ZEND_PARSE_PARAMETERS_START(1, 1) @@ -332,60 +352,66 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doDeleteMultiple) zephir_fetch_params(1, 1, 0, &keys); ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkKeys", NULL, 0, keys); zephir_check_call_status(); - ZEPHIR_INIT_VAR(&_0); - ZVAL_STRING(&_0, "cache:beforeDeleteMultiple"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_0, keys); - zephir_check_call_status(); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_0) != IS_NULL) { + ZEPHIR_INIT_VAR(&_1$$3); + ZVAL_STRING(&_1$$3, "cache:beforeDeleteMultiple"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_1$$3, keys); + zephir_check_call_status(); + } ZEPHIR_INIT_VAR(&keysArray); array_init(&keysArray); if (Z_TYPE_P(keys) == IS_STRING) { - ZEPHIR_INIT_NVAR(&_0); - zephir_string_to_char_array(&_0, keys); - _1 = &_0; + ZEPHIR_INIT_VAR(&_3); + zephir_string_to_char_array(&_3, keys); + _2 = &_3; } else { - _1 = keys; + _2 = keys; } - zephir_is_iterable(_1, 0, "phalcon/Cache/AbstractCache.zep", 151); - if (Z_TYPE_P(_1) == IS_ARRAY) { - ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1), _2) + zephir_is_iterable(_2, 0, "phalcon/Cache/AbstractCache.zep", 161); + if (Z_TYPE_P(_2) == IS_ARRAY) { + ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4) { ZEPHIR_INIT_NVAR(&key); - ZVAL_COPY(&key, _2); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkKey", &_3, 0, &key); + ZVAL_COPY(&key, _4); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkKey", &_5, 0, &key); zephir_check_call_status(); - zephir_array_append(&keysArray, &key, PH_SEPARATE, "phalcon/Cache/AbstractCache.zep", 148); + zephir_array_append(&keysArray, &key, PH_SEPARATE, "phalcon/Cache/AbstractCache.zep", 158); } ZEND_HASH_FOREACH_END(); } else { - ZEPHIR_CALL_METHOD(NULL, _1, "rewind", NULL, 0); + ZEPHIR_CALL_METHOD(NULL, _2, "rewind", NULL, 0); zephir_check_call_status(); - _5 = 1; + _7 = 1; while (1) { - if (_5) { - _5 = 0; + if (_7) { + _7 = 0; } else { - ZEPHIR_CALL_METHOD(NULL, _1, "next", NULL, 0); + ZEPHIR_CALL_METHOD(NULL, _2, "next", NULL, 0); zephir_check_call_status(); } - ZEPHIR_CALL_METHOD(&_4, _1, "valid", NULL, 0); + ZEPHIR_CALL_METHOD(&_6, _2, "valid", NULL, 0); zephir_check_call_status(); - if (!zend_is_true(&_4)) { + if (!zend_is_true(&_6)) { break; } - ZEPHIR_CALL_METHOD(&key, _1, "current", NULL, 0); + ZEPHIR_CALL_METHOD(&key, _2, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkKey", &_3, 0, &key); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkKey", &_5, 0, &key); zephir_check_call_status(); - zephir_array_append(&keysArray, &key, PH_SEPARATE, "phalcon/Cache/AbstractCache.zep", 148); + zephir_array_append(&keysArray, &key, PH_SEPARATE, "phalcon/Cache/AbstractCache.zep", 158); } } ZEPHIR_INIT_NVAR(&key); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 272, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(&result, &_6, "deleteMultiple", NULL, 0, &keysArray); - zephir_check_call_status(); - ZEPHIR_INIT_VAR(&_7); - ZVAL_STRING(&_7, "cache:afterDeleteMultiple"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_7, keys); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 273, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(&result, &_8, "deleteMultiple", NULL, 0, &keysArray); zephir_check_call_status(); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_9) != IS_NULL) { + ZEPHIR_INIT_VAR(&_10$$6); + ZVAL_STRING(&_10$$6, "cache:afterDeleteMultiple"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_10$$6, keys); + zephir_check_call_status(); + } RETURN_CCTOR(&result); } @@ -396,7 +422,7 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doGet) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval key_zv, *defaultValue = NULL, defaultValue_sub, __$null, result, _0, _1; + zval key_zv, *defaultValue = NULL, defaultValue_sub, __$null, result, _0, _2, _3, _1$$3, _4$$4; zend_string *key = NULL; zval *this_ptr = getThis(); @@ -405,10 +431,17 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doGet) ZVAL_NULL(&__$null); ZVAL_UNDEF(&result); ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); + ZVAL_UNDEF(&_3); + ZVAL_UNDEF(&_1$$3); + ZVAL_UNDEF(&_4$$4); 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("adapter", 7, 1); + _zephir_prop_0 = zend_string_init("eventsManager", 13, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("adapter", 7, 1); } bool is_null_true = 1; @@ -430,17 +463,23 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doGet) } ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkKey", NULL, 0, &key_zv); zephir_check_call_status(); - ZEPHIR_INIT_VAR(&_0); - ZVAL_STRING(&_0, "cache:beforeGet"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_0, &key_zv); - zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 272, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(&result, &_1, "get", NULL, 0, &key_zv, defaultValue); - zephir_check_call_status(); - ZEPHIR_INIT_NVAR(&_0); - ZVAL_STRING(&_0, "cache:afterGet"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_0, &key_zv); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_0) != IS_NULL) { + ZEPHIR_INIT_VAR(&_1$$3); + ZVAL_STRING(&_1$$3, "cache:beforeGet"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_1$$3, &key_zv); + zephir_check_call_status(); + } + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 273, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(&result, &_2, "get", NULL, 0, &key_zv, defaultValue); zephir_check_call_status(); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_3) != IS_NULL) { + ZEPHIR_INIT_VAR(&_4$$4); + ZVAL_STRING(&_4$$4, "cache:afterGet"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_4$$4, &key_zv); + zephir_check_call_status(); + } RETURN_CCTOR(&result); } @@ -453,11 +492,11 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doGet) */ PHP_METHOD(Phalcon_Cache_AbstractCache, doGetMultiple) { - zend_bool _6$$3, _16$$6; + zend_bool _7$$4, _17$$7; zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; - zephir_fcall_cache_entry *_4 = NULL, *_14 = NULL; + zephir_fcall_cache_entry *_5 = NULL, *_15 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *keys, keys_sub, *defaultValue = NULL, defaultValue_sub, __$null, adapterClass, connection, element, keysArray, results, serializer, _0, *_1$$3, _2$$3, *_3$$3, _5$$3, _7$$3, _8$$3, _9$$3, *_10$$6, _11$$6, *_12$$6, _15$$6, _13$$7, _17$$8; + zval *keys, keys_sub, *defaultValue = NULL, defaultValue_sub, __$null, adapterClass, connection, element, keysArray, results, serializer, _0, _19, _1$$3, *_2$$4, _3$$4, *_4$$4, _6$$4, _8$$4, _9$$4, _10$$4, *_11$$7, _12$$7, *_13$$7, _16$$7, _14$$8, _18$$9, _20$$10; zval *this_ptr = getThis(); ZVAL_UNDEF(&keys_sub); @@ -470,18 +509,25 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doGetMultiple) ZVAL_UNDEF(&results); ZVAL_UNDEF(&serializer); ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_2$$3); - ZVAL_UNDEF(&_5$$3); - ZVAL_UNDEF(&_7$$3); - ZVAL_UNDEF(&_8$$3); - ZVAL_UNDEF(&_9$$3); - ZVAL_UNDEF(&_11$$6); - ZVAL_UNDEF(&_15$$6); - ZVAL_UNDEF(&_13$$7); - ZVAL_UNDEF(&_17$$8); + ZVAL_UNDEF(&_19); + ZVAL_UNDEF(&_1$$3); + ZVAL_UNDEF(&_3$$4); + ZVAL_UNDEF(&_6$$4); + ZVAL_UNDEF(&_8$$4); + ZVAL_UNDEF(&_9$$4); + ZVAL_UNDEF(&_10$$4); + ZVAL_UNDEF(&_12$$7); + ZVAL_UNDEF(&_16$$7); + ZVAL_UNDEF(&_14$$8); + ZVAL_UNDEF(&_18$$9); + ZVAL_UNDEF(&_20$$10); 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("adapter", 7, 1); + _zephir_prop_0 = zend_string_init("eventsManager", 13, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("adapter", 7, 1); } bool is_null_true = 1; @@ -499,55 +545,58 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doGetMultiple) } ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkKeys", NULL, 0, keys); zephir_check_call_status(); - ZEPHIR_INIT_VAR(&_0); - ZVAL_STRING(&_0, "cache:beforeGetMultiple"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_0, keys); - zephir_check_call_status(); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_0) != IS_NULL) { + ZEPHIR_INIT_VAR(&_1$$3); + ZVAL_STRING(&_1$$3, "cache:beforeGetMultiple"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_1$$3, keys); + zephir_check_call_status(); + } ZEPHIR_INIT_VAR(&results); array_init(&results); zephir_memory_observe(&adapterClass); - zephir_read_property_cached(&adapterClass, this_ptr, _zephir_prop_0, 272, PH_NOISY_CC); + zephir_read_property_cached(&adapterClass, this_ptr, _zephir_prop_1, 273, PH_NOISY_CC); if (zephir_instance_of_ev(&adapterClass, phalcon_cache_adapter_redis_ce)) { ZEPHIR_INIT_VAR(&keysArray); array_init(&keysArray); if (Z_TYPE_P(keys) == IS_STRING) { - ZEPHIR_INIT_VAR(&_2$$3); - zephir_string_to_char_array(&_2$$3, keys); - _1$$3 = &_2$$3; + ZEPHIR_INIT_VAR(&_3$$4); + zephir_string_to_char_array(&_3$$4, keys); + _2$$4 = &_3$$4; } else { - _1$$3 = keys; + _2$$4 = keys; } - zephir_is_iterable(_1$$3, 0, "phalcon/Cache/AbstractCache.zep", 211); - if (Z_TYPE_P(_1$$3) == IS_ARRAY) { - ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_1$$3), _3$$3) + zephir_is_iterable(_2$$4, 0, "phalcon/Cache/AbstractCache.zep", 229); + if (Z_TYPE_P(_2$$4) == IS_ARRAY) { + ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2$$4), _4$$4) { ZEPHIR_INIT_NVAR(&element); - ZVAL_COPY(&element, _3$$3); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkKey", &_4, 0, &element); + ZVAL_COPY(&element, _4$$4); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkKey", &_5, 0, &element); zephir_check_call_status(); - zephir_array_append(&keysArray, &element, PH_SEPARATE, "phalcon/Cache/AbstractCache.zep", 208); + zephir_array_append(&keysArray, &element, PH_SEPARATE, "phalcon/Cache/AbstractCache.zep", 226); } ZEND_HASH_FOREACH_END(); } else { - ZEPHIR_CALL_METHOD(NULL, _1$$3, "rewind", NULL, 0); + ZEPHIR_CALL_METHOD(NULL, _2$$4, "rewind", NULL, 0); zephir_check_call_status(); - _6$$3 = 1; + _7$$4 = 1; while (1) { - if (_6$$3) { - _6$$3 = 0; + if (_7$$4) { + _7$$4 = 0; } else { - ZEPHIR_CALL_METHOD(NULL, _1$$3, "next", NULL, 0); + ZEPHIR_CALL_METHOD(NULL, _2$$4, "next", NULL, 0); zephir_check_call_status(); } - ZEPHIR_CALL_METHOD(&_5$$3, _1$$3, "valid", NULL, 0); + ZEPHIR_CALL_METHOD(&_6$$4, _2$$4, "valid", NULL, 0); zephir_check_call_status(); - if (!zend_is_true(&_5$$3)) { + if (!zend_is_true(&_6$$4)) { break; } - ZEPHIR_CALL_METHOD(&element, _1$$3, "current", NULL, 0); + ZEPHIR_CALL_METHOD(&element, _2$$4, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkKey", &_4, 0, &element); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkKey", &_5, 0, &element); zephir_check_call_status(); - zephir_array_append(&keysArray, &element, PH_SEPARATE, "phalcon/Cache/AbstractCache.zep", 208); + zephir_array_append(&keysArray, &element, PH_SEPARATE, "phalcon/Cache/AbstractCache.zep", 226); } } ZEPHIR_INIT_NVAR(&element); @@ -557,66 +606,69 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doGetMultiple) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&results, &connection, "mget", NULL, 0, &keysArray); zephir_check_call_status(); - ZEPHIR_INIT_VAR(&_7$$3); - object_init_ex(&_7$$3, phalcon_0__closure_ce); - zephir_update_property_zval(&_7$$3, SL("serializer"), &serializer); - zephir_update_property_zval(&_7$$3, SL("defaultValue"), defaultValue); - ZEPHIR_INIT_VAR(&_8$$3); - ZEPHIR_INIT_NVAR(&_8$$3); - zephir_create_closure_bound(&_8$$3, &_7$$3, NULL, phalcon_0__closure_ce, SL("__invoke")); - ZEPHIR_CALL_FUNCTION(&_9$$3, "array_map", NULL, 193, &_8$$3, &results); + ZEPHIR_INIT_VAR(&_8$$4); + object_init_ex(&_8$$4, phalcon_0__closure_ce); + zephir_update_property_zval(&_8$$4, SL("serializer"), &serializer); + zephir_update_property_zval(&_8$$4, SL("defaultValue"), defaultValue); + ZEPHIR_INIT_VAR(&_9$$4); + ZEPHIR_INIT_NVAR(&_9$$4); + zephir_create_closure_bound(&_9$$4, &_8$$4, NULL, phalcon_0__closure_ce, SL("__invoke")); + ZEPHIR_CALL_FUNCTION(&_10$$4, "array_map", NULL, 193, &_9$$4, &results); zephir_check_call_status(); - ZEPHIR_CPY_WRT(&results, &_9$$3); - ZEPHIR_CALL_FUNCTION(&_9$$3, "array_combine", NULL, 259, &keysArray, &results); + ZEPHIR_CPY_WRT(&results, &_10$$4); + ZEPHIR_CALL_FUNCTION(&_10$$4, "array_combine", NULL, 259, &keysArray, &results); zephir_check_call_status(); - ZEPHIR_CPY_WRT(&results, &_9$$3); + ZEPHIR_CPY_WRT(&results, &_10$$4); } else { if (Z_TYPE_P(keys) == IS_STRING) { - ZEPHIR_INIT_VAR(&_11$$6); - zephir_string_to_char_array(&_11$$6, keys); - _10$$6 = &_11$$6; + ZEPHIR_INIT_VAR(&_12$$7); + zephir_string_to_char_array(&_12$$7, keys); + _11$$7 = &_12$$7; } else { - _10$$6 = keys; + _11$$7 = keys; } - zephir_is_iterable(_10$$6, 0, "phalcon/Cache/AbstractCache.zep", 247); - if (Z_TYPE_P(_10$$6) == IS_ARRAY) { - ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_10$$6), _12$$6) + zephir_is_iterable(_11$$7, 0, "phalcon/Cache/AbstractCache.zep", 265); + if (Z_TYPE_P(_11$$7) == IS_ARRAY) { + ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_11$$7), _13$$7) { ZEPHIR_INIT_NVAR(&element); - ZVAL_COPY(&element, _12$$6); - ZEPHIR_CALL_METHOD(&_13$$7, this_ptr, "get", &_14, 0, &element, defaultValue); + ZVAL_COPY(&element, _13$$7); + ZEPHIR_CALL_METHOD(&_14$$8, this_ptr, "get", &_15, 0, &element, defaultValue); zephir_check_call_status(); - zephir_array_update_zval(&results, &element, &_13$$7, PH_COPY | PH_SEPARATE); + zephir_array_update_zval(&results, &element, &_14$$8, PH_COPY | PH_SEPARATE); } ZEND_HASH_FOREACH_END(); } else { - ZEPHIR_CALL_METHOD(NULL, _10$$6, "rewind", NULL, 0); + ZEPHIR_CALL_METHOD(NULL, _11$$7, "rewind", NULL, 0); zephir_check_call_status(); - _16$$6 = 1; + _17$$7 = 1; while (1) { - if (_16$$6) { - _16$$6 = 0; + if (_17$$7) { + _17$$7 = 0; } else { - ZEPHIR_CALL_METHOD(NULL, _10$$6, "next", NULL, 0); + ZEPHIR_CALL_METHOD(NULL, _11$$7, "next", NULL, 0); zephir_check_call_status(); } - ZEPHIR_CALL_METHOD(&_15$$6, _10$$6, "valid", NULL, 0); + ZEPHIR_CALL_METHOD(&_16$$7, _11$$7, "valid", NULL, 0); zephir_check_call_status(); - if (!zend_is_true(&_15$$6)) { + if (!zend_is_true(&_16$$7)) { break; } - ZEPHIR_CALL_METHOD(&element, _10$$6, "current", NULL, 0); + ZEPHIR_CALL_METHOD(&element, _11$$7, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_17$$8, this_ptr, "get", &_14, 0, &element, defaultValue); + ZEPHIR_CALL_METHOD(&_18$$9, this_ptr, "get", &_15, 0, &element, defaultValue); zephir_check_call_status(); - zephir_array_update_zval(&results, &element, &_17$$8, PH_COPY | PH_SEPARATE); + zephir_array_update_zval(&results, &element, &_18$$9, PH_COPY | PH_SEPARATE); } } ZEPHIR_INIT_NVAR(&element); } - ZEPHIR_INIT_NVAR(&_0); - ZVAL_STRING(&_0, "cache:afterGetMultiple"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_0, keys); - zephir_check_call_status(); + zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_19) != IS_NULL) { + ZEPHIR_INIT_VAR(&_20$$10); + ZVAL_STRING(&_20$$10, "cache:afterGetMultiple"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_20$$10, keys); + zephir_check_call_status(); + } RETURN_CCTOR(&results); } @@ -627,17 +679,24 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doHas) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval key_zv, result, _0, _1; + zval key_zv, result, _0, _2, _3, _1$$3, _4$$4; zend_string *key = NULL; zval *this_ptr = getThis(); ZVAL_UNDEF(&key_zv); ZVAL_UNDEF(&result); ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); + ZVAL_UNDEF(&_3); + ZVAL_UNDEF(&_1$$3); + ZVAL_UNDEF(&_4$$4); 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("adapter", 7, 1); + _zephir_prop_0 = zend_string_init("eventsManager", 13, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("adapter", 7, 1); } ZEND_PARSE_PARAMETERS_START(1, 1) @@ -649,17 +708,23 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doHas) ZVAL_STR_COPY(&key_zv, key); ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkKey", NULL, 0, &key_zv); zephir_check_call_status(); - ZEPHIR_INIT_VAR(&_0); - ZVAL_STRING(&_0, "cache:beforeHas"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_0, &key_zv); - zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 272, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(&result, &_1, "has", NULL, 0, &key_zv); - zephir_check_call_status(); - ZEPHIR_INIT_NVAR(&_0); - ZVAL_STRING(&_0, "cache:afterHas"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_0, &key_zv); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_0) != IS_NULL) { + ZEPHIR_INIT_VAR(&_1$$3); + ZVAL_STRING(&_1$$3, "cache:beforeHas"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_1$$3, &key_zv); + zephir_check_call_status(); + } + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 273, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(&result, &_2, "has", NULL, 0, &key_zv); zephir_check_call_status(); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_3) != IS_NULL) { + ZEPHIR_INIT_VAR(&_4$$4); + ZVAL_STRING(&_4$$4, "cache:afterHas"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_4$$4, &key_zv); + zephir_check_call_status(); + } RETURN_CCTOR(&result); } @@ -673,7 +738,7 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doSet) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval key_zv, *value, value_sub, *ttl = NULL, ttl_sub, __$null, result, _0, _1; + zval key_zv, *value, value_sub, *ttl = NULL, ttl_sub, __$null, result, _0, _2, _3, _1$$3, _4$$4; zend_string *key = NULL; zval *this_ptr = getThis(); @@ -683,10 +748,17 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doSet) ZVAL_NULL(&__$null); ZVAL_UNDEF(&result); ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); + ZVAL_UNDEF(&_3); + ZVAL_UNDEF(&_1$$3); + ZVAL_UNDEF(&_4$$4); 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("adapter", 7, 1); + _zephir_prop_0 = zend_string_init("eventsManager", 13, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("adapter", 7, 1); } bool is_null_true = 1; @@ -710,17 +782,23 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doSet) } ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkKey", NULL, 0, &key_zv); zephir_check_call_status(); - ZEPHIR_INIT_VAR(&_0); - ZVAL_STRING(&_0, "cache:beforeSet"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_0, &key_zv); - zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 272, PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(&result, &_1, "set", NULL, 0, &key_zv, value, ttl); - zephir_check_call_status(); - ZEPHIR_INIT_NVAR(&_0); - ZVAL_STRING(&_0, "cache:afterSet"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_0, &key_zv); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_0) != IS_NULL) { + ZEPHIR_INIT_VAR(&_1$$3); + ZVAL_STRING(&_1$$3, "cache:beforeSet"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_1$$3, &key_zv); + zephir_check_call_status(); + } + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 273, PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(&result, &_2, "set", NULL, 0, &key_zv, value, ttl); zephir_check_call_status(); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_3) != IS_NULL) { + ZEPHIR_INIT_VAR(&_4$$4); + ZVAL_STRING(&_4$$4, "cache:afterSet"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_4$$4, &key_zv); + zephir_check_call_status(); + } RETURN_CCTOR(&result); } @@ -732,13 +810,13 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doSet) */ PHP_METHOD(Phalcon_Cache_AbstractCache, doSetMultiple) { - zend_string *_8; - zend_ulong _7; - zend_bool result = 0, _12; + zend_string *_10; + zend_ulong _9; + zend_bool result = 0, _14; zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; - zephir_fcall_cache_entry *_3 = NULL, *_10 = NULL; + zephir_fcall_cache_entry *_3 = NULL, *_12 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *values, values_sub, *ttl = NULL, ttl_sub, __$null, key, keys, value, *_0, _1, *_2, _4, *_5, *_6, _11, _14, _9$$4, _13$$6; + zval *values, values_sub, *ttl = NULL, ttl_sub, __$null, key, keys, value, *_0, _1, *_2, _4, *_6, _7, *_8, _13, _16, _5$$4, _11$$5, _15$$7, _17$$9; zval *this_ptr = getThis(); ZVAL_UNDEF(&values_sub); @@ -749,10 +827,18 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doSetMultiple) ZVAL_UNDEF(&value); ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_4); - ZVAL_UNDEF(&_11); - ZVAL_UNDEF(&_14); - ZVAL_UNDEF(&_9$$4); - ZVAL_UNDEF(&_13$$6); + ZVAL_UNDEF(&_7); + ZVAL_UNDEF(&_13); + ZVAL_UNDEF(&_16); + ZVAL_UNDEF(&_5$$4); + ZVAL_UNDEF(&_11$$5); + ZVAL_UNDEF(&_15$$7); + ZVAL_UNDEF(&_17$$9); + static zend_string *_zephir_prop_0 = NULL; + if (UNEXPECTED(!_zephir_prop_0)) { + _zephir_prop_0 = zend_string_init("eventsManager", 13, 1); + } + bool is_null_true = 1; ZEND_PARSE_PARAMETERS_START(1, 2) Z_PARAM_ZVAL(values) @@ -777,7 +863,7 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doSetMultiple) } else { _0 = &keys; } - zephir_is_iterable(_0, 0, "phalcon/Cache/AbstractCache.zep", 310); + zephir_is_iterable(_0, 0, "phalcon/Cache/AbstractCache.zep", 338); ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_0), _2) { ZEPHIR_INIT_NVAR(&key); @@ -786,69 +872,75 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, doSetMultiple) zephir_check_call_status(); } ZEND_HASH_FOREACH_END(); ZEPHIR_INIT_NVAR(&key); - ZEPHIR_INIT_VAR(&_4); - ZVAL_STRING(&_4, "cache:beforeSetMultiple"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_4, &keys); - zephir_check_call_status(); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_4) != IS_NULL) { + ZEPHIR_INIT_VAR(&_5$$4); + ZVAL_STRING(&_5$$4, "cache:beforeSetMultiple"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_5$$4, &keys); + zephir_check_call_status(); + } result = 1; if (Z_TYPE_P(values) == IS_STRING) { - ZEPHIR_INIT_NVAR(&_4); - zephir_string_to_char_array(&_4, values); - _5 = &_4; + ZEPHIR_INIT_VAR(&_7); + zephir_string_to_char_array(&_7, values); + _6 = &_7; } else { - _5 = values; + _6 = values; } - zephir_is_iterable(_5, 0, "phalcon/Cache/AbstractCache.zep", 319); - if (Z_TYPE_P(_5) == IS_ARRAY) { - ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_5), _7, _8, _6) + zephir_is_iterable(_6, 0, "phalcon/Cache/AbstractCache.zep", 349); + if (Z_TYPE_P(_6) == IS_ARRAY) { + ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(_6), _9, _10, _8) { ZEPHIR_INIT_NVAR(&key); - if (_8 != NULL) { - ZVAL_STR_COPY(&key, _8); + if (_10 != NULL) { + ZVAL_STR_COPY(&key, _10); } else { - ZVAL_LONG(&key, _7); + ZVAL_LONG(&key, _9); } ZEPHIR_INIT_NVAR(&value); - ZVAL_COPY(&value, _6); - ZEPHIR_CALL_METHOD(&_9$$4, this_ptr, "set", &_10, 0, &key, &value, ttl); + ZVAL_COPY(&value, _8); + ZEPHIR_CALL_METHOD(&_11$$5, this_ptr, "set", &_12, 0, &key, &value, ttl); zephir_check_call_status(); - if (!ZEPHIR_IS_TRUE_IDENTICAL(&_9$$4)) { + if (!ZEPHIR_IS_TRUE_IDENTICAL(&_11$$5)) { result = 0; } } ZEND_HASH_FOREACH_END(); } else { - ZEPHIR_CALL_METHOD(NULL, _5, "rewind", NULL, 0); + ZEPHIR_CALL_METHOD(NULL, _6, "rewind", NULL, 0); zephir_check_call_status(); - _12 = 1; + _14 = 1; while (1) { - if (_12) { - _12 = 0; + if (_14) { + _14 = 0; } else { - ZEPHIR_CALL_METHOD(NULL, _5, "next", NULL, 0); + ZEPHIR_CALL_METHOD(NULL, _6, "next", NULL, 0); zephir_check_call_status(); } - ZEPHIR_CALL_METHOD(&_11, _5, "valid", NULL, 0); + ZEPHIR_CALL_METHOD(&_13, _6, "valid", NULL, 0); zephir_check_call_status(); - if (!zend_is_true(&_11)) { + if (!zend_is_true(&_13)) { break; } - ZEPHIR_CALL_METHOD(&key, _5, "key", NULL, 0); + ZEPHIR_CALL_METHOD(&key, _6, "key", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&value, _5, "current", NULL, 0); + ZEPHIR_CALL_METHOD(&value, _6, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_13$$6, this_ptr, "set", &_10, 0, &key, &value, ttl); + ZEPHIR_CALL_METHOD(&_15$$7, this_ptr, "set", &_12, 0, &key, &value, ttl); zephir_check_call_status(); - if (!ZEPHIR_IS_TRUE_IDENTICAL(&_13$$6)) { + if (!ZEPHIR_IS_TRUE_IDENTICAL(&_15$$7)) { result = 0; } } } ZEPHIR_INIT_NVAR(&value); ZEPHIR_INIT_NVAR(&key); - ZEPHIR_INIT_VAR(&_14); - ZVAL_STRING(&_14, "cache:afterSetMultiple"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_14, &keys); - zephir_check_call_status(); + zephir_read_property_cached(&_16, this_ptr, _zephir_prop_0, 274, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_16) != IS_NULL) { + ZEPHIR_INIT_VAR(&_17$$9); + ZVAL_STRING(&_17$$9, "cache:afterSetMultiple"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_17$$9, &keys); + zephir_check_call_status(); + } RETURN_MM_BOOL(result); } @@ -910,12 +1002,12 @@ PHP_METHOD(Phalcon_Cache_AbstractCache, setEventsManager) _2 = ZEPHIR_IS_TRUE_IDENTICAL(&_1); if (_2) { zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 275, PH_NOISY_CC); _2 = Z_TYPE_P(&_3) != IS_NULL; } if (_2) { zephir_memory_observe(&_4$$3); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 273, PH_NOISY_CC); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 275, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_5$$3); ZVAL_STRING(&_5$$3, "eventsManager"); ZVAL_BOOL(&_6$$3, 1); diff --git a/ext/phalcon/cache/adapterfactory.zep.c b/ext/phalcon/cache/adapterfactory.zep.c index 59ff581d4e..1ec58ce40d 100644 --- a/ext/phalcon/cache/adapterfactory.zep.c +++ b/ext/phalcon/cache/adapterfactory.zep.c @@ -79,7 +79,7 @@ PHP_METHOD(Phalcon_Cache_AdapterFactory, __construct) } else { zephir_get_arrval(&services, services_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 503, serializerFactory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 504, serializerFactory); ZEPHIR_CALL_METHOD(NULL, this_ptr, "init", NULL, 0, &services); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -156,7 +156,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, 503, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 504, 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 fd4cafd745..28e89443c8 100644 --- a/ext/phalcon/cache/cachefactory.zep.c +++ b/ext/phalcon/cache/cachefactory.zep.c @@ -63,7 +63,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, 504, factory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 505, factory); } /** @@ -204,7 +204,7 @@ PHP_METHOD(Phalcon_Cache_CacheFactory, newInstance) } else { zephir_get_arrval(&options, options_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 504, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 505, 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); diff --git a/ext/phalcon/cli/console.zep.c b/ext/phalcon/cli/console.zep.c index 03550e2db4..a3372076a4 100644 --- a/ext/phalcon/cli/console.zep.c +++ b/ext/phalcon/cli/console.zep.c @@ -161,7 +161,7 @@ PHP_METHOD(Phalcon_Cli_Console, handle) } else { zephir_get_arrval(&arguments, arguments_param); } - 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, 506, 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); @@ -171,9 +171,9 @@ PHP_METHOD(Phalcon_Cli_Console, handle) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 506, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 507, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_2) != IS_NULL) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 506, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 507, 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); @@ -182,7 +182,7 @@ PHP_METHOD(Phalcon_Cli_Console, handle) RETURN_MM_BOOL(0); } } - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 505, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 506, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_8); ZVAL_STRING(&_8, "router"); ZEPHIR_CALL_METHOD(&_7, &_6, "getShared", NULL, 0, &_8); @@ -190,11 +190,11 @@ PHP_METHOD(Phalcon_Cli_Console, handle) ZEPHIR_CPY_WRT(&router, &_7); _9 = ZEPHIR_IS_EMPTY(&arguments); if (_9) { - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 507, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 508, PH_NOISY_CC | PH_READONLY); _9 = zephir_is_true(&_10); } if (_9) { - zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_2, 507, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_2, 508, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &router, "handle", NULL, 0, &_11$$6); zephir_check_call_status(); } else { @@ -205,12 +205,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, 508, PH_NOISY_CC); + zephir_read_property_cached(&moduleName, this_ptr, _zephir_prop_3, 509, PH_NOISY_CC); } if (zephir_is_true(&moduleName)) { - zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_1, 506, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_1, 507, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_12$$9) != IS_NULL) { - zephir_read_property_cached(&_13$$10, this_ptr, _zephir_prop_1, 506, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$10, this_ptr, _zephir_prop_1, 507, 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); @@ -261,14 +261,14 @@ PHP_METHOD(Phalcon_Cli_Console, handle) } } } - zephir_read_property_cached(&_21$$13, this_ptr, _zephir_prop_0, 505, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$13, this_ptr, _zephir_prop_0, 506, 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, 505, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$13, this_ptr, _zephir_prop_0, 506, 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, 505, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24$$13, this_ptr, _zephir_prop_0, 506, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &moduleObject, "registerServices", NULL, 0, &_24$$13); zephir_check_call_status(); } else { @@ -286,15 +286,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, 505, PH_NOISY_CC); + zephir_read_property_cached(&_28$$18, this_ptr, _zephir_prop_0, 506, 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, 506, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$9, this_ptr, _zephir_prop_1, 507, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_29$$9) != IS_NULL) { - zephir_read_property_cached(&_30$$20, this_ptr, _zephir_prop_1, 506, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_30$$20, this_ptr, _zephir_prop_1, 507, 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); @@ -304,7 +304,7 @@ PHP_METHOD(Phalcon_Cli_Console, handle) } } } - zephir_read_property_cached(&_33, this_ptr, _zephir_prop_0, 505, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_33, this_ptr, _zephir_prop_0, 506, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_8); ZVAL_STRING(&_8, "dispatcher"); ZEPHIR_CALL_METHOD(&_7, &_33, "getShared", NULL, 0, &_8); @@ -324,12 +324,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, 509, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_36, this_ptr, _zephir_prop_4, 510, 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, 506, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_37, this_ptr, _zephir_prop_1, 507, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_37) != IS_NULL) { - zephir_read_property_cached(&_38$$22, this_ptr, _zephir_prop_1, 506, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_38$$22, this_ptr, _zephir_prop_1, 507, 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); @@ -340,9 +340,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, 506, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_41, this_ptr, _zephir_prop_1, 507, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_41) != IS_NULL) { - zephir_read_property_cached(&_42$$24, this_ptr, _zephir_prop_1, 506, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_42$$24, this_ptr, _zephir_prop_1, 507, 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); @@ -612,7 +612,7 @@ PHP_METHOD(Phalcon_Cli_Console, setArgument) ZEPHIR_CALL_CE_STATIC(&_46$$22, phalcon_cli_router_route_ce, "getDelimiter", NULL, 0); zephir_check_call_status(); zephir_fast_join(&_45$$22, &_46$$22, &args); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 507, &_45$$22); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 508, &_45$$22); } else { if (!(ZEPHIR_IS_EMPTY(&args))) { ZEPHIR_MAKE_REF(&args); @@ -633,9 +633,9 @@ PHP_METHOD(Phalcon_Cli_Console, setArgument) zephir_fast_array_merge(&_49$$26, &handleArgs, &args); ZEPHIR_CPY_WRT(&handleArgs, &_49$$26); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 507, &handleArgs); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 508, &handleArgs); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 509, &opts); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 510, &opts); RETURN_THIS(); } diff --git a/ext/phalcon/cli/dispatcher.zep.c b/ext/phalcon/cli/dispatcher.zep.c index 3f9653c062..1f4556ec1e 100644 --- a/ext/phalcon/cli/dispatcher.zep.c +++ b/ext/phalcon/cli/dispatcher.zep.c @@ -138,7 +138,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, 510, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 511, PH_NOISY_CC | PH_READONLY); zephir_fast_array_merge(&_0, &localParams, &_1); ZEPHIR_CPY_WRT(&localParams, &_0); ZEPHIR_INIT_VAR(&_2); @@ -226,7 +226,7 @@ PHP_METHOD(Phalcon_Cli_Dispatcher, getOption) defaultValue = &defaultValue_sub; defaultValue = &__$null; } - 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, 511, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); zephir_memory_observe(&optionValue); if (!(zephir_array_isset_fetch(&optionValue, &options, option, 0))) { @@ -236,7 +236,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, 511, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 512, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (Z_TYPE_P(&container) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$5); @@ -305,7 +305,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, 510, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 511, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, option)); } @@ -328,7 +328,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, 512, &taskName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 513, &taskName_zv); } /** @@ -356,7 +356,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, 510, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 511, &options); ZEPHIR_MM_RESTORE(); } @@ -379,7 +379,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, 513, &taskName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 514, &taskName_zv); } /** @@ -401,7 +401,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, 514, &taskSuffix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 515, &taskSuffix_zv); } /** @@ -430,7 +430,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, 515, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 516, 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 9a9c196c5e..cb0d1f9e82 100644 --- a/ext/phalcon/cli/router.zep.c +++ b/ext/phalcon/cli/router.zep.c @@ -333,9 +333,9 @@ PHP_METHOD(Phalcon_Cli_Router, getRouteById) 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, 516, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 517, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, id)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 516, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 517, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2$$3); zephir_array_fetch(&_2$$3, &_1$$3, id, PH_NOISY, "phalcon/Cli/Router.zep", 179); RETURN_CCTOR(&_2$$3); @@ -374,7 +374,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, 516, 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_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); @@ -595,13 +595,13 @@ PHP_METHOD(Phalcon_Cli_Router, handle) ZVAL_NULL(&matches); ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 517, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 518, &_0); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 518, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 519, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 518, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 519, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 519, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 520, &__$null); if (Z_TYPE_P(arguments) != IS_ARRAY) { _1$$3 = Z_TYPE_P(arguments) != IS_STRING; if (_1$$3) { @@ -622,7 +622,7 @@ PHP_METHOD(Phalcon_Cli_Router, handle) ZEPHIR_INIT_NVAR(arguments); ZVAL_STRING(arguments, ""); } - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_3, 516, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_3, 517, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_4$$3) == IS_STRING) { ZEPHIR_INIT_VAR(&_6$$3); zephir_string_to_char_array(&_6$$3, &_4$$3); @@ -773,9 +773,9 @@ PHP_METHOD(Phalcon_Cli_Router, handle) } ZEPHIR_INIT_NVAR(&position); ZEPHIR_INIT_NVAR(&part); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 517, &matches); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 518, &matches); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 519, &route); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 520, &route); break; } } ZEND_HASH_FOREACH_END(); @@ -934,9 +934,9 @@ PHP_METHOD(Phalcon_Cli_Router, handle) } ZEPHIR_INIT_NVAR(&position); ZEPHIR_INIT_NVAR(&part); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 517, &matches); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 518, &matches); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 519, &route); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 520, &route); break; } } @@ -944,24 +944,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_1, 518, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 519, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 518, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 519, &__$false); } } else { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 518, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 519, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 518, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 519, &__$false); } - zephir_read_property_cached(&_47$$47, this_ptr, _zephir_prop_4, 520, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 521, &_47$$47); - zephir_read_property_cached(&_48$$47, this_ptr, _zephir_prop_6, 522, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 523, &_48$$47); - zephir_read_property_cached(&_49$$47, this_ptr, _zephir_prop_8, 524, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 525, &_49$$47); - zephir_read_property_cached(&_50$$47, this_ptr, _zephir_prop_10, 526, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 527, &_50$$47); + zephir_read_property_cached(&_47$$47, this_ptr, _zephir_prop_4, 521, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 522, &_47$$47); + zephir_read_property_cached(&_48$$47, this_ptr, _zephir_prop_6, 523, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 524, &_48$$47); + zephir_read_property_cached(&_49$$47, this_ptr, _zephir_prop_8, 525, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 526, &_49$$47); + zephir_read_property_cached(&_50$$47, this_ptr, _zephir_prop_10, 527, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 528, &_50$$47); RETURN_THIS(); } } else { @@ -978,21 +978,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, 520, PH_NOISY_CC); + zephir_read_property_cached(&moduleName, this_ptr, _zephir_prop_4, 521, 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, 522, PH_NOISY_CC); + zephir_read_property_cached(&taskName, this_ptr, _zephir_prop_6, 523, 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, 524, PH_NOISY_CC); + zephir_read_property_cached(&actionName, this_ptr, _zephir_prop_8, 525, PH_NOISY_CC); } ZEPHIR_OBS_NVAR(¶ms); if (zephir_array_isset_string_fetch(¶ms, &parts, SL("params"), 0)) { @@ -1020,10 +1020,10 @@ PHP_METHOD(Phalcon_Cli_Router, handle) } else { ZEPHIR_CPY_WRT(¶ms, &parts); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 521, &moduleName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 523, &taskName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 525, &actionName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 527, ¶ms); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 522, &moduleName); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 524, &taskName); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 526, &actionName); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 528, ¶ms); RETURN_THIS(); } @@ -1046,7 +1046,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, 524, &actionName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 525, &actionName_zv); RETURN_THISW(); } @@ -1069,7 +1069,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, 520, &moduleName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 521, &moduleName_zv); RETURN_THISW(); } @@ -1127,19 +1127,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, 520, &module); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 521, &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, 522, &task); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 523, &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, 524, &action); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 525, &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, 526, ¶ms); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 527, ¶ms); } RETURN_THIS(); } @@ -1163,7 +1163,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, 522, &taskName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 523, &taskName_zv); RETURN_THISW(); } diff --git a/ext/phalcon/cli/router/route.zep.c b/ext/phalcon/cli/router/route.zep.c index c38b135e6a..9f34864881 100644 --- a/ext/phalcon/cli/router/route.zep.c +++ b/ext/phalcon/cli/router/route.zep.c @@ -171,7 +171,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, 528, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 529, &_0); ZEPHIR_CALL_METHOD(NULL, this_ptr, "reConfigure", NULL, 0, &pattern_zv, paths); zephir_check_call_status(); zephir_memory_observe(&_1); @@ -179,7 +179,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, 529, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 530, &_2); ZEPHIR_INIT_VAR(&_3); ZVAL_LONG(&_3, 1); ZEPHIR_INIT_VAR(&_4); @@ -285,14 +285,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, 530, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 531, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 461, &_1$$3); zephir_check_call_status(); zephir_throw_exception_debug(&_0$$3, "phalcon/Cli/Router/Route.zep", 123); ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 531, callback); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 532, callback); RETURN_THIS(); } @@ -346,41 +346,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", 141)) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 528, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 529, 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, 528, PH_NOISY_CC); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 529, 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, 528, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 529, 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, 528, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 529, 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, 528, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 529, 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, 528, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 529, 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, 528, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 529, 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, 528, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$3, this_ptr, _zephir_prop_0, 529, 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, 528, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$3, this_ptr, _zephir_prop_0, 529, 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, 528, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$3, this_ptr, _zephir_prop_0, 529, 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); @@ -627,7 +627,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, 528, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$27, this_ptr, _zephir_prop_0, 529, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_29$$27); ZEPHIR_CONCAT_SVS(&_29$$27, "([^", &_28$$27, "]*)"); zephir_concat_self(&route, &_29$$27); @@ -752,7 +752,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, 532, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 533, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_FUNCTION("array_flip", NULL, 266, &_0); zephir_check_call_status(); RETURN_MM(); @@ -941,7 +941,7 @@ PHP_METHOD(Phalcon_Cli_Router_Route, reConfigure) } else { if (zephir_memnstr_str(&pattern, SL(":delimiter"), "phalcon/Cli/Router/Route.zep", 508)) { ZEPHIR_INIT_VAR(&_7$$21); - zephir_read_property_cached(&_8$$21, this_ptr, _zephir_prop_0, 528, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$21, this_ptr, _zephir_prop_0, 529, 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); @@ -949,9 +949,9 @@ PHP_METHOD(Phalcon_Cli_Router_Route, reConfigure) } ZEPHIR_CPY_WRT(&compiledPattern, &pattern); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 530, &pattern); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 533, &compiledPattern); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 532, &routePaths); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 531, &pattern); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 534, &compiledPattern); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 533, &routePaths); ZEPHIR_MM_RESTORE(); } @@ -974,7 +974,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, 534, &description_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 535, &description_zv); RETURN_THISW(); } @@ -1006,7 +1006,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, 535, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 536, &name_zv); RETURN_THISW(); } diff --git a/ext/phalcon/cli/task.zep.c b/ext/phalcon/cli/task.zep.c index f459ab476f..0b12e15ccc 100644 --- a/ext/phalcon/cli/task.zep.c +++ b/ext/phalcon/cli/task.zep.c @@ -136,19 +136,19 @@ PHP_METHOD(Phalcon_Cli_Task, setEventsManager) _2 = ZEPHIR_IS_TRUE_IDENTICAL(&_1); if (_2) { zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 275, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 276, PH_NOISY_CC); _2 = Z_TYPE_P(&_3) != IS_NULL; } if (_2) { zephir_memory_observe(&_4$$3); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 275, PH_NOISY_CC); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 276, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_5$$3); ZVAL_STRING(&_5$$3, "eventsManager"); ZVAL_BOOL(&_6$$3, 1); ZEPHIR_CALL_METHOD(NULL, &_4$$3, "set", NULL, 0, &_5$$3, eventsManager, &_6$$3); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 276, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 277, eventsManager); ZEPHIR_MM_RESTORE(); } @@ -214,16 +214,16 @@ PHP_METHOD(Phalcon_Cli_Task, fireManagerEvent) stopOnFalse = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 276, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 277, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { _1$$3 = stopOnFalse; if (_1$$3) { zephir_memory_observe(&_2$$3); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 276, PH_NOISY_CC); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 277, PH_NOISY_CC); _1$$3 = zephir_instance_of_ev(&_2$$3, phalcon_events_manager_ce); } if (_1$$3) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 276, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 277, PH_NOISY_CC | PH_READONLY); if (cancellable) { ZVAL_BOOL(&_4$$4, 1); } else { @@ -234,7 +234,7 @@ PHP_METHOD(Phalcon_Cli_Task, fireManagerEvent) zephir_check_call_status(); RETURN_MM(); } - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 276, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 277, PH_NOISY_CC | PH_READONLY); if (cancellable) { ZVAL_BOOL(&_7$$3, 1); } else { diff --git a/ext/phalcon/config/adapter/grouped.zep.c b/ext/phalcon/config/adapter/grouped.zep.c index 286a9db3a4..d9f1ecc81c 100644 --- a/ext/phalcon/config/adapter/grouped.zep.c +++ b/ext/phalcon/config/adapter/grouped.zep.c @@ -229,7 +229,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Grouped, __construct) zephir_array_fetch_string(&configArray, &configInstance, SL("config"), PH_NOISY, "phalcon/Config/Adapter/Grouped.zep", 129); ZEPHIR_INIT_NVAR(&configInstance); object_init_ex(&configInstance, phalcon_config_config_ce); - zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_0, 536, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_0, 537, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &configInstance, "__construct", &_13, 41, &configArray, &_12$$9); zephir_check_call_status(); } else { @@ -303,7 +303,7 @@ PHP_METHOD(Phalcon_Config_Adapter_Grouped, __construct) zephir_array_fetch_string(&configArray, &configInstance, SL("config"), PH_NOISY, "phalcon/Config/Adapter/Grouped.zep", 129); ZEPHIR_INIT_NVAR(&configInstance); object_init_ex(&configInstance, phalcon_config_config_ce); - zephir_read_property_cached(&_24$$17, this_ptr, _zephir_prop_0, 536, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24$$17, this_ptr, _zephir_prop_0, 537, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &configInstance, "__construct", &_13, 41, &configArray, &_24$$17); zephir_check_call_status(); } else { diff --git a/ext/phalcon/config/exceptions/cannotloadconfigfile.zep.c b/ext/phalcon/config/exceptions/cannotloadconfigfile.zep.c index 26183630f2..451fed69ec 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, 537, &fileName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 538, &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 2d99858cee..c811825d52 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, 538, &option_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 539, &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 a89a25f950..072e1124ce 100644 --- a/ext/phalcon/container/container.zep.c +++ b/ext/phalcon/container/container.zep.c @@ -173,7 +173,7 @@ PHP_METHOD(Phalcon_Container_Container, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 539, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 540, &_0); ZEPHIR_INIT_VAR(&_1); zephir_create_array(&_1, 3, 0); ZEPHIR_INIT_VAR(&_2); @@ -200,7 +200,7 @@ PHP_METHOD(Phalcon_Container_Container, __construct) } zephir_array_fast_append(&_1, &_2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 540, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 541, &_1); ZEPHIR_MM_RESTORE(); } @@ -335,13 +335,13 @@ 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_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, 542, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_0, &name)) { ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "resolveAlias", NULL, 477, &name); zephir_check_call_status(); zephir_get_strval(&name, &_1$$3); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 542, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 543, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_2, &name)) { ZEPHIR_INIT_VAR(&_3$$4); object_init_ex(&_3$$4, phalcon_container_exceptions_cannotextendresolved_ce); @@ -351,7 +351,7 @@ PHP_METHOD(Phalcon_Container_Container, extend) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 543, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 544, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_key_exists(&_4, &name))) { ZEPHIR_INIT_VAR(&_5$$5); object_init_ex(&_5$$5, phalcon_container_exceptions_servicenotfound_ce); @@ -361,7 +361,7 @@ PHP_METHOD(Phalcon_Container_Container, extend) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 543, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 544, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_7); zephir_array_fetch(&_7, &_6, &name, PH_NOISY, "phalcon/Container/Container.zep", 170); ZEPHIR_CALL_METHOD(NULL, &_7, "addExtender", NULL, 0, callableObject); @@ -410,21 +410,21 @@ 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_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, 542, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_0, &name)) { ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "resolveAlias", NULL, 477, &name); zephir_check_call_status(); zephir_get_strval(&name, &_1$$3); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 544, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 545, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_2, &name)) { ZEPHIR_RETURN_CALL_METHOD(this_ptr, "resolveParameter", NULL, 480, &name); zephir_check_call_status(); RETURN_MM(); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 542, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 543, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_3, &name)) { - zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_2, 542, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_2, 543, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_5$$5); zephir_array_fetch(&_5$$5, &_4$$5, &name, PH_NOISY, "phalcon/Container/Container.zep", 189); RETURN_CCTOR(&_5$$5); @@ -461,7 +461,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, 541, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 542, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&alias, &_0, &name_zv, 0)) { RETURN_CCTOR(&alias); } @@ -505,7 +505,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, 545, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 546, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&names, &_0, &tag_zv, 0))) { ZEPHIR_INIT_NVAR(&names); array_init(&names); @@ -586,7 +586,7 @@ 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, 543, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 544, 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); @@ -596,7 +596,7 @@ PHP_METHOD(Phalcon_Container_Container, getDefinition) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 543, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 544, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_3); zephir_array_fetch(&_3, &_2, &name_zv, PH_NOISY, "phalcon/Container/Container.zep", 242); RETURN_CCTOR(&_3); @@ -632,7 +632,7 @@ 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, 542, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 543, 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); @@ -642,7 +642,7 @@ PHP_METHOD(Phalcon_Container_Container, getInstance) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 542, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 543, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_3); zephir_array_fetch(&_3, &_2, &name_zv, PH_NOISY, "phalcon/Container/Container.zep", 256); RETURN_CCTOR(&_3); @@ -676,7 +676,7 @@ 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, 544, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 545, 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); @@ -755,7 +755,7 @@ PHP_METHOD(Phalcon_Container_Container, getServiceNames) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("services", 8, 1); } - 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, 544, PH_NOISY_CC | PH_READONLY); zephir_array_keys(return_value, &_0); return; } @@ -815,30 +815,30 @@ 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_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, 542, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_0, &name)) { ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "resolveAlias", NULL, 477, &name); zephir_check_call_status(); zephir_get_strval(&name, &_1$$3); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 544, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 545, PH_NOISY_CC | PH_READONLY); _3 = zephir_array_key_exists(&_2, &name); if (!(_3)) { - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 542, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 543, PH_NOISY_CC | PH_READONLY); _3 = zephir_array_key_exists(&_4, &name); } _5 = _3; if (!(_5)) { - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_3, 543, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_3, 544, PH_NOISY_CC | PH_READONLY); _5 = zephir_array_key_exists(&_6, &name); } if (_5) { RETURN_MM_BOOL(1); } - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_4, 546, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_4, 547, PH_NOISY_CC | PH_READONLY); _8 = zephir_is_true(&_7); if (_8) { - zephir_read_property_cached(&_9, this_ptr, _zephir_prop_5, 539, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_5, 540, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_10, &_9, "isResolvableClass", NULL, 0, &name); zephir_check_call_status(); _8 = zephir_is_true(&_10); @@ -866,7 +866,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, 541, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 542, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_key_exists(&_0, &name_zv)); } @@ -890,7 +890,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, 543, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 544, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_key_exists(&_0, &name_zv)); } @@ -914,7 +914,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, 542, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 543, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_key_exists(&_0, &name_zv)); } @@ -938,7 +938,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, 544, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 545, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_key_exists(&_0, &name_zv)); } @@ -1008,7 +1008,7 @@ 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_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, 542, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_0, &name)) { ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "resolveAlias", NULL, 477, &name); zephir_check_call_status(); @@ -1117,7 +1117,7 @@ PHP_METHOD(Phalcon_Container_Container, setAlias) ZVAL_STR_COPY(&alias_zv, alias); _0 = ZEPHIR_IS_IDENTICAL(&name_zv, &alias_zv); if (!(_0)) { - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 541, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 542, PH_NOISY_CC | PH_READONLY); _0 = zephir_array_key_exists(&_1, &name_zv); } if (_0) { @@ -1149,9 +1149,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, 546, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 547, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 546, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 547, &__$false); } RETURN_THISW(); } @@ -1257,13 +1257,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, 545, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 546, 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, 545, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 546, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_3); zephir_array_fetch(&_3, &_2, &tag_zv, PH_NOISY, "phalcon/Container/Container.zep", 496); ZEPHIR_CALL_FUNCTION(&_4, "in_array", NULL, 88, &serviceName_zv, &_3, &__$true); @@ -1357,7 +1357,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, 547, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 548, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); @@ -1484,7 +1484,7 @@ PHP_METHOD(Phalcon_Container_Container, detectCircularAlias) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 541, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 542, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_key_exists(&_2$$3, ¤t))) { break; } @@ -1495,7 +1495,7 @@ PHP_METHOD(Phalcon_Container_Container, detectCircularAlias) break; } zephir_array_update_zval(&seen, ¤t, &__$true, PH_COPY | PH_SEPARATE); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 541, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 542, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_4$$3); zephir_array_fetch(&_4$$3, &_3$$3, ¤t, PH_NOISY, "phalcon/Container/Container.zep", 581); ZEPHIR_CPY_WRT(¤t, &_4$$3); @@ -1535,7 +1535,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, 540, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 541, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); @@ -1631,9 +1631,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, 543, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 544, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_key_exists(&_0, &name_zv))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 546, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 547, PH_NOISY_CC | PH_READONLY); _2$$3 = zephir_is_true(&_1$$3); if (_2$$3) { _2$$3 = zephir_class_exists(&name_zv, 1); @@ -1651,7 +1651,7 @@ PHP_METHOD(Phalcon_Container_Container, resolve) 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, 544, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&definition); zephir_array_fetch(&definition, &_4, &name_zv, PH_NOISY, "phalcon/Container/Container.zep", 621); ZEPHIR_CALL_METHOD(NULL, &definition, "freeze", NULL, 0, this_ptr); @@ -1709,7 +1709,7 @@ PHP_METHOD(Phalcon_Container_Container, resolveAlias) ZVAL_NULL(&seen); ZEPHIR_CPY_WRT(¤t, &name_zv); while (1) { - 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, 542, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_key_exists(&_0, ¤t))) { break; } @@ -1726,7 +1726,7 @@ PHP_METHOD(Phalcon_Container_Container, resolveAlias) return; } zephir_array_update_zval(&seen, ¤t, &__$true, PH_COPY | PH_SEPARATE); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 541, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 542, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_4$$3); zephir_array_fetch(&_4$$3, &_3$$3, ¤t, PH_NOISY, "phalcon/Container/Container.zep", 669); ZEPHIR_CPY_WRT(¤t, &_4$$3); @@ -1762,7 +1762,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, 544, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 545, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&value); zephir_array_fetch(&value, &_0, &name_zv, PH_NOISY, "phalcon/Container/Container.zep", 682); _1 = Z_TYPE_P(&value) == IS_OBJECT; diff --git a/ext/phalcon/container/containerfactory.zep.c b/ext/phalcon/container/containerfactory.zep.c index a8885dfc82..37f38f36e6 100644 --- a/ext/phalcon/container/containerfactory.zep.c +++ b/ext/phalcon/container/containerfactory.zep.c @@ -110,7 +110,7 @@ PHP_METHOD(Phalcon_Container_ContainerFactory, newContainer) object_init_ex(&container, phalcon_container_container_ce); ZEPHIR_CALL_METHOD(NULL, &container, "__construct", NULL, 227); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 548, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 549, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); diff --git a/ext/phalcon/container/definition/servicedefinition.zep.c b/ext/phalcon/container/definition/servicedefinition.zep.c index 5dc72582d5..2f2fa50552 100644 --- a/ext/phalcon/container/definition/servicedefinition.zep.c +++ b/ext/phalcon/container/definition/servicedefinition.zep.c @@ -179,9 +179,9 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, __construct) raw = &raw_sub; raw = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 549, &serviceName_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 550, &type_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 551, raw); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 550, &serviceName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 551, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 552, raw); } /** @@ -209,7 +209,7 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, addExtender) 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, &extender); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 552, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 553, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkFrozen", NULL, 0); zephir_check_call_status(); @@ -265,26 +265,26 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, addTag) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&tag_zv); ZVAL_STR_COPY(&tag_zv, tag); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 552, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 553, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkFrozen", NULL, 0); zephir_check_call_status(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 553, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 554, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_2, "in_array", NULL, 88, &tag_zv, &_1, &__$true); zephir_check_call_status(); if (!zephir_is_true(&_2)) { zephir_update_property_array_append(this_ptr, SL("tags"), &tag_zv); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 554, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 555, PH_NOISY_CC | PH_READONLY); _4 = Z_TYPE_P(&_3) != IS_NULL; if (_4) { - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 554, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 555, PH_NOISY_CC | PH_READONLY); _4 = (zephir_method_exists_ex(&_5, ZEND_STRL("settag")) == SUCCESS); } if (_4) { - zephir_read_property_cached(&_6$$5, this_ptr, _zephir_prop_2, 554, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_3, 549, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$5, this_ptr, _zephir_prop_2, 555, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_3, 550, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_6$$5, "setTag", NULL, 0, &tag_zv, &_7$$5); zephir_check_call_status(); } @@ -351,22 +351,22 @@ 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, 555, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 556, 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, 556, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 557, 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, 556, PH_NOISY_CC); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 557, PH_NOISY_CC); } else { ZEPHIR_OBS_NVAR(&_2$$4); - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 549, PH_NOISY_CC); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 550, PH_NOISY_CC); } ZEPHIR_CPY_WRT(&className, &_2$$4); - zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_3, 557, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_3, 558, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&args, this_ptr, "resolveArgs", NULL, 493, container, &_4$$4); zephir_check_call_status(); ZEPHIR_INIT_VAR(&reflection); @@ -376,7 +376,7 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, buildService) ZEPHIR_CALL_METHOD(&instance, &reflection, "newInstanceArgs", NULL, 494, &args); zephir_check_call_status(); } - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_4, 558, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_4, 559, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_5) == IS_STRING) { ZEPHIR_INIT_VAR(&_7); zephir_string_to_char_array(&_7, &_5); @@ -483,11 +483,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, 552, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 553, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 550, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 551, PH_NOISY_CC | PH_READONLY); _2 = ZEPHIR_IS_STRING_IDENTICAL(&_1, "string"); if (_2) { _2 = (zephir_method_exists_ex(container, ZEND_STRL("isautowireenabled")) == SUCCESS); @@ -500,13 +500,13 @@ 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, 556, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_3, 557, 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, 556, PH_NOISY_CC); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_3, 557, PH_NOISY_CC); } else { ZEPHIR_OBS_NVAR(&_8$$4); - zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_4, 549, PH_NOISY_CC); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_4, 550, PH_NOISY_CC); } ZEPHIR_CPY_WRT(&className, &_8$$4); ZEPHIR_INIT_VAR(&reflection); @@ -525,28 +525,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, 559, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_2, 560, 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, 557, &_11$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 558, &_11$$5); } } else { - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 550, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 551, 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, 559, PH_NOISY_CC); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 560, PH_NOISY_CC); _6 = !(ZEPHIR_IS_EMPTY(&_7)); } if (_6) { - zephir_read_property_cached(&_13$$6, this_ptr, _zephir_prop_2, 559, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 557, &_13$$6); + zephir_read_property_cached(&_13$$6, this_ptr, _zephir_prop_2, 560, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 558, &_13$$6); } } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 552, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 553, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 552, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 553, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -588,11 +588,11 @@ 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, 556, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 557, 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, 549, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 550, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 496, &_2$$3); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Container/Definition/ServiceDefinition.zep", 226); @@ -650,11 +650,11 @@ 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, 555, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 556, 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, 549, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 550, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 497, &_2$$3); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Container/Definition/ServiceDefinition.zep", 260); @@ -715,7 +715,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, 556, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 557, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(Z_TYPE_P(&_0) != IS_NULL); } @@ -737,7 +737,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, 558, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 559, PH_NOISY_CC); RETURN_MM_BOOL(!(ZEPHIR_IS_EMPTY(&_0))); } @@ -754,7 +754,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, 555, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 556, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(Z_TYPE_P(&_0) != IS_NULL); } @@ -777,10 +777,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, 560, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 561, PH_NOISY_CC | PH_READONLY); _1 = zephir_is_true(&_0); if (_1) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 552, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 553, PH_NOISY_CC | PH_READONLY); _1 = zephir_is_true(&_2); } RETURN_BOOL(_1); @@ -825,7 +825,7 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, setArgument) 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, ¶m, &value); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 552, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 553, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkFrozen", NULL, 0); zephir_check_call_status(); @@ -867,12 +867,12 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, setClass) 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, 552, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 553, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkFrozen", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 556, &className_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 557, &className_zv); RETURN_THIS(); } @@ -894,7 +894,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, 554, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 555, container); RETURN_THISW(); } @@ -950,7 +950,7 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, setExtenders) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &extenders_param); zephir_get_arrval(&extenders, extenders_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 552, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 553, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkFrozen", NULL, 0); zephir_check_call_status(); @@ -970,7 +970,7 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, setExtenders) if (!(zephir_is_callable(&extender))) { ZEPHIR_INIT_NVAR(&_4$$5); object_init_ex(&_4$$5, phalcon_container_exceptions_invalidextender_ce); - zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 549, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 550, PH_NOISY_CC | PH_READONLY); zephir_cast_to_string(&_6$$5, &key); ZEPHIR_CALL_METHOD(NULL, &_4$$5, "__construct", &_7, 498, &_5$$5, &_6$$5); zephir_check_call_status(); @@ -1002,7 +1002,7 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, setExtenders) if (!(zephir_is_callable(&extender))) { ZEPHIR_INIT_NVAR(&_10$$7); object_init_ex(&_10$$7, phalcon_container_exceptions_invalidextender_ce); - zephir_read_property_cached(&_11$$7, this_ptr, _zephir_prop_1, 549, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$7, this_ptr, _zephir_prop_1, 550, PH_NOISY_CC | PH_READONLY); zephir_cast_to_string(&_12$$7, &key); ZEPHIR_CALL_METHOD(NULL, &_10$$7, "__construct", &_7, 498, &_11$$7, &_12$$7); zephir_check_call_status(); @@ -1014,7 +1014,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_2, 558, &extenders); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 559, &extenders); RETURN_THIS(); } @@ -1047,12 +1047,12 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, setFactory) 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, &factory); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 552, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 553, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkFrozen", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 555, factory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 556, factory); RETURN_THIS(); } @@ -1087,15 +1087,15 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, setIsCacheable) 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, &isCacheable_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 552, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 553, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkFrozen", NULL, 0); zephir_check_call_status(); } if (isCacheable) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 560, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 561, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 560, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 561, &__$false); } RETURN_THIS(); } @@ -1131,12 +1131,12 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, setLifetime) 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, 552, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 553, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkFrozen", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 561, &lifetime_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 562, &lifetime_zv); RETURN_THIS(); } @@ -1165,12 +1165,12 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, unsetClass) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 552, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 553, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkFrozen", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 556, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 557, &__$null); RETURN_THIS(); } @@ -1199,14 +1199,14 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, unsetExtenders) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 552, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 553, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkFrozen", NULL, 0); zephir_check_call_status(); } ZEPHIR_INIT_VAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 558, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 559, &_1); RETURN_THIS(); } @@ -1235,12 +1235,12 @@ PHP_METHOD(Phalcon_Container_Definition_ServiceDefinition, unsetFactory) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 552, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 553, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkFrozen", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 555, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 556, &__$null); RETURN_THIS(); } @@ -1271,11 +1271,11 @@ 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, 552, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 553, 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, 549, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 550, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 499, &_2$$3); zephir_check_call_status(); zephir_throw_exception_debug(&_1$$3, "phalcon/Container/Definition/ServiceDefinition.zep", 512); diff --git a/ext/phalcon/container/resolver/lazy/arrayvalues.zep.c b/ext/phalcon/container/resolver/lazy/arrayvalues.zep.c index 0c2bc4ed87..450a17b0cf 100644 --- a/ext/phalcon/container/resolver/lazy/arrayvalues.zep.c +++ b/ext/phalcon/container/resolver/lazy/arrayvalues.zep.c @@ -103,7 +103,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, 562, &values); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 563, &values); ZEPHIR_MM_RESTORE(); } @@ -117,7 +117,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, 562, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 563, PH_NOISY_CC | PH_READONLY); RETURN_LONG(zephir_fast_count_int(&_0)); } @@ -140,7 +140,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, 562, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 563, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 19, &_0); zephir_check_call_status(); RETURN_MM(); @@ -247,7 +247,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, 562, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 563, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_key_exists(&_0, offset)); } @@ -275,7 +275,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_ArrayValues, offsetGet) 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, &offset); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 562, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 563, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_1); zephir_array_fetch(&_1, &_0, offset, PH_NOISY, "phalcon/Container/Resolver/Lazy/ArrayValues.zep", 102); RETURN_CCTOR(&_1); @@ -346,7 +346,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, 562, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 563, 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 1b35b3c92f..ca7a7699da 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, 563, callableObject); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 564, callableObject); } /** @@ -101,7 +101,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, 563, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 564, 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 d65dbd6ec8..c977332786 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, 564, id); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 565, id); } /** diff --git a/ext/phalcon/container/resolver/lazy/callablenew.zep.c b/ext/phalcon/container/resolver/lazy/callablenew.zep.c index e1427f9be9..ed78c92806 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, 565, id); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 566, id); } /** diff --git a/ext/phalcon/container/resolver/lazy/csenv.zep.c b/ext/phalcon/container/resolver/lazy/csenv.zep.c index ec3ae276f9..aa918a0e15 100644 --- a/ext/phalcon/container/resolver/lazy/csenv.zep.c +++ b/ext/phalcon/container/resolver/lazy/csenv.zep.c @@ -110,7 +110,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_CsEnv, resolve) ZVAL_STRING(&_3, "\\"); ZEPHIR_CALL_FUNCTION(&values, "str_getcsv", NULL, 500, &_0, &_1, &_2, &_3); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 566, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 567, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_4) != IS_NULL) { ZEPHIR_INIT_VAR(&result); array_init(&result); @@ -133,7 +133,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_CsEnv, resolve) } ZEPHIR_INIT_NVAR(&value); ZVAL_COPY(&value, _7$$3); - zephir_read_property_cached(&_10$$4, this_ptr, _zephir_prop_0, 566, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$4, this_ptr, _zephir_prop_0, 567, PH_NOISY_CC | PH_READONLY); ZEPHIR_MAKE_REF(&value); ZEPHIR_CALL_FUNCTION(NULL, "settype", &_11, 17, &value, &_10$$4); ZEPHIR_UNREF(&value); @@ -160,7 +160,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_CsEnv, resolve) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&value, _5$$3, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_14$$5, this_ptr, _zephir_prop_0, 566, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$5, this_ptr, _zephir_prop_0, 567, PH_NOISY_CC | PH_READONLY); ZEPHIR_MAKE_REF(&value); ZEPHIR_CALL_FUNCTION(NULL, "settype", &_11, 17, &value, &_14$$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 bb6ae85cd0..5f148e9f2d 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, 567, defaultValue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 568, 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 17bb8054fb..a7eb8f97a7 100644 --- a/ext/phalcon/container/resolver/lazy/functioncall.zep.c +++ b/ext/phalcon/container/resolver/lazy/functioncall.zep.c @@ -103,8 +103,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, 568, &functionName_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 569, &arguments); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 569, &functionName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 570, &arguments); ZEPHIR_MM_RESTORE(); } @@ -137,10 +137,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, 569, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 570, 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, 568, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 569, 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 d3af26b5bf..c52bd16414 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, 570, id); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 571, id); } /** @@ -101,7 +101,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, 570, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 571, 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 d80f521196..fa8a497637 100644 --- a/ext/phalcon/container/resolver/lazy/getcall.zep.c +++ b/ext/phalcon/container/resolver/lazy/getcall.zep.c @@ -115,9 +115,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, 571, id); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 572, &method_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 573, &arguments); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 572, id); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 573, &method_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 574, &arguments); ZEPHIR_MM_RESTORE(); } @@ -158,10 +158,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, 571, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 572, 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, 573, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 574, 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); @@ -170,7 +170,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_GetCall, resolve) zephir_create_array(&callback, 2, 0); zephir_array_fast_append(&callback, &service); zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 572, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 573, PH_NOISY_CC); zephir_array_fast_append(&callback, &_2); ZEPHIR_CALL_USER_FUNC_ARRAY(return_value, &callback, &arguments); zephir_check_call_status(); diff --git a/ext/phalcon/container/resolver/lazy/newcall.zep.c b/ext/phalcon/container/resolver/lazy/newcall.zep.c index 6a051ded1e..f8b8ba65df 100644 --- a/ext/phalcon/container/resolver/lazy/newcall.zep.c +++ b/ext/phalcon/container/resolver/lazy/newcall.zep.c @@ -115,9 +115,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, 574, id); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 575, &method_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 576, &arguments); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 575, id); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 576, &method_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 577, &arguments); ZEPHIR_MM_RESTORE(); } @@ -158,10 +158,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, 574, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 575, 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, 576, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 577, 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); @@ -170,7 +170,7 @@ PHP_METHOD(Phalcon_Container_Resolver_Lazy_NewCall, resolve) zephir_create_array(&callback, 2, 0); zephir_array_fast_append(&callback, &service); zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 575, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 576, PH_NOISY_CC); zephir_array_fast_append(&callback, &_2); ZEPHIR_CALL_USER_FUNC_ARRAY(return_value, &callback, &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 d74ae65fe1..6c001f4f02 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, 577, id); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 578, id); } /** @@ -101,7 +101,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, 577, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 578, 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 874b9648ad..b5552785f3 100644 --- a/ext/phalcon/container/resolver/lazy/staticcall.zep.c +++ b/ext/phalcon/container/resolver/lazy/staticcall.zep.c @@ -115,9 +115,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, 578, className); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 579, &method_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 580, &arguments); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 579, className); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 580, &method_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 581, &arguments); ZEPHIR_MM_RESTORE(); } @@ -157,17 +157,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, 578, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 579, 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, 580, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 581, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&arguments, this_ptr, "resolveArguments", NULL, 0, ioc, &_1); zephir_check_call_status(); ZEPHIR_INIT_VAR(&callback); zephir_create_array(&callback, 2, 0); zephir_array_fast_append(&callback, &className); zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 579, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 580, PH_NOISY_CC); zephir_array_fast_append(&callback, &_2); ZEPHIR_CALL_USER_FUNC_ARRAY(return_value, &callback, &arguments); zephir_check_call_status(); diff --git a/ext/phalcon/datamapper/pdo/connection.zep.c b/ext/phalcon/datamapper/pdo/connection.zep.c index e5dc04dbca..53792a8faa 100644 --- a/ext/phalcon/datamapper/pdo/connection.zep.c +++ b/ext/phalcon/datamapper/pdo/connection.zep.c @@ -190,7 +190,7 @@ 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, 581, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 582, &_4); if (Z_TYPE_P(profiler) == IS_NULL) { ZEPHIR_INIT_NVAR(profiler); object_init_ex(profiler, phalcon_datamapper_pdo_profiler_profiler_ce); @@ -232,7 +232,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, 581, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 582, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2); zephir_array_fetch_long(&_2, &_1, 0, PH_NOISY, "phalcon/DataMapper/Pdo/Connection.zep", 113); zephir_array_fast_append(&_0, &_2); @@ -242,11 +242,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, 581, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 582, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_2); zephir_array_fetch_long(&_2, &_4, 3, PH_NOISY, "phalcon/DataMapper/Pdo/Connection.zep", 116); zephir_array_fast_append(&_0, &_2); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 581, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 582, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_2); zephir_array_fetch_long(&_2, &_5, 4, PH_NOISY, "phalcon/DataMapper/Pdo/Connection.zep", 118); zephir_array_fast_append(&_0, &_2); @@ -300,38 +300,38 @@ 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, 582, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 583, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_INIT_VAR(&_1$$3); ZVAL_STRING(&_1$$3, "dm:beforeConnect"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireBefore", NULL, 0, &_1$$3); zephir_check_call_status(); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 583, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 584, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_1$$3); ZVAL_STRING(&_1$$3, "connect"); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "start", NULL, 0, &_1$$3); zephir_check_call_status(); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 581, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 582, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&dsn); zephir_array_fetch_long(&dsn, &_3$$3, 0, PH_NOISY, "phalcon/DataMapper/Pdo/Connection.zep", 135); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 581, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 582, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&username); zephir_array_fetch_long(&username, &_4$$3, 1, PH_NOISY, "phalcon/DataMapper/Pdo/Connection.zep", 136); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 581, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 582, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&password); zephir_array_fetch_long(&password, &_5$$3, 2, PH_NOISY, "phalcon/DataMapper/Pdo/Connection.zep", 137); - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_2, 581, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_2, 582, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&options); zephir_array_fetch_long(&options, &_6$$3, 3, PH_NOISY, "phalcon/DataMapper/Pdo/Connection.zep", 138); - zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_2, 581, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_2, 582, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&queries); zephir_array_fetch_long(&queries, &_7$$3, 4, PH_NOISY, "phalcon/DataMapper/Pdo/Connection.zep", 139); ZEPHIR_INIT_NVAR(&_1$$3); object_init_ex(&_1$$3, php_pdo_get_dbh_ce()); ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 0, &dsn, &username, &password, &options); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 582, &_1$$3); - zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_1, 583, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 583, &_1$$3); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_1, 584, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_8$$3, "finish", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_9$$3); @@ -414,13 +414,13 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Connection, disconnect) ZVAL_STRING(&_0, "dm:beforeDisconnect"); ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireBefore", NULL, 0, &_0); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 583, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 584, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "disconnect"); ZEPHIR_CALL_METHOD(NULL, &_1, "start", NULL, 0, &_0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 582, &__$null); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 583, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 583, &__$null); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 584, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_2, "finish", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_0); diff --git a/ext/phalcon/datamapper/pdo/connection/decorated.zep.c b/ext/phalcon/datamapper/pdo/connection/decorated.zep.c index 2a52563ba7..2b654788b3 100644 --- a/ext/phalcon/datamapper/pdo/connection/decorated.zep.c +++ b/ext/phalcon/datamapper/pdo/connection/decorated.zep.c @@ -84,7 +84,7 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Connection_Decorated, __construct) } else { ZEPHIR_SEPARATE_PARAM(profiler); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 584, pdo); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 585, pdo); if (Z_TYPE_P(profiler) == IS_NULL) { ZEPHIR_INIT_NVAR(profiler); object_init_ex(profiler, phalcon_datamapper_pdo_profiler_profiler_ce); diff --git a/ext/phalcon/datamapper/pdo/connectionlocator.zep.c b/ext/phalcon/datamapper/pdo/connectionlocator.zep.c index 3cd6233fcf..a458bd0972 100644 --- a/ext/phalcon/datamapper/pdo/connectionlocator.zep.c +++ b/ext/phalcon/datamapper/pdo/connectionlocator.zep.c @@ -248,7 +248,7 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_ConnectionLocator, getMaster) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 585, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 586, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "applyEventsManager", NULL, 0, &_0); zephir_check_call_status(); RETURN_MM(); @@ -358,7 +358,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, 585, callableObject); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 586, callableObject); RETURN_THISW(); } @@ -475,7 +475,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, 586, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 587, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&instances, &_0); if (ZEPHIR_IS_EMPTY(&collection)) { ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getMaster", NULL, 0); @@ -508,7 +508,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, 586, &instances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 587, &instances); } zephir_memory_observe(&_6); zephir_array_fetch(&_6, &instances, &instanceName, PH_NOISY, "phalcon/DataMapper/Pdo/ConnectionLocator.zep", 249); @@ -548,13 +548,13 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_ConnectionLocator, applyEventsManager) 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, 587, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 588, PH_NOISY_CC | PH_READONLY); _1 = Z_TYPE_P(&_0) != IS_NULL; if (_1) { _1 = zephir_instance_of_ev(connection, phalcon_contracts_events_eventsaware_ce); } if (_1) { - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 587, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 588, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, connection, "setEventsManager", NULL, 0, &_2$$3); zephir_check_call_status(); } @@ -611,19 +611,19 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_ConnectionLocator, setEventsManager) _2 = ZEPHIR_IS_TRUE_IDENTICAL(&_1); if (_2) { zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 588, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 589, PH_NOISY_CC); _2 = Z_TYPE_P(&_3) != IS_NULL; } if (_2) { zephir_memory_observe(&_4$$3); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 588, PH_NOISY_CC); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 589, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_5$$3); ZVAL_STRING(&_5$$3, "eventsManager"); ZVAL_BOOL(&_6$$3, 1); ZEPHIR_CALL_METHOD(NULL, &_4$$3, "set", NULL, 0, &_5$$3, eventsManager, &_6$$3); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 587, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 588, eventsManager); ZEPHIR_MM_RESTORE(); } @@ -689,16 +689,16 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_ConnectionLocator, fireManagerEvent) stopOnFalse = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 587, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 588, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { _1$$3 = stopOnFalse; if (_1$$3) { zephir_memory_observe(&_2$$3); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 587, PH_NOISY_CC); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 588, PH_NOISY_CC); _1$$3 = zephir_instance_of_ev(&_2$$3, phalcon_events_manager_ce); } if (_1$$3) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 587, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 588, PH_NOISY_CC | PH_READONLY); if (cancellable) { ZVAL_BOOL(&_4$$4, 1); } else { @@ -709,7 +709,7 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_ConnectionLocator, fireManagerEvent) zephir_check_call_status(); RETURN_MM(); } - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 587, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 588, PH_NOISY_CC | PH_READONLY); if (cancellable) { ZVAL_BOOL(&_7$$3, 1); } else { diff --git a/ext/phalcon/datamapper/pdo/profiler/profiler.zep.c b/ext/phalcon/datamapper/pdo/profiler/profiler.zep.c index a8ff78d5aa..95127bbdf2 100644 --- a/ext/phalcon/datamapper/pdo/profiler/profiler.zep.c +++ b/ext/phalcon/datamapper/pdo/profiler/profiler.zep.c @@ -133,11 +133,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, 589, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 590, &_0); ZVAL_UNDEF(&_1); ZVAL_LONG(&_1, 7); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 590, &_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 591, logger); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 591, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 592, logger); ZEPHIR_INIT_NVAR(&_0); object_init_ex(&_0, phalcon_support_helper_json_encode_ce); if (zephir_has_constructor(&_0)) { @@ -145,7 +145,7 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Profiler_Profiler, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 592, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 593, &_0); ZEPHIR_MM_RESTORE(); } @@ -235,7 +235,7 @@ 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, 593, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 594, 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); @@ -243,7 +243,7 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Profiler_Profiler, finish) zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&finish, "hrtime", NULL, 0, &__$true); zephir_check_call_status(); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 594, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 595, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&start); zephir_array_fetch_string(&start, &_1$$3, SL("start"), PH_NOISY, "phalcon/DataMapper/Pdo/Profiler/Profiler.zep", 96); ZEPHIR_CALL_METHOD(&_2$$3, &ex, "getTraceAsString", NULL, 0); @@ -267,22 +267,22 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Profiler_Profiler, finish) ZEPHIR_INIT_NVAR(&_4$$3); ZVAL_STRING(&_4$$3, ""); } else { - zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_2, 592, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_2, 593, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_4$$3, &_8$$3, "__invoke", NULL, 0, &values); zephir_check_call_status(); } ZEPHIR_INIT_VAR(&_9$$3); ZVAL_STRING(&_9$$3, "values"); zephir_update_property_array(this_ptr, SL("context"), &_9$$3, &_4$$3); - zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_3, 591, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_4, 590, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_12$$3, this_ptr, _zephir_prop_5, 589, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_13$$3, this_ptr, _zephir_prop_1, 594, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_3, 592, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_4, 591, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$3, this_ptr, _zephir_prop_5, 590, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$3, this_ptr, _zephir_prop_1, 595, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_10$$3, "log", NULL, 0, &_11$$3, &_12$$3, &_13$$3); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_14$$3); array_init(&_14$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 594, &_14$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 595, &_14$$3); } ZEPHIR_MM_RESTORE(); } @@ -331,7 +331,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, 590, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 591, PH_NOISY_CC); zephir_cast_to_string(&_1, &_0); RETURN_CTOR(&_1); } @@ -372,9 +372,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, 593, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 594, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 593, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 594, &__$false); } RETURN_THISW(); } @@ -402,7 +402,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, 589, &logFormat_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 590, &logFormat_zv); RETURN_THISW(); } @@ -429,7 +429,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, 590, &logLevel_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 591, &logLevel_zv); RETURN_THISW(); } @@ -468,7 +468,7 @@ 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, 593, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 594, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(zephir_is_true(&_0))) { ZEPHIR_INIT_VAR(&_1$$3); zephir_create_array(&_1$$3, 2, 0); @@ -476,7 +476,7 @@ PHP_METHOD(Phalcon_DataMapper_Pdo_Profiler_Profiler, start) ZEPHIR_CALL_FUNCTION(&_2$$3, "hrtime", NULL, 0, &__$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, 594, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 595, &_1$$3); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/datamapper/query/bind.zep.c b/ext/phalcon/datamapper/query/bind.zep.c index d4fb86fc7b..aaae3bf68b 100644 --- a/ext/phalcon/datamapper/query/bind.zep.c +++ b/ext/phalcon/datamapper/query/bind.zep.c @@ -118,13 +118,13 @@ PHP_METHOD(Phalcon_DataMapper_Query_Bind, bindInline) zephir_check_call_status(); RETURN_MM(); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 595, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 596, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_4); ZVAL_LONG(&_4, 1); ZEPHIR_INIT_VAR(&_5); zephir_add_function(&_5, &_3, &_4); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 595, &_5); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 595, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 596, &_5); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 596, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&key); ZEPHIR_CONCAT_SVS(&key, "__", &_3, "__"); ZVAL_LONG(&_6, type); @@ -159,10 +159,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, 596, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 597, 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, 596, &store); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 597, &store); ZEPHIR_MM_RESTORE(); } @@ -383,13 +383,13 @@ 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, 595, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 596, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_2$$3); ZVAL_LONG(&_2$$3, 1); ZEPHIR_INIT_NVAR(&_3$$3); zephir_add_function(&_3$$3, &_1$$3, &_2$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 595, &_3$$3); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 595, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 596, &_3$$3); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 596, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&key); ZEPHIR_CONCAT_SVS(&key, "__", &_1$$3, "__"); ZVAL_LONG(&_4$$3, type); @@ -417,13 +417,13 @@ PHP_METHOD(Phalcon_DataMapper_Query_Bind, inlineArray) } ZEPHIR_CALL_METHOD(&value, &data, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 595, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 596, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_10$$4); ZVAL_LONG(&_10$$4, 1); ZEPHIR_INIT_NVAR(&_11$$4); zephir_add_function(&_11$$4, &_9$$4, &_10$$4); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 595, &_11$$4); - zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 595, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 596, &_11$$4); + zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 596, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&key); ZEPHIR_CONCAT_SVS(&key, "__", &_9$$4, "__"); ZVAL_LONG(&_12$$4, type); diff --git a/ext/phalcon/datamapper/query/delete.zep.c b/ext/phalcon/datamapper/query/delete.zep.c index 1205840d14..f808b6d14f 100644 --- a/ext/phalcon/datamapper/query/delete.zep.c +++ b/ext/phalcon/datamapper/query/delete.zep.c @@ -133,7 +133,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, 597, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 598, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2); zephir_array_fetch_string(&_2, &_1, SL("FROM"), PH_NOISY, "phalcon/DataMapper/Query/Delete.zep", 57); ZEPHIR_INIT_VAR(&_4); @@ -208,7 +208,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, 597, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 598, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2); zephir_array_fetch_string(&_2, &_1, SL("RETURNING"), PH_NOISY, "phalcon/DataMapper/Query/Delete.zep", 80); zephir_fast_array_merge(&_0, &_2, &columns); diff --git a/ext/phalcon/datamapper/query/insert.zep.c b/ext/phalcon/datamapper/query/insert.zep.c index 1bf4609499..774bf61a27 100644 --- a/ext/phalcon/datamapper/query/insert.zep.c +++ b/ext/phalcon/datamapper/query/insert.zep.c @@ -140,7 +140,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, 598, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 599, 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(); @@ -261,7 +261,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, 599, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 600, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "lastInsertId", NULL, 0, &name_zv); zephir_check_call_status(); RETURN_MM(); @@ -288,7 +288,7 @@ 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, 600, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 601, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2); zephir_array_fetch_string(&_2, &_1, SL("FROM"), PH_NOISY, "phalcon/DataMapper/Query/Insert.zep", 90); ZEPHIR_CALL_METHOD(&_3, this_ptr, "buildColumns", NULL, 0); @@ -386,7 +386,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, 600, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 601, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2); zephir_array_fetch_string(&_2, &_1, SL("RETURNING"), PH_NOISY, "phalcon/DataMapper/Query/Insert.zep", 123); zephir_fast_array_merge(&_0, &_2, &columns); @@ -442,7 +442,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, 598, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 599, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "remove", NULL, 0, &column_zv); zephir_check_call_status(); RETURN_THIS(); @@ -489,7 +489,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, 600, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 601, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_1); zephir_array_fetch_string(&_1, &_0, SL("COLUMNS"), PH_NOISY, "phalcon/DataMapper/Query/Insert.zep", 156); if (Z_TYPE_P(&_1) == IS_STRING) { @@ -550,7 +550,7 @@ PHP_METHOD(Phalcon_DataMapper_Query_Insert, buildColumns) zephir_check_call_status(); zephir_fast_trim(&_13, &_14, NULL , ZEPHIR_TRIM_LEFT); ZEPHIR_INIT_NVAR(&_15); - zephir_read_property_cached(&_17, this_ptr, _zephir_prop_0, 600, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17, this_ptr, _zephir_prop_0, 601, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_18); zephir_array_fetch_string(&_18, &_17, SL("COLUMNS"), PH_NOISY, "phalcon/DataMapper/Query/Insert.zep", 163); ZEPHIR_CALL_FUNCTION(&_19, "array_values", NULL, 27, &_18); diff --git a/ext/phalcon/datamapper/query/queryfactory.zep.c b/ext/phalcon/datamapper/query/queryfactory.zep.c index 2021e55ea3..d44b04aeef 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, 601, &selectClass); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 602, &selectClass); ZEPHIR_MM_RESTORE(); } @@ -183,7 +183,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, 601, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 602, 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); diff --git a/ext/phalcon/datamapper/query/select.zep.c b/ext/phalcon/datamapper/query/select.zep.c index a2e8c39002..3383b567f1 100644 --- a/ext/phalcon/datamapper/query/select.zep.c +++ b/ext/phalcon/datamapper/query/select.zep.c @@ -141,7 +141,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, 602, PH_NOISY_CC); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 603, PH_NOISY_CC); zephir_array_fast_append(&_0$$3, &_1$$3); zephir_array_fast_append(&_0$$3, &method_zv); ZEPHIR_INIT_VAR(&_2$$3); @@ -320,25 +320,25 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, appendJoin) } else { } if (!(ZEPHIR_IS_EMPTY(value))) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 603, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 604, 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, 604, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 605, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_4); zephir_array_fetch_string(&_4, &_3, SL("FROM"), PH_NOISY, "phalcon/DataMapper/Query/Select.zep", 137); ZEPHIR_CALL_FUNCTION(&end, "array_key_last", NULL, 20, &_4); zephir_check_call_status(); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 604, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 605, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_6); zephir_array_fetch_string(&_6, &_5, SL("FROM"), PH_NOISY, "phalcon/DataMapper/Query/Select.zep", 138); zephir_memory_observe(&_7); zephir_array_fetch(&_7, &_6, &end, PH_NOISY, "phalcon/DataMapper/Query/Select.zep", 138); ZEPHIR_CALL_FUNCTION(&key, "array_key_last", NULL, 20, &_7); zephir_check_call_status(); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 604, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 605, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_9); zephir_array_fetch_string(&_9, &_8, SL("FROM"), PH_NOISY, "phalcon/DataMapper/Query/Select.zep", 140); zephir_memory_observe(&_10); @@ -370,7 +370,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, 605, &asAlias_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 606, &asAlias_zv); RETURN_THISW(); } @@ -468,7 +468,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, 604, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 605, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_9); zephir_array_fetch_string(&_9, &_8, SL("COLUMNS"), PH_NOISY, "phalcon/DataMapper/Query/Select.zep", 175); zephir_fast_array_merge(&_7, &_9, &localColumns); @@ -537,9 +537,9 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, forUpdate) } else { } if (enable) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 606, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 607, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 606, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 607, &__$false); } RETURN_THISW(); } @@ -593,7 +593,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, 604, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 605, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2); zephir_array_fetch_string(&_2, &_1, SL("UNION"), PH_NOISY, "phalcon/DataMapper/Query/Select.zep", 214); zephir_fast_join_str(&_0, SL(""), &_2); @@ -643,7 +643,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, 604, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 605, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(!(zephir_isempty_dim_string(&_0, SL("COLUMNS")))); } @@ -819,13 +819,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, 603, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$5, this_ptr, _zephir_prop_0, 604, 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, 604, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19, this_ptr, _zephir_prop_1, 605, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_20); zephir_array_fetch_string(&_20, &_19, SL("FROM"), PH_NOISY, "phalcon/DataMapper/Query/Select.zep", 281); ZEPHIR_CALL_FUNCTION(&key, "array_key_last", NULL, 20, &_20); @@ -917,11 +917,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, 605, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 606, &_0); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 606, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 607, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 606, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 607, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -950,8 +950,8 @@ 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, 602, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 603, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 603, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 604, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &_0, &_1); zephir_check_call_status(); RETURN_MM(); @@ -1062,7 +1062,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, 606, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 607, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_INIT_NVAR(&forUpdate); ZVAL_STRING(&forUpdate, " FOR UPDATE"); @@ -1095,11 +1095,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, 605, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11, this_ptr, _zephir_prop_1, 606, 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, 605, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_1, 606, 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); @@ -1139,7 +1139,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, 604, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 605, 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", 385); } @@ -1187,11 +1187,11 @@ PHP_METHOD(Phalcon_DataMapper_Query_Select, buildFrom) ZEPHIR_INIT_VAR(&from); array_init(&from); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 604, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 605, PH_NOISY_CC | PH_READONLY); if (zephir_isempty_dim_string(&_0, SL("FROM"))) { RETURN_MM_STRING(""); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 604, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 605, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2); zephir_array_fetch_string(&_2, &_1, SL("FROM"), PH_NOISY, "phalcon/DataMapper/Query/Select.zep", 403); if (Z_TYPE_P(&_2) == IS_STRING) { diff --git a/ext/phalcon/datamapper/query/update.zep.c b/ext/phalcon/datamapper/query/update.zep.c index 4b4f0b3ceb..8aa2711b4b 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, 607, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 608, 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(); @@ -278,7 +278,7 @@ 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, 608, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 609, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2); zephir_array_fetch_string(&_2, &_1, SL("FROM"), PH_NOISY, "phalcon/DataMapper/Query/Update.zep", 92); ZEPHIR_CALL_METHOD(&_3, this_ptr, "buildColumns", NULL, 0); @@ -306,7 +306,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, 608, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 609, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(!(zephir_isempty_dim_string(&_0, SL("COLUMNS")))); } @@ -372,7 +372,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, 608, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 609, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2); zephir_array_fetch_string(&_2, &_1, SL("RETURNING"), PH_NOISY, "phalcon/DataMapper/Query/Update.zep", 124); zephir_fast_array_merge(&_0, &_2, &columns); @@ -428,7 +428,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, 607, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 608, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "remove", NULL, 0, &column_zv); zephir_check_call_status(); RETURN_THIS(); @@ -471,7 +471,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, 608, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 609, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_1); zephir_array_fetch_string(&_1, &_0, SL("COLUMNS"), PH_NOISY, "phalcon/DataMapper/Query/Update.zep", 157); if (Z_TYPE_P(&_1) == IS_STRING) { diff --git a/ext/phalcon/db/adapter/pdo/mysql.zep.c b/ext/phalcon/db/adapter/pdo/mysql.zep.c index e65b1cf79e..deaeae4e8f 100644 --- a/ext/phalcon/db/adapter/pdo/mysql.zep.c +++ b/ext/phalcon/db/adapter/pdo/mysql.zep.c @@ -106,7 +106,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, 609, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 610, 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); @@ -122,7 +122,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, addForeignKey) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 609, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 610, 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); @@ -337,13 +337,13 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeColumns) array_init(&columns); ZEPHIR_INIT_VAR(&definition); array_init(&definition); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 609, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 610, 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); ZEPHIR_CALL_METHOD(&fields, this_ptr, "fetchAll", NULL, 0, &_1, &_2); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 610, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 611, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_4, 4); ZEPHIR_CALL_METHOD(&_3, &_2, "getAttribute", NULL, 0, &_4); zephir_check_call_status(); @@ -1259,7 +1259,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeIndexes) array_init(&indexes); ZEPHIR_INIT_VAR(&indexObjects); array_init(&indexObjects); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 609, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 610, 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); @@ -1647,7 +1647,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeReferences) array_init(&references); ZEPHIR_INIT_VAR(&referenceObjects); array_init(&referenceObjects); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 609, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 610, 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 42f77b8f23..8d226f52a3 100644 --- a/ext/phalcon/db/adapter/pdo/postgresql.zep.c +++ b/ext/phalcon/db/adapter/pdo/postgresql.zep.c @@ -143,7 +143,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, 611, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 612, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&descriptor, &_0$$3); } zephir_memory_observe(&schema); @@ -247,7 +247,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, createTable) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 612, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 613, 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); @@ -507,7 +507,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, 612, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 613, 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); @@ -1414,7 +1414,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, 612, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 613, 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); @@ -1699,7 +1699,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, modifyColumn) currentColumn = ¤tColumn_sub; currentColumn = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 612, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 613, 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 0303993d9f..7091ff69a4 100644 --- a/ext/phalcon/db/adapter/pdo/sqlite.zep.c +++ b/ext/phalcon/db/adapter/pdo/sqlite.zep.c @@ -129,7 +129,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, 613, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 614, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&descriptor, &_0$$3); } zephir_memory_observe(&dbname); @@ -293,7 +293,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, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 615, 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); @@ -806,7 +806,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, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 615, 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); @@ -841,7 +841,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeIndexes) ZEPHIR_OBS_NVAR(&columns); zephir_array_fetch_string(&columns, &_9$$6, SL("columns"), PH_NOISY, "phalcon/Db/Adapter/Pdo/Sqlite.zep", 360); } - zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 615, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_11$$3, &_10$$3, "describeIndex", NULL, 0, &keyName); zephir_check_call_status(); ZVAL_LONG(&_12$$3, 2); @@ -889,7 +889,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(&_12$$3, this_ptr, _zephir_prop_0, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$3, this_ptr, _zephir_prop_0, 615, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_20$$3, &_12$$3, "listIndexesSql", NULL, 0, &table_zv, &schema_zv, &keyName); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&indexSql, this_ptr, "fetchColumn", &_21, 0, &_20$$3); @@ -953,7 +953,7 @@ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeIndexes) ZEPHIR_OBS_NVAR(&columns); zephir_array_fetch_string(&columns, &_34$$16, SL("columns"), PH_NOISY, "phalcon/Db/Adapter/Pdo/Sqlite.zep", 360); } - zephir_read_property_cached(&_35$$13, this_ptr, _zephir_prop_0, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_35$$13, this_ptr, _zephir_prop_0, 615, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_36$$13, &_35$$13, "describeIndex", NULL, 0, &keyName); zephir_check_call_status(); ZVAL_LONG(&_37$$13, 2); @@ -1001,7 +1001,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(&_37$$13, this_ptr, _zephir_prop_0, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_37$$13, this_ptr, _zephir_prop_0, 615, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_45$$13, &_37$$13, "listIndexesSql", NULL, 0, &table_zv, &schema_zv, &keyName); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&indexSql, this_ptr, "fetchColumn", &_21, 0, &_45$$13); @@ -1143,7 +1143,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, 614, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 615, 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 118f35c687..2eb8d85a94 100644 --- a/ext/phalcon/db/check.zep.c +++ b/ext/phalcon/db/check.zep.c @@ -144,8 +144,8 @@ PHP_METHOD(Phalcon_Db_Check, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 615, &name_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 616, &expression); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 616, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 617, &expression); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/db/column.zep.c b/ext/phalcon/db/column.zep.c index 1bfacc6a5a..1d5a92afe2 100644 --- a/ext/phalcon/db/column.zep.c +++ b/ext/phalcon/db/column.zep.c @@ -715,7 +715,7 @@ 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, 617, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 618, &name_zv); zephir_memory_observe(&type); if (UNEXPECTED(!(zephir_array_isset_string_fetch(&type, &definition, SL("type"), 0)))) { ZEPHIR_INIT_VAR(&_0$$3); @@ -726,26 +726,26 @@ PHP_METHOD(Phalcon_Db_Column, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 618, &type); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 619, &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, 619, &typeReference); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 620, &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, 620, &typeValues); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 621, &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, 621, ¬Null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 622, ¬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, 622, &primary); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 623, &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, 623, &size); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 624, &size); } zephir_memory_observe(&scale); if (zephir_array_isset_string_fetch(&scale, &definition, SL("scale"), 0)) { @@ -766,7 +766,7 @@ PHP_METHOD(Phalcon_Db_Column, __construct) zephir_switch_0_clause_5: ; zephir_switch_0_clause_6: ; zephir_switch_0_clause_7: ; - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 624, &scale); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 625, &scale); goto zephir_switch_0_end; zephir_switch_0_clause_8: ; ZEPHIR_INIT_VAR(&_1$$11); @@ -781,23 +781,23 @@ 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, 625, &defaultValue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 626, &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, 626, &dunsigned); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 627, &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, 627, &isNumeric); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 628, &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, 628, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 629, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 628, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 629, &__$false); } } else { if (ZEPHIR_IS_LONG(&type, 14)) { goto zephir_switch_1_clause_0; } @@ -812,9 +812,9 @@ PHP_METHOD(Phalcon_Db_Column, __construct) zephir_switch_1_clause_3: ; zephir_switch_1_clause_4: ; if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 628, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 629, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 628, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 629, &__$false); } goto zephir_switch_1_end; zephir_switch_1_clause_5: ; @@ -831,19 +831,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, 629, &first); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_12, 630, &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, 630, &after); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 631, &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, 631, &bindType); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_14, 632, &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, 632, &comment); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_15, 633, &comment); } zephir_memory_observe(&generated); if (zephir_array_isset_string_fetch(&generated, &definition, SL("generated"), 0)) { @@ -857,7 +857,7 @@ PHP_METHOD(Phalcon_Db_Column, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_4$$25, this_ptr, _zephir_prop_11, 628, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$25, this_ptr, _zephir_prop_11, 629, 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); @@ -867,7 +867,7 @@ PHP_METHOD(Phalcon_Db_Column, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_6$$25, this_ptr, _zephir_prop_8, 625, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$25, this_ptr, _zephir_prop_8, 626, 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); @@ -877,31 +877,31 @@ PHP_METHOD(Phalcon_Db_Column, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_16, 633, &generated); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_16, 634, &generated); } } zephir_memory_observe(&generationStored); if (zephir_array_isset_string_fetch(&generationStored, &definition, SL("generationStored"), 0)) { if (zephir_get_boolval(&generationStored)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 634, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 635, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 634, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 635, &__$false); } } zephir_memory_observe(&invisible); if (zephir_array_isset_string_fetch(&invisible, &definition, SL("invisible"), 0)) { if (zephir_get_boolval(&invisible)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_18, 635, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_18, 636, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_18, 635, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_18, 636, &__$false); } } zephir_memory_observe(&isArray); if (zephir_array_isset_string_fetch(&isArray, &definition, SL("array"), 0)) { if (zephir_get_boolval(&isArray)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 636, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 637, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 636, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 637, &__$false); } } ZEPHIR_MM_RESTORE(); @@ -1033,7 +1033,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, 625, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 626, PH_NOISY_CC | PH_READONLY); RETURN_MM_BOOL(Z_TYPE_P(&_1) != IS_NULL); } @@ -1079,7 +1079,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, 633, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 634, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(Z_TYPE_P(&_0) != IS_NULL); } diff --git a/ext/phalcon/db/geometry/geometrycollection.zep.c b/ext/phalcon/db/geometry/geometrycollection.zep.c index 5d0f412cb9..a295bfc6d5 100644 --- a/ext/phalcon/db/geometry/geometrycollection.zep.c +++ b/ext/phalcon/db/geometry/geometrycollection.zep.c @@ -77,10 +77,10 @@ PHP_METHOD(Phalcon_Db_Geometry_GeometryCollection, __construct) srid = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 637, &geometries); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 638, &geometries); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 638, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 639, &_0); ZEPHIR_MM_RESTORE(); } @@ -124,7 +124,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, 637, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 638, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); diff --git a/ext/phalcon/db/geometry/linestring.zep.c b/ext/phalcon/db/geometry/linestring.zep.c index fb84d527c8..60606fd1cf 100644 --- a/ext/phalcon/db/geometry/linestring.zep.c +++ b/ext/phalcon/db/geometry/linestring.zep.c @@ -77,10 +77,10 @@ PHP_METHOD(Phalcon_Db_Geometry_LineString, __construct) srid = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 639, &points); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 640, &points); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 640, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 641, &_0); ZEPHIR_MM_RESTORE(); } @@ -140,7 +140,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, 639, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 640, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); diff --git a/ext/phalcon/db/geometry/multilinestring.zep.c b/ext/phalcon/db/geometry/multilinestring.zep.c index 8dc3b6b75a..39a981c3cf 100644 --- a/ext/phalcon/db/geometry/multilinestring.zep.c +++ b/ext/phalcon/db/geometry/multilinestring.zep.c @@ -77,10 +77,10 @@ PHP_METHOD(Phalcon_Db_Geometry_MultiLineString, __construct) srid = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 641, &lineStrings); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 642, &lineStrings); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 642, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 643, &_0); ZEPHIR_MM_RESTORE(); } @@ -126,7 +126,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, 641, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 642, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); diff --git a/ext/phalcon/db/geometry/multipoint.zep.c b/ext/phalcon/db/geometry/multipoint.zep.c index 7f5d5c41c7..edeb31a112 100644 --- a/ext/phalcon/db/geometry/multipoint.zep.c +++ b/ext/phalcon/db/geometry/multipoint.zep.c @@ -77,10 +77,10 @@ PHP_METHOD(Phalcon_Db_Geometry_MultiPoint, __construct) srid = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 643, &points); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 644, &points); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 644, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 645, &_0); ZEPHIR_MM_RESTORE(); } @@ -124,7 +124,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, 643, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 644, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); diff --git a/ext/phalcon/db/geometry/multipolygon.zep.c b/ext/phalcon/db/geometry/multipolygon.zep.c index ff48362d0b..a1d9412d31 100644 --- a/ext/phalcon/db/geometry/multipolygon.zep.c +++ b/ext/phalcon/db/geometry/multipolygon.zep.c @@ -77,10 +77,10 @@ PHP_METHOD(Phalcon_Db_Geometry_MultiPolygon, __construct) srid = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 645, &polygons); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 646, &polygons); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 646, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 647, &_0); ZEPHIR_MM_RESTORE(); } @@ -126,7 +126,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, 645, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 646, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); diff --git a/ext/phalcon/db/geometry/point.zep.c b/ext/phalcon/db/geometry/point.zep.c index dfeae65bf5..b6aa5d6702 100644 --- a/ext/phalcon/db/geometry/point.zep.c +++ b/ext/phalcon/db/geometry/point.zep.c @@ -76,13 +76,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, 647, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 648, &_0); ZVAL_UNDEF(&_0); ZVAL_DOUBLE(&_0, y); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 648, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 649, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 649, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 650, &_0); } PHP_METHOD(Phalcon_Db_Geometry_Point, getType) @@ -135,8 +135,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, 647, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 648, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 648, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 649, 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 57a92591fd..97e5dc0f8e 100644 --- a/ext/phalcon/db/geometry/polygon.zep.c +++ b/ext/phalcon/db/geometry/polygon.zep.c @@ -77,10 +77,10 @@ PHP_METHOD(Phalcon_Db_Geometry_Polygon, __construct) srid = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 650, &rings); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 651, &rings); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, srid); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 651, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 652, &_0); ZEPHIR_MM_RESTORE(); } @@ -152,7 +152,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, 650, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 651, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); diff --git a/ext/phalcon/db/geometry/wkbparser.zep.c b/ext/phalcon/db/geometry/wkbparser.zep.c index 9e7fd36f4a..5064ad428a 100644 --- a/ext/phalcon/db/geometry/wkbparser.zep.c +++ b/ext/phalcon/db/geometry/wkbparser.zep.c @@ -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, 652, &body); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 653, &body); ZVAL_UNDEF(&_8); ZVAL_LONG(&_8, zephir_fast_strlen_ev(&body)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 653, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 654, &_8); ZVAL_UNDEF(&_8); ZVAL_LONG(&_8, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 654, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 655, &_8); ZVAL_LONG(&_8, srid); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "readGeometry", NULL, 0, &_8); zephir_check_call_status(); @@ -659,18 +659,18 @@ 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, 654, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 655, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_LONG(&_1, 1); ZEPHIR_INIT_VAR(&_2); zephir_add_function(&_2, &_0, &_1); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 653, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 654, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_GT(&_2, &_0)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exceptions_invalidwkb_ce, "truncated buffer", "phalcon/Db/Geometry/WkbParser.zep", 221); return; } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 652, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 654, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 653, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 655, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_5, 1); ZEPHIR_INIT_VAR(&_6); zephir_substr(&_6, &_3, zephir_get_intval(&_4), 1 , 0); @@ -678,12 +678,12 @@ PHP_METHOD(Phalcon_Db_Geometry_WkbParser, readByte) ZVAL_STRING(&_7, "C"); ZEPHIR_CALL_FUNCTION(&arr, "unpack", NULL, 0, &_7, &_6); zephir_check_call_status(); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 654, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 655, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_1); ZVAL_LONG(&_1, 1); ZEPHIR_INIT_VAR(&_9); zephir_add_function(&_9, &_8, &_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 654, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 655, &_9); zephir_memory_observe(&_10); zephir_array_fetch_long(&_10, &arr, 1, PH_NOISY, "phalcon/Db/Geometry/WkbParser.zep", 227); RETURN_MM_LONG(zephir_get_intval(&_10)); @@ -728,12 +728,12 @@ 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, 654, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 655, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_LONG(&_1, 4); ZEPHIR_INIT_VAR(&_2); zephir_add_function(&_2, &_0, &_1); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 653, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 654, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_GT(&_2, &_0)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exceptions_invalidwkb_ce, "truncated buffer", "phalcon/Db/Geometry/WkbParser.zep", 235); return; @@ -745,19 +745,19 @@ PHP_METHOD(Phalcon_Db_Geometry_WkbParser, readUint32) ZEPHIR_INIT_NVAR(&fmt); ZVAL_STRING(&fmt, "N"); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 652, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 654, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 653, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 655, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_5, 4); ZEPHIR_INIT_VAR(&_6); zephir_substr(&_6, &_3, zephir_get_intval(&_4), 4 , 0); ZEPHIR_CALL_FUNCTION(&arr, "unpack", NULL, 0, &fmt, &_6); zephir_check_call_status(); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 654, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 655, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_1); ZVAL_LONG(&_1, 4); ZEPHIR_INIT_VAR(&_8); zephir_add_function(&_8, &_7, &_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 654, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 655, &_8); zephir_memory_observe(&_9); zephir_array_fetch_long(&_9, &arr, 1, PH_NOISY, "phalcon/Db/Geometry/WkbParser.zep", 242); RETURN_MM_LONG(zephir_get_intval(&_9)); @@ -802,12 +802,12 @@ 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, 654, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 655, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_LONG(&_1, 8); ZEPHIR_INIT_VAR(&_2); zephir_add_function(&_2, &_0, &_1); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 653, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 654, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_GT(&_2, &_0)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exceptions_invalidwkb_ce, "truncated buffer", "phalcon/Db/Geometry/WkbParser.zep", 250); return; @@ -819,19 +819,19 @@ PHP_METHOD(Phalcon_Db_Geometry_WkbParser, readDouble) ZEPHIR_INIT_NVAR(&fmt); ZVAL_STRING(&fmt, "E"); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 652, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 654, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 653, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 655, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_5, 8); ZEPHIR_INIT_VAR(&_6); zephir_substr(&_6, &_3, zephir_get_intval(&_4), 8 , 0); ZEPHIR_CALL_FUNCTION(&arr, "unpack", NULL, 0, &fmt, &_6); zephir_check_call_status(); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 654, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 655, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_1); ZVAL_LONG(&_1, 8); ZEPHIR_INIT_VAR(&_8); zephir_add_function(&_8, &_7, &_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 654, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 655, &_8); zephir_memory_observe(&_9); zephir_array_fetch_long(&_9, &arr, 1, PH_NOISY, "phalcon/Db/Geometry/WkbParser.zep", 257); RETURN_MM_DOUBLE(zephir_get_doubleval(&_9)); diff --git a/ext/phalcon/db/index.zep.c b/ext/phalcon/db/index.zep.c index 3f715e5f6e..337efd308c 100644 --- a/ext/phalcon/db/index.zep.c +++ b/ext/phalcon/db/index.zep.c @@ -229,7 +229,7 @@ PHP_METHOD(Phalcon_Db_Index, __construct) zephir_memory_observe(&type_zv); ZVAL_STR_COPY(&type_zv, type); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 655, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 656, &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", 150); @@ -243,18 +243,18 @@ PHP_METHOD(Phalcon_Db_Index, __construct) return; } zephir_array_fetch_string(&_2$$3, &columnsOrDefinition, SL("columns"), PH_NOISY | PH_READONLY, "phalcon/Db/Index.zep", 154); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 656, &_2$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 657, &_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, 657, &_3$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 658, &_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, 658, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 659, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 658, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 659, &__$false); } } zephir_memory_observe(&directions); @@ -268,7 +268,7 @@ PHP_METHOD(Phalcon_Db_Index, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 659, &directions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 660, &directions); } zephir_memory_observe(&where); if (zephir_array_isset_string_fetch(&where, &columnsOrDefinition, SL("where"), 0)) { @@ -281,19 +281,19 @@ PHP_METHOD(Phalcon_Db_Index, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 660, &where); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 661, &where); } zephir_memory_observe(&concurrent); if (zephir_array_isset_string_fetch(&concurrent, &columnsOrDefinition, SL("concurrently"), 0)) { if (zephir_get_boolval(&concurrent)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 661, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 662, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 661, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 662, &__$false); } } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 656, &columnsOrDefinition); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 657, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 657, &columnsOrDefinition); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 658, &type_zv); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/db/profiler.zep.c b/ext/phalcon/db/profiler.zep.c index f893aa702b..2982ddfb7c 100644 --- a/ext/phalcon/db/profiler.zep.c +++ b/ext/phalcon/db/profiler.zep.c @@ -149,7 +149,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, 662, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 663, PH_NOISY_CC | PH_READONLY); RETURN_LONG(zephir_fast_count_int(&_0)); } @@ -190,7 +190,7 @@ PHP_METHOD(Phalcon_Db_Profiler, reset) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 662, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 663, &_0); RETURN_THIS(); } @@ -216,7 +216,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, 663, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 664, &_0); RETURN_THISW(); } @@ -295,7 +295,7 @@ PHP_METHOD(Phalcon_Db_Profiler, startProfile) ZEPHIR_CALL_METHOD(NULL, this_ptr, "beforeStartProfile", NULL, 0, &activeProfile); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 664, &activeProfile); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 665, &activeProfile); RETURN_THIS(); } @@ -340,33 +340,33 @@ 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, 664, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 665, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&activeProfile, &_0); ZEPHIR_CALL_FUNCTION(&_1, "hrtime", NULL, 0, &__$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, 663, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 664, PH_NOISY_CC | PH_READONLY); _2 = ZEPHIR_GT_LONG(&_0, 0); if (_2) { - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 662, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 663, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 663, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 664, 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, 662, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 663, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&firstKey, "array_key_first", NULL, 18, &_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, this_ptr, _zephir_prop_3, 665, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_3, 666, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_7, &activeProfile, "getTotalElapsedNanoseconds", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_8); zephir_add_function(&_8, &_6, &_7); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 665, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 666, &_8); 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 8c0ffd3c23..d60ddff1a2 100644 --- a/ext/phalcon/db/profiler/item.zep.c +++ b/ext/phalcon/db/profiler/item.zep.c @@ -140,8 +140,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, 666, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 667, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 667, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 668, PH_NOISY_CC | PH_READONLY); zephir_sub_function(return_value, &_0, &_1); return; } @@ -167,7 +167,7 @@ PHP_METHOD(Phalcon_Db_Profiler_Item, setFinalTime) zephir_fetch_params_without_memory_grow(1, 0, &finalTime_param); ZVAL_UNDEF(&_0); ZVAL_DOUBLE(&_0, finalTime); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 666, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 667, &_0); RETURN_THISW(); } @@ -192,7 +192,7 @@ PHP_METHOD(Phalcon_Db_Profiler_Item, setInitialTime) zephir_fetch_params_without_memory_grow(1, 0, &initialTime_param); ZVAL_UNDEF(&_0); ZVAL_DOUBLE(&_0, initialTime); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 667, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 668, &_0); RETURN_THISW(); } @@ -221,7 +221,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, 668, &sqlBindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 669, &sqlBindTypes); RETURN_THIS(); } @@ -244,7 +244,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, 669, &sqlStatement_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 670, &sqlStatement_zv); RETURN_THISW(); } @@ -273,7 +273,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, 670, &sqlVariables); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 671, &sqlVariables); RETURN_THIS(); } diff --git a/ext/phalcon/db/rawvalue.zep.c b/ext/phalcon/db/rawvalue.zep.c index f240107ffa..d9a8ad68d5 100644 --- a/ext/phalcon/db/rawvalue.zep.c +++ b/ext/phalcon/db/rawvalue.zep.c @@ -88,15 +88,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, 671, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 672, &_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, 671, &_1$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 672, &_1$$4); } else { zephir_cast_to_string(&_2$$5, value); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 671, &_2$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 672, &_2$$5); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/db/reference.zep.c b/ext/phalcon/db/reference.zep.c index 2e6284462e..0a825946d0 100644 --- a/ext/phalcon/db/reference.zep.c +++ b/ext/phalcon/db/reference.zep.c @@ -182,7 +182,7 @@ PHP_METHOD(Phalcon_Db_Reference, __construct) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); zephir_get_arrval(&definition, definition_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 672, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 673, &name_zv); zephir_memory_observe(&referencedTable); if (UNEXPECTED(!(zephir_array_isset_string_fetch(&referencedTable, &definition, SL("referencedTable"), 0)))) { ZEPHIR_INIT_VAR(&_0$$3); @@ -193,7 +193,7 @@ PHP_METHOD(Phalcon_Db_Reference, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 673, &referencedTable); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 674, &referencedTable); zephir_memory_observe(&columns); if (UNEXPECTED(!(zephir_array_isset_string_fetch(&columns, &definition, SL("columns"), 0)))) { ZEPHIR_INIT_VAR(&_1$$4); @@ -204,7 +204,7 @@ PHP_METHOD(Phalcon_Db_Reference, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 674, &columns); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 675, &columns); zephir_memory_observe(&referencedColumns); if (UNEXPECTED(!(zephir_array_isset_string_fetch(&referencedColumns, &definition, SL("referencedColumns"), 0)))) { ZEPHIR_INIT_VAR(&_2$$5); @@ -215,22 +215,22 @@ PHP_METHOD(Phalcon_Db_Reference, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 675, &referencedColumns); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 676, &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, 676, &schema); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 677, &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, 677, &referencedSchema); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 678, &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, 678, &onDelete); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 679, &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, 679, &onUpdate); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 680, &onUpdate); } if (UNEXPECTED(zephir_fast_count_int(&columns) != zephir_fast_count_int(&referencedColumns))) { ZEPHIR_INIT_VAR(&_3$$10); diff --git a/ext/phalcon/db/result/pdoresult.zep.c b/ext/phalcon/db/result/pdoresult.zep.c index 8cb6c842ff..af68e1abd7 100644 --- a/ext/phalcon/db/result/pdoresult.zep.c +++ b/ext/phalcon/db/result/pdoresult.zep.c @@ -163,11 +163,11 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, __construct) bindTypes = &bindTypes_sub; bindTypes = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 680, connection); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 681, result); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 682, sqlStatement); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 683, bindParams); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 684, bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 681, connection); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 682, result); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 683, sqlStatement); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 684, bindParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 685, bindTypes); } /** @@ -239,19 +239,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, 680, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 681, 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, 682, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 683, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlStatement, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 683, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 684, 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, 684, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 685, 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); @@ -260,14 +260,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, 681, &statement); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 682, &statement); n = -1; number--; while (1) { if (!(n != number)) { break; } - zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_5, 685, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_5, 686, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &statement, "fetch", &_4, 0, &_3$$6); zephir_check_call_status(); n++; @@ -300,8 +300,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, 686, &__$null); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 681, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 687, &__$null); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 682, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "execute", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -371,9 +371,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, 685, PH_NOISY_CC); + zephir_read_property_cached(&mode, this_ptr, _zephir_prop_0, 686, PH_NOISY_CC); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 681, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 682, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1, cursorOrientation); ZVAL_LONG(&_2, cursorOffset); ZEPHIR_RETURN_CALL_METHOD(&_0, "fetch", NULL, 0, &mode, &_1, &_2); @@ -448,7 +448,7 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, fetchAll) constructorArgs = &__$null; } if (mode == 8) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 681, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 682, 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(); @@ -459,13 +459,13 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, fetchAll) _2 = mode == 10; } if (_2) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 681, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 682, 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, 681, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 682, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_6, mode); ZEPHIR_RETURN_CALL_METHOD(&_5, "fetchAll", NULL, 0, &_6); zephir_check_call_status(); @@ -509,8 +509,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, 681, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 685, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 682, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 686, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "fetch", NULL, 0, &_1); zephir_check_call_status(); RETURN_MM(); @@ -584,12 +584,12 @@ 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, 686, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 687, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&rowCount, &_0); if (Z_TYPE_P(&rowCount) != IS_NULL) { RETURN_CCTOR(&rowCount); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 680, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 681, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&connection, &_0); ZEPHIR_CALL_METHOD(&type, &connection, "getType", NULL, 0); zephir_check_call_status(); @@ -598,21 +598,21 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, numRows) _1 = ZEPHIR_IS_STRING_IDENTICAL(&type, "pgsql"); } if (_1) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 681, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 682, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&pdoStatement, &_2$$4); ZEPHIR_CALL_METHOD(&_3$$4, &pdoStatement, "rowCount", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&rowCount); ZVAL_LONG(&rowCount, zephir_get_intval(&_3$$4)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 686, &rowCount); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 687, &rowCount); RETURN_CCTOR(&rowCount); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 682, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 683, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlStatement, &_0); ZEPHIR_INIT_VAR(&_4); ZEPHIR_CONCAT_SVS(&_4, "SELECT COUNT(*) \"numrows\" FROM (", &sqlStatement, ")"); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 683, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_5, 684, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 684, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_5, 685, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&result, &connection, "query", NULL, 0, &_4, &_0, &_5); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&row, &result, "fetch", NULL, 0); @@ -621,7 +621,7 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, numRows) zephir_array_fetch_string(&_6, &row, SL("numrows"), PH_NOISY, "phalcon/Db/Result/PdoResult.zep", 338); ZEPHIR_INIT_NVAR(&rowCount); ZVAL_LONG(&rowCount, zephir_get_intval(&_6)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 686, &rowCount); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 687, &rowCount); RETURN_CCTOR(&rowCount); } @@ -696,7 +696,7 @@ PHP_METHOD(Phalcon_Db_Result_PdoResult, setFetchMode) ctorargs = &ctorargs_sub; ctorargs = &__$null; } - 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, 682, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&pdoStatement, &_0); _1 = fetchMode == 8; if (!(_1)) { @@ -726,7 +726,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, 685, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 686, &_0); RETURN_MM_BOOL(1); } diff --git a/ext/phalcon/di/factorydefault.zep.c b/ext/phalcon/di/factorydefault.zep.c index fdc01e4f19..aa0697fbed 100644 --- a/ext/phalcon/di/factorydefault.zep.c +++ b/ext/phalcon/di/factorydefault.zep.c @@ -276,7 +276,7 @@ PHP_METHOD(Phalcon_Di_FactoryDefault, __construct) ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 182, &_2, &_3); zephir_check_call_status(); zephir_array_update_string(&_0, SL("url"), &_1, PH_COPY | PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 277, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 278, &_0); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/di/factorydefault/cli.zep.c b/ext/phalcon/di/factorydefault/cli.zep.c index 18497103cc..457a58d9c1 100644 --- a/ext/phalcon/di/factorydefault/cli.zep.c +++ b/ext/phalcon/di/factorydefault/cli.zep.c @@ -204,7 +204,7 @@ PHP_METHOD(Phalcon_Di_FactoryDefault_Cli, __construct) ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 182, &_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, 687, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 688, &_0); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/di/service.zep.c b/ext/phalcon/di/service.zep.c index 3488ca8096..f004dc5757 100644 --- a/ext/phalcon/di/service.zep.c +++ b/ext/phalcon/di/service.zep.c @@ -104,11 +104,11 @@ PHP_METHOD(Phalcon_Di_Service, __construct) shared = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 688, definition); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 689, definition); if (shared) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 689, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 690, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 689, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 690, &__$false); } } @@ -150,7 +150,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, 688, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 689, 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); @@ -161,7 +161,7 @@ PHP_METHOD(Phalcon_Di_Service, getParameter) return; } zephir_memory_observe(&arguments); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 688, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 689, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_string_fetch(&arguments, &_2, SL("arguments"), 0)) { zephir_memory_observe(¶meter); if (zephir_array_isset_long_fetch(¶meter, &arguments, position, 0)) { @@ -250,10 +250,10 @@ PHP_METHOD(Phalcon_Di_Service, resolve) container = &container_sub; container = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 689, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 690, PH_NOISY_CC | PH_READONLY); _1 = zephir_is_true(&_0); if (_1) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 690, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 691, PH_NOISY_CC | PH_READONLY); _1 = Z_TYPE_P(&_2) != IS_NULL; } if (_1) { @@ -262,7 +262,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, 688, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 689, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&definition, &_3); if (Z_TYPE_P(&definition) == IS_STRING) { if (zephir_class_exists(&definition, 1)) { @@ -328,14 +328,14 @@ PHP_METHOD(Phalcon_Di_Service, resolve) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 689, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 690, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_3)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 690, &instance); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 691, &instance); } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 691, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 692, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 691, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 692, &__$false); } RETURN_CCTOR(&instance); } @@ -358,7 +358,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, 688, definition); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 689, definition); } /** @@ -395,7 +395,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, 688, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 689, 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); @@ -406,7 +406,7 @@ PHP_METHOD(Phalcon_Di_Service, setParameter) return; } zephir_memory_observe(&arguments); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 688, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 689, 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 { @@ -442,9 +442,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, 689, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 690, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 689, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 690, &__$false); } } @@ -466,6 +466,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, 690, sharedInstance); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 691, sharedInstance); } diff --git a/ext/phalcon/domain/payload/payload.zep.c b/ext/phalcon/domain/payload/payload.zep.c index 6231c2a673..be0607e409 100644 --- a/ext/phalcon/domain/payload/payload.zep.c +++ b/ext/phalcon/domain/payload/payload.zep.c @@ -158,7 +158,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, 692, exception); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 693, exception); RETURN_THISW(); } @@ -180,7 +180,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, 693, extras); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 694, extras); RETURN_THISW(); } @@ -202,7 +202,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, 694, input); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 695, input); RETURN_THISW(); } @@ -224,7 +224,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, 695, messages); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 696, messages); RETURN_THISW(); } @@ -246,7 +246,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, 696, output); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 697, output); RETURN_THISW(); } @@ -272,7 +272,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, 697, status); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 698, status); RETURN_THISW(); } diff --git a/ext/phalcon/encryption/crypt.zep.c b/ext/phalcon/encryption/crypt.zep.c index 520e43e177..8517855c7e 100644 --- a/ext/phalcon/encryption/crypt.zep.c +++ b/ext/phalcon/encryption/crypt.zep.c @@ -259,11 +259,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, 698, padFactory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 699, padFactory); ZEPHIR_INIT_VAR(&_0); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "sha256"); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 699, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 700, &_0); ZEPHIR_CALL_METHOD(&_1, this_ptr, "initializeAvailableCiphers", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_2, &_1, "setCipher", NULL, 0, &cipher); @@ -373,7 +373,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, 700, PH_NOISY_CC); + zephir_read_property_cached(&decryptKey, this_ptr, _zephir_prop_0, 701, PH_NOISY_CC); if (1 != ZEPHIR_IS_EMPTY(&key_zv)) { ZEPHIR_CPY_WRT(&decryptKey, &key_zv); } @@ -386,9 +386,9 @@ PHP_METHOD(Phalcon_Encryption_Crypt, decrypt) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 701, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 702, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cipher, &_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 702, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 703, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&ivLength, &_1); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "cipher"); @@ -418,10 +418,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, 703, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 704, 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, 704, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_4, 705, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&hashLength, &_5$$6, &hashAlgorithm, 0))) { ZEPHIR_INIT_VAR(&_7$$7); ZVAL_STRING(&_7$$7, ""); @@ -448,7 +448,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, decrypt) ZEPHIR_CALL_FUNCTION(&cipherText, "mb_substr", NULL, 310, &input_zv, &ivLength, &__$null, &_11$$8); zephir_check_call_status(); } - zephir_read_property_cached(&_12, this_ptr, _zephir_prop_3, 703, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12, this_ptr, _zephir_prop_3, 704, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_12)) { /* try_start_1: */ @@ -634,7 +634,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, 700, PH_NOISY_CC); + zephir_read_property_cached(&encryptKey, this_ptr, _zephir_prop_0, 701, PH_NOISY_CC); if (1 != ZEPHIR_IS_EMPTY(&key_zv)) { ZEPHIR_CPY_WRT(&encryptKey, &key_zv); } @@ -647,9 +647,9 @@ PHP_METHOD(Phalcon_Encryption_Crypt, encrypt) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 701, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 702, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cipher, &_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 702, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 703, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&ivLength, &_1); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "cipher"); @@ -688,7 +688,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, 703, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 704, 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(); @@ -894,7 +894,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, 701, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 702, 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)) { @@ -919,7 +919,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, 705, &data_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 706, &data_zv); RETURN_THISW(); } @@ -939,7 +939,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, 706, &tag_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 707, &tag_zv); RETURN_THISW(); } @@ -982,7 +982,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, setAuthTagLength) } ZVAL_UNDEF(&_2); ZVAL_LONG(&_2, length); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 707, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 708, &_2); RETURN_THIS(); } @@ -1024,8 +1024,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, 702, &_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 701, &cipher_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 703, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 702, &cipher_zv); RETURN_THIS(); } @@ -1060,7 +1060,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, 699, &hashAlgorithm_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 700, &hashAlgorithm_zv); RETURN_THIS(); } @@ -1095,7 +1095,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, 700, &key_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 701, &key_zv); RETURN_THISW(); } @@ -1120,7 +1120,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, 708, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 709, &_0); RETURN_THISW(); } @@ -1145,9 +1145,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, 703, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 704, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 703, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 704, &__$false); } RETURN_THISW(); } @@ -1280,11 +1280,11 @@ PHP_METHOD(Phalcon_Encryption_Crypt, cryptPadText) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 698, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 699, 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, 698, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 699, 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); @@ -1376,11 +1376,11 @@ PHP_METHOD(Phalcon_Encryption_Crypt, cryptUnpadText) _2 = ZEPHIR_IS_TRUE_IDENTICAL(&_3); } if (_2) { - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 698, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 699, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_7$$3, paddingType); ZEPHIR_CALL_METHOD(&service, &_6$$3, "padNumberToService", NULL, 0, &_7$$3); zephir_check_call_status(); - zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_0, 698, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_0, 699, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_8$$3, &_7$$3, "newInstance", NULL, 0, &service); zephir_check_call_status(); ZVAL_LONG(&_9$$3, blockSize); @@ -1469,7 +1469,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, 701, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 702, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cipher, &_0); ZEPHIR_INIT_VAR(&_2); zephir_create_array(&_2, 2, 0); @@ -1482,9 +1482,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, 705, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 706, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&authData, &_4$$3); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 707, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 708, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&authTagLength, &_4$$3); ZEPHIR_INIT_VAR(&cipherLength); ZVAL_LONG(&cipherLength, zephir_fast_strlen_ev(&cipherText_zv)); @@ -1560,7 +1560,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, 708, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 709, 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); @@ -1631,7 +1631,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, 701, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 702, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cipher, &_0); ZEPHIR_INIT_VAR(&authTag); ZVAL_STRING(&authTag, ""); @@ -1646,7 +1646,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, 705, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 706, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&authData, &_4$$3); if (1 == ZEPHIR_IS_EMPTY(&authData)) { ZEPHIR_INIT_VAR(&_5$$4); @@ -1657,16 +1657,16 @@ PHP_METHOD(Phalcon_Encryption_Crypt, encryptGcmCcm) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 706, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_2, 707, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&authTag, &_4$$3); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_3, 707, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_3, 708, 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, 706, &authTag); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 707, &authTag); } else { ZVAL_LONG(&_6$$5, 1); ZEPHIR_CALL_FUNCTION(&encrypted, "openssl_encrypt", NULL, 0, &padded_zv, &cipher, &encryptKey_zv, &_6$$5, &iv_zv); @@ -1723,7 +1723,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, 708, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 709, PH_NOISY_CC | PH_READONLY); _1 = !ZEPHIR_IS_LONG_IDENTICAL(&_0, 0); if (_1) { ZEPHIR_INIT_VAR(&_3); @@ -1736,7 +1736,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, 708, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 709, 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(); @@ -1856,7 +1856,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, initializeAvailableCiphers) } } ZEPHIR_INIT_NVAR(&cipher); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 709, &allowed); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 710, &allowed); RETURN_THIS(); } @@ -1923,13 +1923,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, 702, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 703, 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, 701, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 702, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_3); ZVAL_STRING(&_3, ""); ZEPHIR_CALL_FUNCTION(&_4, "str_ireplace", NULL, 0, &_1, &_3, &_2); @@ -2001,15 +2001,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, 701, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 702, 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, 701, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 701, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 702, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 702, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_5); ZVAL_LONG(&_5, zephir_fast_strlen_ev(&_4)); ZEPHIR_INIT_VAR(&_6); diff --git a/ext/phalcon/encryption/security.zep.c b/ext/phalcon/encryption/security.zep.c index 5474cbf6d1..ddee324c80 100644 --- a/ext/phalcon/encryption/security.zep.c +++ b/ext/phalcon/encryption/security.zep.c @@ -264,9 +264,9 @@ PHP_METHOD(Phalcon_Encryption_Security, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 710, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 711, request); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 712, session); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 711, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 712, request); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 713, session); ZEPHIR_MM_RESTORE(); } @@ -520,16 +520,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, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 714, 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, 714, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_1, 715, 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, 715, &__$null); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 716, &__$null); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 717, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 716, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 717, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 718, &__$null); RETURN_THIS(); } @@ -604,7 +604,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, 717, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 718, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_0)) { ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getSessionToken", NULL, 0); zephir_check_call_status(); @@ -654,11 +654,11 @@ PHP_METHOD(Phalcon_Encryption_Security, getSaltBytes) ZEPHIR_INIT_VAR(&safeBytes); ZVAL_NULL(&safeBytes); if (!(numberBytes)) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 718, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 719, PH_NOISY_CC | PH_READONLY); numberBytes = zephir_get_intval(&_0$$3); } while (1) { - zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_1, 710, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_1, 711, 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(); @@ -701,7 +701,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, 714, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 715, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&session, "get", NULL, 0, &_2$$3); zephir_check_call_status(); RETURN_MM(); @@ -763,7 +763,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, 715, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 716, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); ZVAL_STRING(&_1$$3, "session"); @@ -771,32 +771,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, 719, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_1, 720, 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, 714, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_2, 715, 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, 715, &sessionToken); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 717, &sessionToken); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 716, &sessionToken); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 718, &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, 717, &_6$$3); - zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_4, 710, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_5, 718, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 718, &_6$$3); + zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_4, 711, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_5, 719, 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, 715, &_8$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 716, &_8$$3); if (Z_TYPE_P(&session) != IS_NULL) { - zephir_read_property_cached(&_10$$6, this_ptr, _zephir_prop_2, 714, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_0, 715, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$6, this_ptr, _zephir_prop_2, 715, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_0, 716, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &session, "set", NULL, 0, &_10$$6, &_11$$6); zephir_check_call_status(); } @@ -852,7 +852,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, 716, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 717, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); ZVAL_STRING(&_1$$3, "session"); @@ -861,23 +861,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, 719, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 720, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_FALSE_IDENTICAL(&_3$$4)) { - zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_2, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_2, 714, 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, 716, &sessionTokenKey); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 717, &sessionTokenKey); RETURN_MM_MEMBER(getThis(), "tokenKey"); } } - zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_3, 710, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_4, 718, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_3, 711, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_4, 719, 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, 716, &_6$$4); - zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_2, 713, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 716, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 717, &_6$$4); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_2, 714, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 717, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &session, "set", NULL, 0, &_8$$4, &_9$$4); zephir_check_call_status(); } @@ -957,7 +957,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, 720, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 721, PH_NOISY_CC); if (ZEPHIR_IS_LONG(&_1, 3)) { goto zephir_switch_0_clause_0; } if (ZEPHIR_IS_LONG(&_1, 8)) { goto zephir_switch_0_clause_1; } if (ZEPHIR_IS_LONG(&_1, 9)) { goto zephir_switch_0_clause_2; } @@ -1090,17 +1090,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, 710, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 718, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 711, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 719, 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, 715, &_1); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 710, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 718, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 716, &_1); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 711, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 719, 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, 716, &_4); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 717, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 717, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 718, &__$null); ZEPHIR_INIT_VAR(&_6); ZVAL_STRING(&_6, "session"); ZEPHIR_INIT_VAR(&_7); @@ -1108,12 +1108,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, 714, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_2, 715, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_5, 715, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$3, this_ptr, _zephir_prop_2, 716, 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, 713, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_3, 716, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_6, 714, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_3, 717, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &session, "set", NULL, 0, &_10$$3, &_11$$3); zephir_check_call_status(); } @@ -1144,9 +1144,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, 719, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 720, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 719, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 720, &__$false); } RETURN_THISW(); } @@ -1172,7 +1172,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, 720, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 721, &_0); RETURN_THISW(); } @@ -1198,7 +1198,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, 718, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 719, &_0); RETURN_THISW(); } @@ -1223,7 +1223,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, 721, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 722, &_0); RETURN_THISW(); } @@ -1267,18 +1267,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, 722, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 723, 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, 722, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 723, 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, 722, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 723, 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); @@ -1310,12 +1310,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, 720, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 721, 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, 720, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 721, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_LONG_IDENTICAL(&_1, 11)) { ZEPHIR_INIT_NVAR(&algorithm); ZVAL_STRING(&algorithm, "argon2id"); @@ -1355,10 +1355,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, 720, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 721, PH_NOISY_CC | PH_READONLY); _1 = ZEPHIR_IS_LONG_IDENTICAL(&_0, 10); if (!(_1)) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 720, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 721, PH_NOISY_CC | PH_READONLY); _1 = ZEPHIR_IS_LONG_IDENTICAL(&_2, 11); } if (_1) { @@ -1420,7 +1420,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, 721, PH_NOISY_CC); + zephir_read_property_cached(&cost, this_ptr, _zephir_prop_0, 722, PH_NOISY_CC); } if (ZEPHIR_LT_LONG(&cost, 4)) { ZEPHIR_INIT_NVAR(&cost); @@ -1478,7 +1478,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, 713, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 714, 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 4932416571..d0af07048b 100644 --- a/ext/phalcon/encryption/security/jwt/builder.zep.c +++ b/ext/phalcon/encryption/security/jwt/builder.zep.c @@ -120,7 +120,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, 723, signer); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 724, signer); ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, phalcon_support_helper_json_encode_ce); if (zephir_has_constructor(&_0)) { @@ -128,9 +128,9 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 724, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 725, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 723, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 725, &_0); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 726, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 724, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_3, &_2, "getAlgHeader", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_4); @@ -168,7 +168,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, 726, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 727, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &name_zv, value); zephir_check_call_status(); RETURN_THIS(); @@ -202,7 +202,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, 725, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 726, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &name_zv, value); zephir_check_call_status(); RETURN_THIS(); @@ -228,7 +228,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, 726, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 727, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); array_init(&_1); ZEPHIR_INIT_VAR(&_2); @@ -256,7 +256,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, 726, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 727, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "toArray", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -280,7 +280,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, 725, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 726, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "cty"); ZVAL_NULL(&_2); @@ -309,7 +309,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, 726, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 727, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "exp"); ZVAL_NULL(&_2); @@ -338,7 +338,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, 725, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 726, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "toArray", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -362,7 +362,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, 726, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 727, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "jti"); ZVAL_NULL(&_2); @@ -391,7 +391,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, 726, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 727, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "iat"); ZVAL_NULL(&_2); @@ -420,7 +420,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, 726, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 727, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "iss"); ZVAL_NULL(&_2); @@ -449,7 +449,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, 726, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 727, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "nbf"); ZVAL_NULL(&_2); @@ -484,7 +484,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, 726, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 727, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "sub"); ZVAL_NULL(&_2); @@ -540,7 +540,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, 727, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 728, 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); @@ -550,7 +550,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, getToken) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 724, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 725, 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); @@ -563,7 +563,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, 724, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 725, 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); @@ -576,10 +576,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, 723, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 724, 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, 727, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12, this_ptr, _zephir_prop_0, 728, 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); @@ -623,12 +623,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, 727, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 728, &_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, 726, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 727, &_0); ZEPHIR_INIT_VAR(&_1); object_init_ex(&_1, phalcon_support_collection_ce); ZEPHIR_INIT_VAR(&_2); @@ -637,7 +637,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, 725, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 726, &_1); RETURN_THIS(); } @@ -727,7 +727,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, 725, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 726, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "cty"); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &_1, &contentType_zv); @@ -970,7 +970,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, setPassphrase) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 727, &passphrase_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 728, &passphrase_zv); RETURN_THIS(); } @@ -1035,7 +1035,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, 726, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 727, 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 8788e41140..feddee57d5 100644 --- a/ext/phalcon/encryption/security/jwt/signer/hmac.zep.c +++ b/ext/phalcon/encryption/security/jwt/signer/hmac.zep.c @@ -90,7 +90,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Signer_Hmac, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 728, &algo_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 729, &algo_zv); ZEPHIR_MM_RESTORE(); } @@ -115,7 +115,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, 728, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 729, 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 7ab001a655..c79e8119cd 100644 --- a/ext/phalcon/encryption/security/jwt/token/item.zep.c +++ b/ext/phalcon/encryption/security/jwt/token/item.zep.c @@ -121,7 +121,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, 729, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 730, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2); zephir_array_fetch_string(&_2, &_1, SL("payload"), PH_NOISY, "phalcon/Encryption/Security/JWT/Token/Item.zep", 42); zephir_memory_observe(&_3); @@ -147,7 +147,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Item, 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, 729, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 730, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_1); zephir_array_fetch_string(&_1, &_0, SL("payload"), PH_NOISY, "phalcon/Encryption/Security/JWT/Token/Item.zep", 50); RETURN_CCTOR(&_1); @@ -175,7 +175,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Item, 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, 729, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 730, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_1); zephir_array_fetch_string(&_1, &_0, SL("payload"), 0, "phalcon/Encryption/Security/JWT/Token/Item.zep", 55); RETURN_MM_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 8cb042a30d..8b12e32807 100644 --- a/ext/phalcon/encryption/security/jwt/token/parser.zep.c +++ b/ext/phalcon/encryption/security/jwt/token/parser.zep.c @@ -88,7 +88,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Parser, __construct) } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 730, &service); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 731, &service); ZEPHIR_MM_RESTORE(); } @@ -177,7 +177,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, 730, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 731, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "doDecodeUrl", NULL, 0, &claims_zv); zephir_check_call_status(); ZVAL_BOOL(&_2, 1); @@ -242,7 +242,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, 730, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 731, 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 5fb44619fc..684b71b8e3 100644 --- a/ext/phalcon/encryption/security/jwt/token/signature.zep.c +++ b/ext/phalcon/encryption/security/jwt/token/signature.zep.c @@ -96,7 +96,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Signature, getHash) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - 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, 732, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_1); zephir_array_fetch_string(&_1, &_0, SL("hash"), PH_NOISY, "phalcon/Encryption/Security/JWT/Token/Signature.zep", 29); RETURN_CCTOR(&_1); diff --git a/ext/phalcon/encryption/security/jwt/token/token.zep.c b/ext/phalcon/encryption/security/jwt/token/token.zep.c index 3eecb6f7fa..d00a18fd6f 100644 --- a/ext/phalcon/encryption/security/jwt/token/token.zep.c +++ b/ext/phalcon/encryption/security/jwt/token/token.zep.c @@ -97,9 +97,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, 732, headers); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 733, claims); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 734, signature); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 733, headers); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 734, claims); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 735, signature); } /** @@ -145,10 +145,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, 732, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 733, 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, 733, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 734, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_3, &_2, "getEncoded", NULL, 0); zephir_check_call_status(); ZEPHIR_CONCAT_VSV(return_value, &_1, ".", &_3); @@ -186,7 +186,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, 734, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 735, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "getEncoded", NULL, 0); zephir_check_call_status(); ZEPHIR_CONCAT_VSV(return_value, &_0, ".", &_2); @@ -333,7 +333,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, 734, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 735, 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 77758c24a8..8b299a73f0 100644 --- a/ext/phalcon/encryption/security/jwt/validator.zep.c +++ b/ext/phalcon/encryption/security/jwt/validator.zep.c @@ -140,10 +140,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, 735, token); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 736, token); ZVAL_UNDEF(&_1); ZVAL_LONG(&_1, timeShift); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 736, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 737, &_1); ZEPHIR_INIT_VAR(&_2); zephir_create_array(&_2, 7, 0); zephir_array_update_string(&_2, SL("aud"), &__$null, PH_COPY | PH_SEPARATE); @@ -153,7 +153,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, 737, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 738, &_2); ZEPHIR_MM_RESTORE(); } @@ -183,9 +183,9 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, get) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&claim_zv); ZVAL_STR_COPY(&claim_zv, claim); - 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, 738, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, &claim_zv)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 737, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 738, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2$$3); zephir_array_fetch(&_2$$3, &_1$$3, &claim_zv, PH_NOISY, "phalcon/Encryption/Security/JWT/Validator.zep", 87); RETURN_CCTOR(&_2$$3); @@ -243,7 +243,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, 735, token); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 736, token); RETURN_THISW(); } @@ -307,7 +307,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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 736, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_4, &_3, "getClaims", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_5); @@ -402,7 +402,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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 736, 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); @@ -447,7 +447,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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 736, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "getClaims", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_3); @@ -455,7 +455,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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 736, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5, &_4, "getClaims", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_3); @@ -521,7 +521,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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 736, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "getClaims", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_3); @@ -570,7 +570,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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 736, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "getClaims", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_3); @@ -633,7 +633,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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 736, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "getClaims", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_3); @@ -682,7 +682,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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 736, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "getClaims", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_3); @@ -736,12 +736,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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 736, 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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 736, 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); @@ -798,7 +798,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, 735, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 736, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "getClaims", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_3); @@ -836,7 +836,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, getTimestamp) 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, 736, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 737, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_LONG(&_1, timestamp); zephir_add_function(return_value, &_1, &_0); diff --git a/ext/phalcon/encryption/security/uuid/sysnodeprovider.zep.c b/ext/phalcon/encryption/security/uuid/sysnodeprovider.zep.c index 4143fb2916..577883127c 100644 --- a/ext/phalcon/encryption/security/uuid/sysnodeprovider.zep.c +++ b/ext/phalcon/encryption/security/uuid/sysnodeprovider.zep.c @@ -136,7 +136,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, 738, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 739, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { RETURN_MM_MEMBER_TYPED(getThis(), "node", IS_STRING); } @@ -150,7 +150,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_SysNodeProvider, getNode) ZEPHIR_CALL_FUNCTION(&cached, "apcu_fetch", NULL, 288, &_3$$4); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&cached)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 738, &cached); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 739, &cached); RETURN_MM_MEMBER_TYPED(getThis(), "node", IS_STRING); } } @@ -366,13 +366,13 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_SysNodeProvider, getNode) ZEPHIR_CALL_METHOD(&node, &_54$$20, "getNode", NULL, 0); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 738, &node); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 739, &node); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "apcu_store"); ZEPHIR_CALL_METHOD(&_55, this_ptr, "phpFunctionExists", NULL, 0, &_2); zephir_check_call_status(); if (zephir_is_true(&_55)) { - zephir_read_property_cached(&_56$$21, this_ptr, _zephir_prop_0, 738, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_56$$21, this_ptr, _zephir_prop_0, 739, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_57$$21); ZVAL_STRING(&_57$$21, "__phalcon_uuid_node"); ZEPHIR_CALL_FUNCTION(NULL, "apcu_store", NULL, 290, &_57$$21, &_56$$21); diff --git a/ext/phalcon/encryption/security/uuid/version1.zep.c b/ext/phalcon/encryption/security/uuid/version1.zep.c index f7125d0222..3e14990b2d 100644 --- a/ext/phalcon/encryption/security/uuid/version1.zep.c +++ b/ext/phalcon/encryption/security/uuid/version1.zep.c @@ -184,7 +184,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version1, __construct) ZVAL_STRING(&_16, "%08x-%04x-%04x-%02x%02x-%s"); ZEPHIR_CALL_FUNCTION(&_17, "sprintf", NULL, 146, &_16, &timeLow, &timeMid, &timeHi, &clockSeqHiRes, &clockSeqLow, &nodeStr); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 739, &_17); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 740, &_17); ZEPHIR_MM_RESTORE(); } @@ -215,7 +215,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, 739, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 740, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&parts); zephir_fast_explode_str(&parts, SL("-"), &_0, ZEND_LONG_MAX); zephir_memory_observe(&_1); @@ -256,7 +256,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, 739, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 740, 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 7fc16e7b24..a9883426af 100644 --- a/ext/phalcon/encryption/security/uuid/version3.zep.c +++ b/ext/phalcon/encryption/security/uuid/version3.zep.c @@ -127,7 +127,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version3, __construct) 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, 740, &_14); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 741, &_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 82b7fd1c81..23ab5e8474 100644 --- a/ext/phalcon/encryption/security/uuid/version4.zep.c +++ b/ext/phalcon/encryption/security/uuid/version4.zep.c @@ -99,7 +99,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, 741, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 742, &_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 ff57acc0c5..048497372c 100644 --- a/ext/phalcon/encryption/security/uuid/version5.zep.c +++ b/ext/phalcon/encryption/security/uuid/version5.zep.c @@ -135,7 +135,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version5, __construct) 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, 742, &_17); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 743, &_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 3ca0f2399c..a4f594b6fc 100644 --- a/ext/phalcon/encryption/security/uuid/version6.zep.c +++ b/ext/phalcon/encryption/security/uuid/version6.zep.c @@ -138,7 +138,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version6, __construct) ZVAL_STRING(&_12, "%08x-%04x-%04x-%02x%02x-%s"); ZEPHIR_CALL_FUNCTION(&_13, "sprintf", NULL, 146, &_12, &timeHigh32, &timeMid16, &timeLow12, &clockSeqHiRes, &clockSeqLow, &nodeStr); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 743, &_13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 744, &_13); ZEPHIR_MM_RESTORE(); } @@ -169,7 +169,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, 743, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 744, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&parts); zephir_fast_explode_str(&parts, SL("-"), &_0, ZEND_LONG_MAX); zephir_memory_observe(&_1); @@ -210,7 +210,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, 743, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 744, 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 8f4b354bbf..12b7cf38c4 100644 --- a/ext/phalcon/encryption/security/uuid/version7.zep.c +++ b/ext/phalcon/encryption/security/uuid/version7.zep.c @@ -131,7 +131,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Uuid_Version7, __construct) ZVAL_STRING(&_16, "%08x-%04x-%04x-%04x-%s"); ZEPHIR_CALL_FUNCTION(&_17, "sprintf", NULL, 146, &_16, &timeHigh32, &timeLow16, &verRandA, &varRandB, &_15); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 744, &_17); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 745, &_17); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/events/event.zep.c b/ext/phalcon/events/event.zep.c index 6926a265fb..f075cd799b 100644 --- a/ext/phalcon/events/event.zep.c +++ b/ext/phalcon/events/event.zep.c @@ -175,13 +175,13 @@ PHP_METHOD(Phalcon_Events_Event, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 745, &type_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 746, source); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 747, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 746, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 747, source); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 748, data); if (cancelable) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 748, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 749, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 748, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 749, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -263,7 +263,7 @@ PHP_METHOD(Phalcon_Events_Event, setData) data = &data_sub; data = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 747, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 748, data); RETURN_THISW(); } @@ -286,7 +286,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, 745, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 746, &type_zv); RETURN_THISW(); } @@ -323,7 +323,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, 748, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 749, 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); @@ -334,9 +334,9 @@ PHP_METHOD(Phalcon_Events_Event, stop) return; } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 749, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 750, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 749, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 750, &__$false); } RETURN_THIS(); } diff --git a/ext/phalcon/events/manager.zep.c b/ext/phalcon/events/manager.zep.c index f9998c907c..972b9c4e4b 100644 --- a/ext/phalcon/events/manager.zep.c +++ b/ext/phalcon/events/manager.zep.c @@ -279,7 +279,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, 750, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 751, 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); @@ -473,7 +473,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, 751, PH_NOISY_CC); + zephir_read_property_cached(&snapshot, this_ptr, _zephir_prop_0, 752, PH_NOISY_CC); if (Z_TYPE_P(&snapshot) == IS_STRING) { ZEPHIR_INIT_VAR(&_1); zephir_string_to_char_array(&_1, &snapshot); @@ -538,9 +538,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, 752, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 753, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 752, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 753, &__$false); } } @@ -594,7 +594,7 @@ PHP_METHOD(Phalcon_Events_Manager, detach) return; } zephir_memory_observe(&queue); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 754, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&queue, &_2, &eventType_zv, 0)) { ZEPHIR_INIT_VAR(&newQueue); array_init(&newQueue); @@ -686,9 +686,9 @@ 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, 753, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 754, &_0$$3); } else { - zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_0, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_0, 754, 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); } @@ -757,7 +757,7 @@ PHP_METHOD(Phalcon_Events_Manager, dispatch) source = &source_sub; source = &__$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, 754, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_0)) { RETURN_MM_NULL(); } @@ -791,7 +791,7 @@ PHP_METHOD(Phalcon_Events_Manager, dispatch) _5 = Z_TYPE_P(name) != IS_NULL; if (_5) { zephir_memory_observe(&queue); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 754, PH_NOISY_CC | PH_READONLY); _5 = zephir_array_isset_fetch(&queue, &_6, name, 0); } if (_5) { @@ -802,7 +802,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(&_7, this_ptr, _zephir_prop_0, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 754, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&queue, &_7, &eventClassName, 0)) { ZEPHIR_RETURN_CALL_METHOD(this_ptr, "runObjectQueue", NULL, 0, &queue, event, &methodName); zephir_check_call_status(); @@ -840,9 +840,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, 754, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 755, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 754, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 755, &__$false); } } @@ -998,23 +998,23 @@ PHP_METHOD(Phalcon_Events_Manager, fire) array_init(&stashed); if (Z_TYPE_P(stopOnFalse) == IS_NULL) { zephir_memory_observe(&stop); - zephir_read_property_cached(&stop, this_ptr, _zephir_prop_0, 755, PH_NOISY_CC); + zephir_read_property_cached(&stop, this_ptr, _zephir_prop_0, 756, PH_NOISY_CC); } else { ZEPHIR_INIT_NVAR(&stop); ZVAL_BOOL(&stop, zephir_get_boolval(stopOnFalse)); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 756, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 757, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 757, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 758, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&fireHooks, &_1); if (Z_TYPE_P(&fireHooks) == IS_NULL) { ZEPHIR_INIT_VAR(&_2$$6); zephir_get_class(&_2$$6, this_ptr, 0); ZEPHIR_INIT_NVAR(&fireHooks); ZVAL_BOOL(&fireHooks, !ZEPHIR_IS_STRING_IDENTICAL(&_2$$6, "Phalcon\\Events\\Manager")); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 757, &fireHooks); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 758, &fireHooks); } _3 = zephir_is_true(&fireHooks); if (_3) { @@ -1030,9 +1030,9 @@ PHP_METHOD(Phalcon_Events_Manager, fire) if (_3) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_3, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_3, 754, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_5)) { - zephir_read_property_cached(&_6$$8, this_ptr, _zephir_prop_4, 758, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$8, this_ptr, _zephir_prop_4, 759, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(zephir_is_true(&_6$$8))) { ZEPHIR_INIT_VAR(&_7$$9); object_init_ex(&_7$$9, phalcon_events_exceptions_nolistenersforevent_ce); @@ -1045,7 +1045,7 @@ PHP_METHOD(Phalcon_Events_Manager, fire) RETURN_MM_NULL(); } zephir_memory_observe(&cached); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_5, 759, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_5, 760, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&cached, &_8, &eventType_zv, 0)) { zephir_memory_observe(&type); zephir_array_fetch_long(&type, &cached, 0, PH_NOISY, "phalcon/Events/Manager.zep", 470); @@ -1080,16 +1080,16 @@ PHP_METHOD(Phalcon_Events_Manager, fire) zephir_array_fast_append(&_14$$11, &eventName); zephir_update_property_array(this_ptr, SL("eventNameCache"), &eventType_zv, &_14$$11); } - zephir_read_property_cached(&_15, this_ptr, _zephir_prop_3, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15, this_ptr, _zephir_prop_3, 754, PH_NOISY_CC | PH_READONLY); hasTypeQueue = zephir_array_isset_value(&_15, &type); - zephir_read_property_cached(&_16, this_ptr, _zephir_prop_3, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16, this_ptr, _zephir_prop_3, 754, PH_NOISY_CC | PH_READONLY); hasFullQueue = zephir_array_isset_value(&_16, &eventType_zv); _17 = !hasTypeQueue; if (_17) { _17 = !hasFullQueue; } if (_17) { - zephir_read_property_cached(&_18$$13, this_ptr, _zephir_prop_4, 758, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$13, this_ptr, _zephir_prop_4, 759, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(zephir_is_true(&_18$$13))) { ZEPHIR_INIT_VAR(&_19$$14); object_init_ex(&_19$$14, phalcon_events_exceptions_nolistenersforevent_ce); @@ -1102,22 +1102,22 @@ PHP_METHOD(Phalcon_Events_Manager, fire) RETURN_MM_NULL(); } zephir_memory_observe(&wasDepth); - zephir_read_property_cached(&wasDepth, this_ptr, _zephir_prop_6, 760, PH_NOISY_CC); + zephir_read_property_cached(&wasDepth, this_ptr, _zephir_prop_6, 761, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_20); ZVAL_LONG(&_20, 1); ZEPHIR_INIT_VAR(&_21); zephir_add_function(&_21, &wasDepth, &_20); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 760, &_21); - zephir_read_property_cached(&_22, this_ptr, _zephir_prop_7, 752, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 761, &_21); + zephir_read_property_cached(&_22, this_ptr, _zephir_prop_7, 753, PH_NOISY_CC | PH_READONLY); collect = zephir_is_true(&_22); if (collect) { if (ZEPHIR_GT_LONG(&wasDepth, 0)) { ZEPHIR_OBS_NVAR(&stashed); - zephir_read_property_cached(&stashed, this_ptr, _zephir_prop_8, 761, PH_NOISY_CC); + zephir_read_property_cached(&stashed, this_ptr, _zephir_prop_8, 762, PH_NOISY_CC); } ZEPHIR_INIT_VAR(&_23$$15); array_init(&_23$$15); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 761, &_23$$15); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 762, &_23$$15); } /* try_start_1: */ @@ -1134,7 +1134,7 @@ PHP_METHOD(Phalcon_Events_Manager, fire) ZEPHIR_INIT_VAR(&status); ZVAL_NULL(&status); if (hasTypeQueue) { - zephir_read_property_cached(&_25$$18, this_ptr, _zephir_prop_3, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$18, this_ptr, _zephir_prop_3, 754, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&fireEvents); zephir_array_fetch(&fireEvents, &_25$$18, &type, PH_NOISY, "phalcon/Events/Manager.zep", 523); if (cancelable) { @@ -1177,7 +1177,7 @@ PHP_METHOD(Phalcon_Events_Manager, fire) _31$$17 = _33$$17; } if (_31$$17) { - zephir_read_property_cached(&_35$$19, this_ptr, _zephir_prop_3, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_35$$19, this_ptr, _zephir_prop_3, 754, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&fireEvents); zephir_array_fetch(&fireEvents, &_35$$19, &eventType_zv, PH_NOISY, "phalcon/Events/Manager.zep", 545); if (cancelable) { @@ -1208,9 +1208,9 @@ PHP_METHOD(Phalcon_Events_Manager, fire) _39$$20 = ZEPHIR_GT_LONG(&wasDepth, 0); } if (_39$$20) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 761, &stashed); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 762, &stashed); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 760, &wasDepth); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 761, &wasDepth); zephir_throw_exception_debug(&ex, "phalcon/Events/Manager.zep", 563); ZEPHIR_MM_RESTORE(); return; @@ -1221,9 +1221,9 @@ PHP_METHOD(Phalcon_Events_Manager, fire) _40 = ZEPHIR_GT_LONG(&wasDepth, 0); } if (_40) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 761, &stashed); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 762, &stashed); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 760, &wasDepth); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 761, &wasDepth); if (zephir_is_true(&fireHooks)) { if (cancelable) { ZVAL_BOOL(&_41$$23, 1); @@ -1361,14 +1361,14 @@ PHP_METHOD(Phalcon_Events_Manager, fireAll) cancelable = 1; } else { } - 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, 757, 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, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 754, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_1)) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 758, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 759, 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); @@ -1382,7 +1382,7 @@ PHP_METHOD(Phalcon_Events_Manager, fireAll) RETURN_MM(); } zephir_memory_observe(&cached); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 759, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 760, 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", 617); @@ -1417,16 +1417,16 @@ PHP_METHOD(Phalcon_Events_Manager, fireAll) zephir_array_fast_append(&_10$$7, &eventName); zephir_update_property_array(this_ptr, SL("eventNameCache"), &eventType_zv, &_10$$7); } - zephir_read_property_cached(&_11, this_ptr, _zephir_prop_1, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11, this_ptr, _zephir_prop_1, 754, PH_NOISY_CC | PH_READONLY); hasTypeQueue = zephir_array_isset_value(&_11, &type); - zephir_read_property_cached(&_12, this_ptr, _zephir_prop_1, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12, this_ptr, _zephir_prop_1, 754, PH_NOISY_CC | PH_READONLY); hasFullQueue = zephir_array_isset_value(&_12, &eventType_zv); _13 = !hasTypeQueue; if (_13) { _13 = !hasFullQueue; } if (_13) { - zephir_read_property_cached(&_14$$9, this_ptr, _zephir_prop_2, 758, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$9, this_ptr, _zephir_prop_2, 759, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(zephir_is_true(&_14$$9))) { ZEPHIR_INIT_VAR(&_15$$10); object_init_ex(&_15$$10, phalcon_events_exceptions_nolistenersforevent_ce); @@ -1440,17 +1440,17 @@ PHP_METHOD(Phalcon_Events_Manager, fireAll) RETURN_MM(); } zephir_memory_observe(&wasDepth); - zephir_read_property_cached(&wasDepth, this_ptr, _zephir_prop_4, 760, PH_NOISY_CC); + zephir_read_property_cached(&wasDepth, this_ptr, _zephir_prop_4, 761, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_16); ZVAL_LONG(&_16, 1); ZEPHIR_INIT_VAR(&_17); zephir_add_function(&_17, &wasDepth, &_16); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 760, &_17); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 761, &_17); zephir_memory_observe(&stashed); - zephir_read_property_cached(&stashed, this_ptr, _zephir_prop_5, 761, PH_NOISY_CC); + zephir_read_property_cached(&stashed, this_ptr, _zephir_prop_5, 762, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_18); array_init(&_18); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 761, &_18); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 762, &_18); /* try_start_1: */ @@ -1466,10 +1466,10 @@ PHP_METHOD(Phalcon_Events_Manager, fireAll) ZEPHIR_INIT_VAR(&dispatchStatus); ZVAL_NULL(&dispatchStatus); if (hasTypeQueue) { - zephir_read_property_cached(&_20$$12, this_ptr, _zephir_prop_1, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$12, this_ptr, _zephir_prop_1, 754, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&fireEvents); zephir_array_fetch(&fireEvents, &_20$$12, &type, PH_NOISY, "phalcon/Events/Manager.zep", 655); - zephir_read_property_cached(&_21$$12, this_ptr, _zephir_prop_6, 755, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$12, this_ptr, _zephir_prop_6, 756, PH_NOISY_CC | PH_READONLY); if (cancelable) { ZVAL_BOOL(&_22$$12, 1); } else { @@ -1480,7 +1480,7 @@ PHP_METHOD(Phalcon_Events_Manager, fireAll) zephir_check_call_status_or_jump(try_end_1); } zephir_memory_observe(&_24$$11); - zephir_read_property_cached(&_24$$11, this_ptr, _zephir_prop_6, 755, PH_NOISY_CC); + zephir_read_property_cached(&_24$$11, this_ptr, _zephir_prop_6, 756, PH_NOISY_CC); _25$$11 = zephir_is_true(&_24$$11); if (_25$$11) { _25$$11 = cancelable; @@ -1508,10 +1508,10 @@ PHP_METHOD(Phalcon_Events_Manager, fireAll) _28$$11 = _30$$11; } if (_28$$11) { - zephir_read_property_cached(&_32$$13, this_ptr, _zephir_prop_1, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_32$$13, this_ptr, _zephir_prop_1, 754, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&fireEvents); zephir_array_fetch(&fireEvents, &_32$$13, &eventType_zv, PH_NOISY, "phalcon/Events/Manager.zep", 675); - zephir_read_property_cached(&_33$$13, this_ptr, _zephir_prop_6, 755, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_33$$13, this_ptr, _zephir_prop_6, 756, PH_NOISY_CC | PH_READONLY); if (cancelable) { ZVAL_BOOL(&_34$$13, 1); } else { @@ -1531,17 +1531,17 @@ PHP_METHOD(Phalcon_Events_Manager, fireAll) if (zephir_is_instance_of(&_36, SL("Throwable"))) { zend_clear_exception(); ZEPHIR_CPY_WRT(&ex, &_36); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 761, &stashed); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 760, &wasDepth); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 762, &stashed); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 761, &wasDepth); zephir_throw_exception_debug(&ex, "phalcon/Events/Manager.zep", 690); ZEPHIR_MM_RESTORE(); return; } } - zephir_read_property_cached(&_37, this_ptr, _zephir_prop_5, 761, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_37, this_ptr, _zephir_prop_5, 762, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&responses, &_37); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 761, &stashed); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 760, &wasDepth); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 762, &stashed); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 761, &wasDepth); RETURN_CCTOR(&responses); } @@ -1595,7 +1595,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, 756, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 757, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { RETURN_MM_NULL(); } @@ -1607,8 +1607,8 @@ 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, 752, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 755, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 756, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "runQueue", NULL, 0, &queue, event, &_1, &_2, &_3, &_4, &_5, &_6); zephir_check_call_status(); RETURN_MM(); @@ -1650,7 +1650,7 @@ PHP_METHOD(Phalcon_Events_Manager, getListenerMap) ZEPHIR_INIT_VAR(&map); array_init(&map); ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 754, PH_NOISY_CC | PH_READONLY); zephir_array_keys(&_0, &_1); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_3); @@ -1711,7 +1711,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, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 754, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&queue, &_0, &type_zv, 0)) { if (Z_TYPE_P(&queue) == IS_STRING) { ZEPHIR_INIT_VAR(&_2$$3); @@ -1801,7 +1801,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, 751, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 752, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_FUNCTION("array_values", NULL, 27, &_0); zephir_check_call_status(); RETURN_MM(); @@ -1826,9 +1826,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, 756, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 757, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 756, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 757, &__$false); } } @@ -1852,7 +1852,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, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 754, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &type_zv)); } @@ -1962,7 +1962,7 @@ 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, 751, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 752, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_0, &key))) { RETURN_MM_NULL(); } @@ -1970,7 +1970,7 @@ PHP_METHOD(Phalcon_Events_Manager, removeSubscriber) ZEPHIR_INIT_VAR(&className); zephir_get_class(&className, subscriber, 0); zephir_memory_observe(&events); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 750, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 751, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&events, &_1, &className, 0))) { _2$$4 = zephir_fetch_class(&className); ZEPHIR_CALL_CE_STATIC(&events, _2$$4, "getSubscribedEvents", NULL, 0); @@ -2046,9 +2046,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, 756, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 757, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 756, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 757, &__$false); } } @@ -2077,7 +2077,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, 762, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 763, &_0); } /** @@ -2107,9 +2107,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, 755, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 756, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 755, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 756, &__$false); } } @@ -2135,9 +2135,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, 758, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 759, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 758, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 759, &__$false); } } @@ -2315,7 +2315,7 @@ PHP_METHOD(Phalcon_Events_Manager, insertHandlerEntry) className = &__$null; } zephir_memory_observe(&prioritiesOn); - zephir_read_property_cached(&prioritiesOn, this_ptr, _zephir_prop_0, 754, PH_NOISY_CC); + zephir_read_property_cached(&prioritiesOn, this_ptr, _zephir_prop_0, 755, PH_NOISY_CC); if (!(zephir_is_true(&prioritiesOn))) { priority = 100; } @@ -2345,7 +2345,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, 753, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 754, 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); @@ -2701,7 +2701,7 @@ PHP_METHOD(Phalcon_Events_Manager, runObjectQueue) ZVAL_NULL(&ret); ZEPHIR_INIT_VAR(&status); ZVAL_NULL(&status); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 752, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 753, PH_NOISY_CC | PH_READONLY); collect = zephir_is_true(&_0); zephir_is_iterable(&queue, 0, "phalcon/Events/Manager.zep", 1195); if (Z_TYPE_P(&queue) == IS_ARRAY) { @@ -2969,32 +2969,32 @@ 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", 1258); - zephir_read_property_cached(&_0$$6, this_ptr, _zephir_prop_0, 763, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$6, this_ptr, _zephir_prop_0, 764, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_1$$6); zephir_array_fetch(&_1$$6, &_0$$6, &handlerClass, 0, "phalcon/Events/Manager.zep", 1260); if (!(zephir_array_isset_value(&_1$$6, &eventName_zv))) { - zephir_read_property_cached(&_2$$7, this_ptr, _zephir_prop_0, 763, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$7, this_ptr, _zephir_prop_0, 764, 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, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$7, this_ptr, _zephir_prop_1, 763, 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, 763, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$7, this_ptr, _zephir_prop_1, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$7, this_ptr, _zephir_prop_0, 764, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$7, this_ptr, _zephir_prop_1, 763, 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, 763, &_8$$8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 764, &_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, 763, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$6, this_ptr, _zephir_prop_0, 764, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_11$$6); zephir_array_fetch(&_11$$6, &_10$$6, &handlerClass, PH_NOISY, "phalcon/Events/Manager.zep", 1269); zephir_memory_observe(&_12$$6); @@ -3053,32 +3053,32 @@ 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", 1312); - zephir_read_property_cached(&_17$$16, this_ptr, _zephir_prop_0, 763, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$16, this_ptr, _zephir_prop_0, 764, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_18$$16); zephir_array_fetch(&_18$$16, &_17$$16, &handlerClass, 0, "phalcon/Events/Manager.zep", 1314); if (!(zephir_array_isset_value(&_18$$16, &eventName_zv))) { - zephir_read_property_cached(&_19$$17, this_ptr, _zephir_prop_0, 763, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19$$17, this_ptr, _zephir_prop_0, 764, PH_NOISY_CC | PH_READONLY); _20$$17 = !(zephir_array_isset_value(&_19$$17, &handlerClass)); if (_20$$17) { - zephir_read_property_cached(&_21$$17, this_ptr, _zephir_prop_1, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$17, this_ptr, _zephir_prop_1, 763, PH_NOISY_CC | PH_READONLY); _20$$17 = ZEPHIR_GT_LONG(&_21$$17, 0); } _22$$17 = _20$$17; if (_22$$17) { - zephir_read_property_cached(&_23$$17, this_ptr, _zephir_prop_0, 763, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_24$$17, this_ptr, _zephir_prop_1, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$17, this_ptr, _zephir_prop_0, 764, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24$$17, this_ptr, _zephir_prop_1, 763, PH_NOISY_CC | PH_READONLY); _22$$17 = ZEPHIR_LE_LONG(&_24$$17, zephir_fast_count_int(&_23$$17)); } if (_22$$17) { ZEPHIR_INIT_NVAR(&_25$$18); array_init(&_25$$18); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 763, &_25$$18); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 764, &_25$$18); } ZEPHIR_INIT_NVAR(&_26$$17); ZVAL_BOOL(&_26$$17, (zephir_method_exists(&handler, &eventName_zv) == SUCCESS)); zephir_update_property_array_multi(this_ptr, SL("methodExistsCache"), &_26$$17, SL("zz"), 2, &handlerClass, &eventName_zv); } - zephir_read_property_cached(&_27$$16, this_ptr, _zephir_prop_0, 763, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_27$$16, this_ptr, _zephir_prop_0, 764, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_28$$16); zephir_array_fetch(&_28$$16, &_27$$16, &handlerClass, PH_NOISY, "phalcon/Events/Manager.zep", 1323); ZEPHIR_OBS_NVAR(&_29$$16); @@ -3160,32 +3160,32 @@ 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", 1312); - zephir_read_property_cached(&_37$$28, this_ptr, _zephir_prop_0, 763, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_37$$28, this_ptr, _zephir_prop_0, 764, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_38$$28); zephir_array_fetch(&_38$$28, &_37$$28, &handlerClass, 0, "phalcon/Events/Manager.zep", 1314); if (!(zephir_array_isset_value(&_38$$28, &eventName_zv))) { - zephir_read_property_cached(&_39$$29, this_ptr, _zephir_prop_0, 763, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_39$$29, this_ptr, _zephir_prop_0, 764, PH_NOISY_CC | PH_READONLY); _40$$29 = !(zephir_array_isset_value(&_39$$29, &handlerClass)); if (_40$$29) { - zephir_read_property_cached(&_41$$29, this_ptr, _zephir_prop_1, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_41$$29, this_ptr, _zephir_prop_1, 763, PH_NOISY_CC | PH_READONLY); _40$$29 = ZEPHIR_GT_LONG(&_41$$29, 0); } _42$$29 = _40$$29; if (_42$$29) { - zephir_read_property_cached(&_43$$29, this_ptr, _zephir_prop_0, 763, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_44$$29, this_ptr, _zephir_prop_1, 762, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_43$$29, this_ptr, _zephir_prop_0, 764, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_44$$29, this_ptr, _zephir_prop_1, 763, PH_NOISY_CC | PH_READONLY); _42$$29 = ZEPHIR_LE_LONG(&_44$$29, zephir_fast_count_int(&_43$$29)); } if (_42$$29) { ZEPHIR_INIT_NVAR(&_45$$30); array_init(&_45$$30); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 763, &_45$$30); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 764, &_45$$30); } ZEPHIR_INIT_NVAR(&_46$$29); ZVAL_BOOL(&_46$$29, (zephir_method_exists(&handler, &eventName_zv) == SUCCESS)); zephir_update_property_array_multi(this_ptr, SL("methodExistsCache"), &_46$$29, SL("zz"), 2, &handlerClass, &eventName_zv); } - zephir_read_property_cached(&_47$$28, this_ptr, _zephir_prop_0, 763, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_47$$28, this_ptr, _zephir_prop_0, 764, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_48$$28); zephir_array_fetch(&_48$$28, &_47$$28, &handlerClass, PH_NOISY, "phalcon/Events/Manager.zep", 1323); ZEPHIR_OBS_NVAR(&_49$$28); diff --git a/ext/phalcon/events/traits/eventsawaretrait.zep.c b/ext/phalcon/events/traits/eventsawaretrait.zep.c index ef6c13885e..84987633ab 100644 --- a/ext/phalcon/events/traits/eventsawaretrait.zep.c +++ b/ext/phalcon/events/traits/eventsawaretrait.zep.c @@ -88,19 +88,19 @@ PHP_METHOD(Phalcon_Events_Traits_EventsAwareTrait, setEventsManager) _2 = ZEPHIR_IS_TRUE_IDENTICAL(&_1); if (_2) { zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 764, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 765, PH_NOISY_CC); _2 = Z_TYPE_P(&_3) != IS_NULL; } if (_2) { zephir_memory_observe(&_4$$3); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 764, PH_NOISY_CC); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 765, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_5$$3); ZVAL_STRING(&_5$$3, "eventsManager"); ZVAL_BOOL(&_6$$3, 1); ZEPHIR_CALL_METHOD(NULL, &_4$$3, "set", NULL, 0, &_5$$3, eventsManager, &_6$$3); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 765, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 766, eventsManager); ZEPHIR_MM_RESTORE(); } @@ -166,16 +166,16 @@ PHP_METHOD(Phalcon_Events_Traits_EventsAwareTrait, fireManagerEvent) stopOnFalse = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 765, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 766, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { _1$$3 = stopOnFalse; if (_1$$3) { zephir_memory_observe(&_2$$3); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 765, PH_NOISY_CC); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 766, PH_NOISY_CC); _1$$3 = zephir_instance_of_ev(&_2$$3, phalcon_events_manager_ce); } if (_1$$3) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 765, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 766, PH_NOISY_CC | PH_READONLY); if (cancellable) { ZVAL_BOOL(&_4$$4, 1); } else { @@ -186,7 +186,7 @@ PHP_METHOD(Phalcon_Events_Traits_EventsAwareTrait, fireManagerEvent) zephir_check_call_status(); RETURN_MM(); } - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 765, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 766, PH_NOISY_CC | PH_READONLY); if (cancellable) { ZVAL_BOOL(&_7$$3, 1); } else { diff --git a/ext/phalcon/filter/filter.zep.c b/ext/phalcon/filter/filter.zep.c index c1159512cb..c636abc40a 100644 --- a/ext/phalcon/filter/filter.zep.c +++ b/ext/phalcon/filter/filter.zep.c @@ -369,7 +369,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, 766, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 767, 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); @@ -379,16 +379,16 @@ PHP_METHOD(Phalcon_Filter_Filter, get) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 767, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 768, 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, 766, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 767, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&definition); zephir_array_fetch(&definition, &_3$$4, &name_zv, PH_NOISY, "phalcon/Filter/Filter.zep", 269); 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, 767, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 768, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_6); zephir_array_fetch(&_6, &_5, &name_zv, PH_NOISY, "phalcon/Filter/Filter.zep", 273); RETURN_CCTOR(&_6); @@ -418,7 +418,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, 766, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 767, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &name_zv)); } @@ -544,16 +544,16 @@ PHP_METHOD(Phalcon_Filter_Filter, init) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &mapper_param); zephir_get_arrval(&mapper, mapper_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 766, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 767, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_1, "array_replace", NULL, 8, &_0, &mapper); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 766, &_1); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 767, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 767, &_1); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 768, PH_NOISY_CC | PH_READONLY); if (!(ZEPHIR_IS_EMPTY(&_2))) { - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_1, 767, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_1, 768, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_4$$3, "array_diff_key", NULL, 9, &_3$$3, &mapper); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 767, &_4$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 768, &_4$$3); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/filter/validation.zep.c b/ext/phalcon/filter/validation.zep.c index 6bd16d62d0..a87f741406 100644 --- a/ext/phalcon/filter/validation.zep.c +++ b/ext/phalcon/filter/validation.zep.c @@ -184,19 +184,19 @@ PHP_METHOD(Phalcon_Filter_Validation, __construct) object_init_ex(&_0, phalcon_messages_messages_ce); ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 14); 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_0, 769, &_0); ZEPHIR_INIT_VAR(&_1); ZEPHIR_INIT_NVAR(&_1); zephir_create_closure_ex(&_1, NULL, phalcon_17__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, 769, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 770, &_2); ZEPHIR_INIT_VAR(&_3); ZEPHIR_INIT_NVAR(&_3); zephir_create_closure_ex(&_3, NULL, phalcon_18__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, 770, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 771, &_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(); @@ -390,7 +390,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, 768, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 769, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "appendMessage", NULL, 0, message); zephir_check_call_status(); RETURN_THIS(); @@ -487,7 +487,7 @@ PHP_METHOD(Phalcon_Filter_Validation, bind) } else { zephir_get_arrval(&whitelist, whitelist_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 771, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 772, data); ZEPHIR_CALL_METHOD(NULL, this_ptr, "setEntity", NULL, 0, entity); zephir_check_call_status(); _0 = Z_TYPE_P(data) != IS_ARRAY; @@ -535,10 +535,10 @@ PHP_METHOD(Phalcon_Filter_Validation, bind) return; } if (ZEPHIR_IS_EMPTY(&whitelist)) { - zephir_read_property_cached(&_7$$7, this_ptr, _zephir_prop_1, 772, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$7, this_ptr, _zephir_prop_1, 773, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&whitelist, &_7$$7); } - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 773, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 774, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&filters, &_8); if (Z_TYPE_P(data) == IS_STRING) { ZEPHIR_INIT_NVAR(&_5); @@ -579,17 +579,17 @@ PHP_METHOD(Phalcon_Filter_Validation, bind) zephir_camelize(&_16$$8, &field, NULL ); ZEPHIR_INIT_NVAR(&method); ZEPHIR_CONCAT_SV(&method, "set", &_16$$8); - zephir_read_property_cached(&_17$$8, this_ptr, _zephir_prop_3, 774, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$8, this_ptr, _zephir_prop_3, 775, PH_NOISY_CC | PH_READONLY); if ((zephir_method_exists(&_17$$8, &method) == SUCCESS)) { ZEPHIR_CALL_METHOD_ZVAL(NULL, entity, &method, NULL, 0, &value); zephir_check_call_status(); } else { - zephir_read_property_cached(&_18$$8, this_ptr, _zephir_prop_3, 774, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$8, this_ptr, _zephir_prop_3, 775, PH_NOISY_CC | PH_READONLY); if ((zephir_method_exists_ex(&_18$$8, ZEND_STRL("writeattribute")) == SUCCESS)) { ZEPHIR_CALL_METHOD(NULL, entity, "writeAttribute", NULL, 0, &field, &value); zephir_check_call_status(); } else { - zephir_read_property_cached(&_19$$8, this_ptr, _zephir_prop_3, 774, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19$$8, this_ptr, _zephir_prop_3, 775, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_20$$8, "property_exists", &_21, 10, &_19$$8, &field); zephir_check_call_status(); if (zephir_is_true(&_20$$8)) { @@ -638,17 +638,17 @@ PHP_METHOD(Phalcon_Filter_Validation, bind) zephir_camelize(&_27$$15, &field, NULL ); ZEPHIR_INIT_NVAR(&method); ZEPHIR_CONCAT_SV(&method, "set", &_27$$15); - zephir_read_property_cached(&_28$$15, this_ptr, _zephir_prop_3, 774, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$15, this_ptr, _zephir_prop_3, 775, PH_NOISY_CC | PH_READONLY); if ((zephir_method_exists(&_28$$15, &method) == SUCCESS)) { ZEPHIR_CALL_METHOD_ZVAL(NULL, entity, &method, NULL, 0, &value); zephir_check_call_status(); } else { - zephir_read_property_cached(&_29$$15, this_ptr, _zephir_prop_3, 774, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$15, this_ptr, _zephir_prop_3, 775, PH_NOISY_CC | PH_READONLY); if ((zephir_method_exists_ex(&_29$$15, ZEND_STRL("writeattribute")) == SUCCESS)) { ZEPHIR_CALL_METHOD(NULL, entity, "writeAttribute", NULL, 0, &field, &value); zephir_check_call_status(); } else { - zephir_read_property_cached(&_30$$15, this_ptr, _zephir_prop_3, 774, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_30$$15, this_ptr, _zephir_prop_3, 775, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_31$$15, "property_exists", &_21, 10, &_30$$15, &field); zephir_check_call_status(); if (zephir_is_true(&_31$$15)) { @@ -682,7 +682,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, 768, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 769, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, &_0, "count", NULL, 0); zephir_check_call_status(); if (ZEPHIR_GT_LONG(&_1, 0)) { @@ -742,7 +742,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, 773, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 774, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&filters, &_0); if (!(!(ZEPHIR_IS_EMPTY(&field_zv)))) { RETURN_CCTOR(&filters); @@ -782,7 +782,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, 775, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 776, 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); @@ -869,9 +869,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, 774, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 775, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&entity, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 771, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 772, 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); @@ -901,7 +901,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, 773, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 774, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&filters, &_0); zephir_memory_observe(&fieldFilters); if (zephir_array_isset_fetch(&fieldFilters, &filters, &field_zv, 0)) { @@ -1001,7 +1001,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, 776, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 777, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&values, &_0); zephir_memory_observe(&value); if (zephir_array_isset_fetch(&value, &values, &field_zv, 0)) { @@ -1203,7 +1203,7 @@ PHP_METHOD(Phalcon_Filter_Validation, setEntity) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 774, entity); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 775, entity); ZEPHIR_MM_RESTORE(); } @@ -1314,7 +1314,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, 775, &labels); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 776, &labels); ZEPHIR_MM_RESTORE(); } @@ -1343,7 +1343,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, 769, &validators); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 770, &validators); RETURN_THIS(); } @@ -1499,8 +1499,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, 769, PH_NOISY_CC); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 770, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&validatorData, this_ptr, _zephir_prop_0, 770, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 771, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&combinedFieldsValidators, &_0); if (UNEXPECTED(Z_TYPE_P(&validatorData) != IS_ARRAY)) { ZEPHIR_INIT_VAR(&_1$$3); @@ -1513,12 +1513,12 @@ PHP_METHOD(Phalcon_Filter_Validation, validate) } ZEPHIR_INIT_VAR(&_2); array_init(&_2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 776, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 777, &_2); ZEPHIR_INIT_VAR(&_3); object_init_ex(&_3, phalcon_messages_messages_ce); ZEPHIR_CALL_METHOD(NULL, &_3, "__construct", NULL, 14); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 768, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 769, &_3); if (Z_TYPE_P(data) != IS_NULL) { _4$$4 = Z_TYPE_P(data) != IS_ARRAY; if (_4$$4) { @@ -1533,13 +1533,13 @@ PHP_METHOD(Phalcon_Filter_Validation, validate) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 771, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 772, data); ZEPHIR_CPY_WRT(&inputData, data); } else { - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 771, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 772, PH_NOISY_CC | PH_READONLY); if (!(ZEPHIR_IS_EMPTY(&_0))) { ZEPHIR_OBS_NVAR(&inputData); - zephir_read_property_cached(&inputData, this_ptr, _zephir_prop_4, 771, PH_NOISY_CC); + zephir_read_property_cached(&inputData, this_ptr, _zephir_prop_4, 772, PH_NOISY_CC); } } if (Z_TYPE_P(entity) != IS_NULL) { @@ -1547,8 +1547,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, 774, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$8, this_ptr, _zephir_prop_3, 768, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$8, this_ptr, _zephir_prop_5, 775, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$8, this_ptr, _zephir_prop_3, 769, 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)) { @@ -1881,8 +1881,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(&_65$$44, this_ptr, _zephir_prop_5, 774, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_66$$44, this_ptr, _zephir_prop_3, 768, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_65$$44, this_ptr, _zephir_prop_5, 775, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_66$$44, this_ptr, _zephir_prop_3, 769, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, this_ptr, "afterValidation", NULL, 0, &inputData, &_65$$44, &_66$$44); zephir_check_call_status(); } diff --git a/ext/phalcon/filter/validation/traits/validatorcompositetrait.zep.c b/ext/phalcon/filter/validation/traits/validatorcompositetrait.zep.c index 41496cb5e5..dfb7e68017 100644 --- a/ext/phalcon/filter/validation/traits/validatorcompositetrait.zep.c +++ b/ext/phalcon/filter/validation/traits/validatorcompositetrait.zep.c @@ -67,7 +67,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, 777, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 778, 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 ecdd525991..693a641734 100644 --- a/ext/phalcon/filter/validation/validator/callback.zep.c +++ b/ext/phalcon/filter/validation/validator/callback.zep.c @@ -174,11 +174,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, 778, PH_NOISY_CC); + zephir_read_property_cached(&savedTemplate, this_ptr, _zephir_prop_0, 779, PH_NOISY_CC); zephir_memory_observe(&savedChanged); - zephir_read_property_cached(&savedChanged, this_ptr, _zephir_prop_1, 779, PH_NOISY_CC); + zephir_read_property_cached(&savedChanged, this_ptr, _zephir_prop_1, 780, PH_NOISY_CC); zephir_memory_observe(&savedTemplates); - zephir_read_property_cached(&savedTemplates, this_ptr, _zephir_prop_2, 780, PH_NOISY_CC); + zephir_read_property_cached(&savedTemplates, this_ptr, _zephir_prop_2, 781, PH_NOISY_CC); ZEPHIR_INIT_VAR(&arguments); zephir_create_array(&arguments, 1, 0); zephir_array_fast_append(&arguments, &data); @@ -206,9 +206,9 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Callback, validate) ZEPHIR_CALL_METHOD(NULL, validation, "appendMessage", NULL, 0, &_3$$7); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 778, &savedTemplate); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 779, &savedChanged); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 780, &savedTemplates); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 779, &savedTemplate); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 780, &savedChanged); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 781, &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/files.zep.c b/ext/phalcon/filter/validation/validator/files.zep.c index 7ceaeab673..43cb86a3b9 100644 --- a/ext/phalcon/filter/validation/validator/files.zep.c +++ b/ext/phalcon/filter/validation/validator/files.zep.c @@ -221,7 +221,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, 781, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 782, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", NULL, 0, &_0); zephir_check_call_status(); if (Z_TYPE_P(&files) == IS_STRING) { diff --git a/ext/phalcon/filter/validation/validator/uniqueness.zep.c b/ext/phalcon/filter/validation/validator/uniqueness.zep.c index d015cdcc35..070e83021e 100644 --- a/ext/phalcon/filter/validation/validator/uniqueness.zep.c +++ b/ext/phalcon/filter/validation/validator/uniqueness.zep.c @@ -295,7 +295,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, 782, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 783, PH_NOISY_CC | PH_READONLY); _2 = !zephir_is_true(&_3); } if (_2) { @@ -307,17 +307,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, 782, &_7$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 783, &_7$$3); } zephir_memory_observe(&_8); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 782, PH_NOISY_CC); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 783, PH_NOISY_CC); _9 = Z_TYPE_P(&_8) == IS_ARRAY; if (_9) { - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 782, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 783, 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, 782, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$4, this_ptr, _zephir_prop_0, 783, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_12$$4); zephir_array_fetch(&_12$$4, &_11$$4, &field_zv, PH_NOISY, "phalcon/Filter/Validation/Validator/Uniqueness.zep", 183); RETURN_CCTOR(&_12$$4); diff --git a/ext/phalcon/filter/validation/validator/url.zep.c b/ext/phalcon/filter/validation/validator/url.zep.c index 9a9325a0d8..df5171dcbf 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, 783, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 784, 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 9b4e6649b2..76f4bcab27 100644 --- a/ext/phalcon/flash/direct.zep.c +++ b/ext/phalcon/flash/direct.zep.c @@ -99,7 +99,7 @@ PHP_METHOD(Phalcon_Flash_Direct, output) remove = 1; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 784, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 785, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); diff --git a/ext/phalcon/flash/session.zep.c b/ext/phalcon/flash/session.zep.c index f5cce3a9ef..2929e0819b 100644 --- a/ext/phalcon/flash/session.zep.c +++ b/ext/phalcon/flash/session.zep.c @@ -117,7 +117,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, 785, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 786, &_0); ZEPHIR_MM_RESTORE(); } @@ -225,14 +225,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, 786, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 787, 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, 787, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 788, PH_NOISY_CC | PH_READONLY); _2 = Z_TYPE_P(&_1) != IS_NULL; if (_2) { - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 787, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 788, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_5); ZVAL_STRING(&_5, "session"); ZEPHIR_CALL_METHOD(&_4, &_3, "has", NULL, 0, &_5); @@ -240,12 +240,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, 787, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_1, 788, 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, 786, &_7$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 787, &_7$$4); RETURN_MM_MEMBER(getThis(), "sessionService"); } ZEPHIR_INIT_NVAR(&_5); @@ -430,7 +430,7 @@ PHP_METHOD(Phalcon_Flash_Session, output) } ZEPHIR_INIT_NVAR(&message); ZEPHIR_INIT_NVAR(&type); - zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 788, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 789, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_9)) { ZEPHIR_CALL_PARENT(NULL, phalcon_flash_session_ce, getThis(), "clear", NULL, 0); zephir_check_call_status(); @@ -485,7 +485,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, 785, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 786, 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) { @@ -497,7 +497,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, 785, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$6, this_ptr, _zephir_prop_0, 786, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &session, "set", NULL, 0, &_1$$6, &messages); zephir_check_call_status(); } @@ -507,7 +507,7 @@ PHP_METHOD(Phalcon_Flash_Session, getSessionMessages) RETURN_MM(); } if (remove) { - zephir_read_property_cached(&_2$$7, this_ptr, _zephir_prop_0, 785, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$7, this_ptr, _zephir_prop_0, 786, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &session, "remove", NULL, 0, &_2$$7); zephir_check_call_status(); } @@ -547,7 +547,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, 785, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 786, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &session, "set", NULL, 0, &_0, &messages); zephir_check_call_status(); RETURN_CTOR(&messages); diff --git a/ext/phalcon/forms/element/check.zep.c b/ext/phalcon/forms/element/check.zep.c index 16540b1546..44289e7bbe 100644 --- a/ext/phalcon/forms/element/check.zep.c +++ b/ext/phalcon/forms/element/check.zep.c @@ -96,11 +96,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, 789, value); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 790, value); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 790, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 791, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 790, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 791, &__$false); } RETURN_THISW(); } diff --git a/ext/phalcon/forms/element/checkgroup.zep.c b/ext/phalcon/forms/element/checkgroup.zep.c index adbf459244..7642c81845 100644 --- a/ext/phalcon/forms/element/checkgroup.zep.c +++ b/ext/phalcon/forms/element/checkgroup.zep.c @@ -111,7 +111,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, 791, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 792, &options); ZEPHIR_CALL_PARENT(NULL, phalcon_forms_element_checkgroup_ce, getThis(), "__construct", NULL, 0, &name, &attributes); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -181,7 +181,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, 792, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 793, 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); @@ -190,8 +190,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, 793, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 791, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 794, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 792, 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); @@ -223,7 +223,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, 791, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 792, &options); RETURN_THIS(); } diff --git a/ext/phalcon/forms/element/radiogroup.zep.c b/ext/phalcon/forms/element/radiogroup.zep.c index 95238eef08..789cb80b9a 100644 --- a/ext/phalcon/forms/element/radiogroup.zep.c +++ b/ext/phalcon/forms/element/radiogroup.zep.c @@ -106,7 +106,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, 794, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 795, &options); ZEPHIR_CALL_PARENT(NULL, phalcon_forms_element_radiogroup_ce, getThis(), "__construct", NULL, 0, &name_zv, &attributes); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -176,7 +176,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, 795, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 796, 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); @@ -185,8 +185,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, 796, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 794, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 797, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 795, 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); @@ -218,7 +218,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, 794, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 795, &options); RETURN_THIS(); } diff --git a/ext/phalcon/forms/element/select.zep.c b/ext/phalcon/forms/element/select.zep.c index 42184bc3bd..dc46d8f353 100644 --- a/ext/phalcon/forms/element/select.zep.c +++ b/ext/phalcon/forms/element/select.zep.c @@ -99,7 +99,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, 797, options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 798, options); ZEPHIR_CALL_PARENT(NULL, phalcon_forms_element_select_ce, getThis(), "__construct", NULL, 0, &name_zv, &attributes); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -139,14 +139,14 @@ PHP_METHOD(Phalcon_Forms_Element_Select, addOption) 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, &option); - 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, 798, 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_cached(this_ptr, _zephir_prop_0, 797, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 798, &_1$$3); } zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 797, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 798, PH_NOISY_CC); if (Z_TYPE_P(&_2) == IS_ARRAY) { if (Z_TYPE_P(option) == IS_ARRAY) { if (Z_TYPE_P(option) == IS_STRING) { @@ -249,7 +249,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, 797, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 798, 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(); @@ -275,7 +275,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, 797, options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 798, options); RETURN_THISW(); } @@ -322,11 +322,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, 798, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 799, 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, 799, PH_NOISY_CC); + zephir_read_property_cached(&defaultAttributes, this_ptr, _zephir_prop_1, 800, 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 998abd3294..c0af397095 100644 --- a/ext/phalcon/forms/form.zep.c +++ b/ext/phalcon/forms/form.zep.c @@ -209,18 +209,18 @@ PHP_METHOD(Phalcon_Forms_Form, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 800, entity); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 801, &userOptions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 801, entity); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 802, &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, 802, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 803, &_2); ZEPHIR_INIT_VAR(&_3); object_init_ex(&_3, phalcon_messages_messages_ce); ZEPHIR_CALL_METHOD(NULL, &_3, "__construct", NULL, 14); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 803, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 804, &_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(); @@ -292,17 +292,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, 804, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 805, 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, 804, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 805, 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, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 806, PH_NOISY_CC | PH_READONLY); _3 = ZEPHIR_IS_EMPTY(&_4); } if (_3) { @@ -310,7 +310,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, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 806, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_5$$5) == IS_STRING) { ZEPHIR_INIT_VAR(&_7$$5); zephir_string_to_char_array(&_7$$5, &_5$$5); @@ -377,7 +377,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, 805, &elements); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 806, &elements); } RETURN_THIS(); } @@ -503,7 +503,7 @@ PHP_METHOD(Phalcon_Forms_Form, bind) } else { zephir_get_arrval(&whitelist, whitelist_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 806, 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); @@ -523,10 +523,10 @@ PHP_METHOD(Phalcon_Forms_Form, bind) RETURN_THIS(); } if (ZEPHIR_IS_EMPTY(&whitelist)) { - zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_1, 806, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&whitelist, &_4$$5); } - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 806, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_5) == IS_STRING) { ZEPHIR_INIT_VAR(&_7); zephir_string_to_char_array(&_7, &_5); @@ -630,11 +630,11 @@ PHP_METHOD(Phalcon_Forms_Form, bind) ZEPHIR_INIT_NVAR(&value); ZVAL_COPY(&value, _21); ZEPHIR_OBS_NVAR(&element); - zephir_read_property_cached(&_24$$14, this_ptr, _zephir_prop_0, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24$$14, this_ptr, _zephir_prop_0, 806, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&element, &_24$$14, &key, 0))) { ZEPHIR_INIT_NVAR(&element); ZVAL_NULL(&element); - zephir_read_property_cached(&_25$$15, this_ptr, _zephir_prop_0, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$15, this_ptr, _zephir_prop_0, 806, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_25$$15) == IS_STRING) { ZEPHIR_INIT_NVAR(&_27$$15); zephir_string_to_char_array(&_27$$15, &_25$$15); @@ -763,11 +763,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(&_48$$29, this_ptr, _zephir_prop_0, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_48$$29, this_ptr, _zephir_prop_0, 806, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&element, &_48$$29, &key, 0))) { ZEPHIR_INIT_NVAR(&element); ZVAL_NULL(&element); - zephir_read_property_cached(&_49$$30, this_ptr, _zephir_prop_0, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_49$$30, this_ptr, _zephir_prop_0, 806, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_49$$30) == IS_STRING) { ZEPHIR_INIT_NVAR(&_51$$30); zephir_string_to_char_array(&_51$$30, &_49$$30); @@ -878,8 +878,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, 807, &assignData); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 808, &filteredData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 808, &assignData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 809, &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(); @@ -943,9 +943,9 @@ PHP_METHOD(Phalcon_Forms_Form, clear) } else { ZEPHIR_SEPARATE_PARAM(fields); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 807, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 808, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&data, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 806, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&elements, &_0); if (Z_TYPE_P(fields) == IS_NULL) { ZEPHIR_INIT_NVAR(&data); @@ -1060,7 +1060,7 @@ PHP_METHOD(Phalcon_Forms_Form, clear) } ZEPHIR_INIT_NVAR(&field); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 807, &data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 808, &data); RETURN_THIS(); } @@ -1077,7 +1077,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, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 806, PH_NOISY_CC | PH_READONLY); RETURN_LONG(zephir_fast_count_int(&_0)); } @@ -1107,8 +1107,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, 809, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 810, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 810, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 811, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&element, &_0, &_1, 0))) { RETURN_MM_BOOL(0); } @@ -1143,7 +1143,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, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 806, 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); @@ -1203,13 +1203,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, 802, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 803, 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, 802, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 803, &_1$$3); } RETURN_MM_MEMBER(getThis(), "attributes"); } @@ -1261,7 +1261,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, 808, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 809, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&filteredData, &_0); if (Z_TYPE_P(&filteredData) == IS_ARRAY) { zephir_memory_observe(&value); @@ -1303,7 +1303,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, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 806, 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); @@ -1423,7 +1423,7 @@ PHP_METHOD(Phalcon_Forms_Form, getUserOption) defaultValue = &__$null; } zephir_memory_observe(&value); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 801, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 802, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&value, &_0, &option_zv, 0))) { RETVAL_ZVAL(defaultValue, 1, 0); RETURN_MM(); @@ -1500,9 +1500,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, 800, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 801, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&entity, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 807, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 808, 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); @@ -1567,7 +1567,7 @@ PHP_METHOD(Phalcon_Forms_Form, getValue) RETURN_MM(); } zephir_memory_observe(&element); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 806, 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(); @@ -1605,7 +1605,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, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 806, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &name_zv)); } @@ -1732,26 +1732,26 @@ PHP_METHOD(Phalcon_Forms_Form, isValid) } else { zephir_get_arrval(&whitelist, whitelist_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 806, 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, 806, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_1, 807, 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, 807, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$5, this_ptr, _zephir_prop_2, 808, 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, 800, PH_NOISY_CC); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 801, PH_NOISY_CC); _3 = Z_TYPE_P(&_4) == IS_OBJECT; } if (_3) { - zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_3, 800, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_3, 801, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(entity, &_5$$6); } ZEPHIR_CALL_METHOD(NULL, this_ptr, "bind", NULL, 0, data, entity, &whitelist); @@ -1776,7 +1776,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, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 806, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_8) == IS_STRING) { ZEPHIR_INIT_VAR(&_10); zephir_string_to_char_array(&_10, &_8); @@ -1952,7 +1952,7 @@ PHP_METHOD(Phalcon_Forms_Form, isValid) validationStatus = 0; } if (!(validationStatus)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 803, &messages); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 804, &messages); } if ((zephir_method_exists_ex(this_ptr, ZEND_STRL("aftervalidation")) == SUCCESS)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "afterValidation", NULL, 0, &messages); @@ -2013,7 +2013,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, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 806, 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); @@ -2317,14 +2317,14 @@ 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, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 806, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, &name_zv)) { zephir_unset_property_array(this_ptr, ZEND_STRL("elements"), &name_zv); RETURN_MM_BOOL(1); } ZEPHIR_INIT_VAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 809, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 810, &_1); RETURN_MM_BOOL(0); } @@ -2371,7 +2371,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, 805, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 806, 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); @@ -2415,11 +2415,11 @@ PHP_METHOD(Phalcon_Forms_Form, rewind) ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 810, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 805, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 811, &_0); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 806, 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, 809, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 810, &_1); ZEPHIR_MM_RESTORE(); } @@ -2472,7 +2472,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, 802, attributes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 803, attributes); RETURN_THISW(); } @@ -2496,7 +2496,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, 800, entity); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 801, entity); RETURN_THISW(); } @@ -2518,7 +2518,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, 804, tagFactory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 805, tagFactory); RETURN_THISW(); } @@ -2568,7 +2568,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, 801, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 802, &options); RETURN_THIS(); } @@ -2592,7 +2592,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, 811, validation); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 812, validation); RETURN_THISW(); } @@ -2621,7 +2621,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, 806, &whitelist); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 807, &whitelist); RETURN_THIS(); } @@ -2643,8 +2643,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, 809, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 810, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 810, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 811, 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 baac4506c7..4b9b469d93 100644 --- a/ext/phalcon/forms/formslocator.zep.c +++ b/ext/phalcon/forms/formslocator.zep.c @@ -126,7 +126,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, 812, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 813, &_0); zephir_is_iterable(&definitions, 0, "phalcon/Forms/FormsLocator.zep", 85); if (Z_TYPE_P(&definitions) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&definitions), _2, _3, _1) @@ -236,7 +236,7 @@ PHP_METHOD(Phalcon_Forms_FormsLocator, get) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 813, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 814, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&factory); zephir_array_fetch(&factory, &_2, &name_zv, PH_NOISY, "phalcon/Forms/FormsLocator.zep", 105); if (Z_TYPE_P(entity) != IS_NULL) { @@ -245,7 +245,7 @@ PHP_METHOD(Phalcon_Forms_FormsLocator, get) RETURN_MM(); } zephir_memory_observe(&instance); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 814, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 815, 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); @@ -285,7 +285,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, 812, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 813, 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); @@ -295,7 +295,7 @@ PHP_METHOD(Phalcon_Forms_FormsLocator, getElement) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 812, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 813, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_3); zephir_array_fetch(&_3, &_2, &type_zv, PH_NOISY, "phalcon/Forms/FormsLocator.zep", 130); RETURN_CCTOR(&_3); @@ -321,7 +321,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, 813, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 814, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &name_zv)); } @@ -345,7 +345,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, 812, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 813, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &type_zv)); } diff --git a/ext/phalcon/forms/loader/arrayloader.zep.c b/ext/phalcon/forms/loader/arrayloader.zep.c index 9216a20016..2b7d09aca5 100644 --- a/ext/phalcon/forms/loader/arrayloader.zep.c +++ b/ext/phalcon/forms/loader/arrayloader.zep.c @@ -69,7 +69,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, 815, &definitions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 816, &definitions); ZEPHIR_MM_RESTORE(); } @@ -102,7 +102,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, 815, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 816, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); diff --git a/ext/phalcon/forms/loader/jsonloader.zep.c b/ext/phalcon/forms/loader/jsonloader.zep.c index 0ed3009d02..4620a8ac98 100644 --- a/ext/phalcon/forms/loader/jsonloader.zep.c +++ b/ext/phalcon/forms/loader/jsonloader.zep.c @@ -68,7 +68,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, 816, &source_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 817, &source_zv); } /** @@ -109,7 +109,7 @@ 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, 816, PH_NOISY_CC); + zephir_read_property_cached(&json, this_ptr, _zephir_prop_0, 817, PH_NOISY_CC); ZEPHIR_CALL_FUNCTION(&_0, "is_file", NULL, 470, &json); zephir_check_call_status(); _1 = zephir_is_true(&_0); diff --git a/ext/phalcon/forms/loader/yamlloader.zep.c b/ext/phalcon/forms/loader/yamlloader.zep.c index 447b6f61c3..e9942acc91 100644 --- a/ext/phalcon/forms/loader/yamlloader.zep.c +++ b/ext/phalcon/forms/loader/yamlloader.zep.c @@ -68,7 +68,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, 817, &source_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 818, &source_zv); } /** @@ -113,7 +113,7 @@ PHP_METHOD(Phalcon_Forms_Loader_YamlLoader, load) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 817, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 818, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&source, &_3); ZEPHIR_CALL_FUNCTION(&_4, "is_file", NULL, 470, &source); zephir_check_call_status(); diff --git a/ext/phalcon/forms/manager.zep.c b/ext/phalcon/forms/manager.zep.c index e18b2efce4..08594b529f 100644 --- a/ext/phalcon/forms/manager.zep.c +++ b/ext/phalcon/forms/manager.zep.c @@ -92,7 +92,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, 818, locator); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 819, locator); ZEPHIR_MM_RESTORE(); } @@ -164,7 +164,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, 819, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 820, 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); @@ -206,7 +206,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, 819, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 820, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &name_zv)); } @@ -258,7 +258,7 @@ PHP_METHOD(Phalcon_Forms_Manager, loadForm) entity = &entity_sub; entity = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 818, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 819, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&locator, &_0); ZEPHIR_INIT_VAR(&_1); object_init_ex(&_1, phalcon_forms_form_ce); @@ -267,7 +267,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, 818, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 819, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); object_init_ex(&_2, phalcon_33__closure_ce); zephir_update_property_zval(&_2, SL("schema"), schema); diff --git a/ext/phalcon/html/breadcrumbs.zep.c b/ext/phalcon/html/breadcrumbs.zep.c index 420a52338d..0a049da211 100644 --- a/ext/phalcon/html/breadcrumbs.zep.c +++ b/ext/phalcon/html/breadcrumbs.zep.c @@ -149,7 +149,7 @@ PHP_METHOD(Phalcon_Html_Breadcrumbs, clear) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 820, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 821, &_0); ZEPHIR_MM_RESTORE(); } @@ -194,10 +194,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, 820, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 821, 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, 820, &elements); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 821, &elements); ZEPHIR_MM_RESTORE(); } @@ -273,14 +273,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, 820, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 821, 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, 821, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 822, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&template, &_0); ZEPHIR_INIT_VAR(&urls); zephir_array_keys(&urls, &elements); @@ -408,7 +408,7 @@ PHP_METHOD(Phalcon_Html_Breadcrumbs, render) zephir_array_append(&output, &_26$$7, PH_SEPARATE, "phalcon/Html/Breadcrumbs.zep", 170); } ZEPHIR_INIT_VAR(&_33); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 822, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 823, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_34); ZEPHIR_CONCAT_SVS(&_34, "
", &_0, "
"); zephir_fast_join(&_33, &_34, &output); @@ -435,7 +435,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, 822, &separator_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 823, &separator_zv); RETURN_THISW(); } diff --git a/ext/phalcon/html/escaper.zep.c b/ext/phalcon/html/escaper.zep.c index a8a231b885..bc5a9af229 100644 --- a/ext/phalcon/html/escaper.zep.c +++ b/ext/phalcon/html/escaper.zep.c @@ -174,7 +174,7 @@ PHP_METHOD(Phalcon_Html_Escaper, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 823, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 824, &_0); ZEPHIR_INIT_VAR(&_1); object_init_ex(&_1, phalcon_html_escaper_cssescaper_ce); if (zephir_has_constructor(&_1)) { @@ -182,7 +182,7 @@ PHP_METHOD(Phalcon_Html_Escaper, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 824, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 825, &_1); ZEPHIR_INIT_VAR(&_2); object_init_ex(&_2, phalcon_html_escaper_htmlescaper_ce); if (zephir_has_constructor(&_2)) { @@ -190,7 +190,7 @@ PHP_METHOD(Phalcon_Html_Escaper, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 825, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 826, &_2); ZEPHIR_INIT_VAR(&_3); object_init_ex(&_3, phalcon_html_escaper_jsescaper_ce); if (zephir_has_constructor(&_3)) { @@ -198,7 +198,7 @@ PHP_METHOD(Phalcon_Html_Escaper, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 826, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 827, &_3); ZEPHIR_INIT_VAR(&_4); object_init_ex(&_4, phalcon_html_escaper_urlescaper_ce); if (zephir_has_constructor(&_4)) { @@ -206,7 +206,7 @@ PHP_METHOD(Phalcon_Html_Escaper, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 827, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 828, &_4); ZEPHIR_INIT_VAR(&_5); ZVAL_STRING(&_5, "utf-8"); if (!ZEPHIR_IS_IDENTICAL(&_5, &encoding_zv)) { @@ -262,7 +262,7 @@ PHP_METHOD(Phalcon_Html_Escaper, attributes) input = &input_sub; input = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 823, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 824, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "escape", NULL, 0, input); zephir_check_call_status(); RETURN_MM(); @@ -293,7 +293,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, 824, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 825, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "escape", NULL, 0, &input_zv); zephir_check_call_status(); RETURN_MM(); @@ -324,7 +324,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, 825, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 826, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "detectEncoding", NULL, 0, &input_zv); zephir_check_call_status(); RETURN_MM(); @@ -504,7 +504,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, 825, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 826, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getEncoding", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -528,7 +528,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, 825, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 826, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getFlags", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -596,7 +596,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, 825, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 826, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "escape", NULL, 0, &input_zv); zephir_check_call_status(); RETURN_MM(); @@ -627,7 +627,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, 826, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 827, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "escape", NULL, 0, &input_zv); zephir_check_call_status(); RETURN_MM(); @@ -658,7 +658,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, 825, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 826, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "normalizeEncoding", NULL, 0, &input_zv); zephir_check_call_status(); RETURN_MM(); @@ -682,7 +682,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, 823, escaper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 824, escaper); RETURN_THISW(); } @@ -704,7 +704,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, 824, escaper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 825, escaper); RETURN_THISW(); } @@ -756,7 +756,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, 823, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 824, PH_NOISY_CC | PH_READONLY); if (doubleEncode) { ZVAL_BOOL(&_1, 1); } else { @@ -764,7 +764,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, 824, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 825, PH_NOISY_CC | PH_READONLY); if (doubleEncode) { ZVAL_BOOL(&_3, 1); } else { @@ -772,7 +772,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, 825, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 826, PH_NOISY_CC | PH_READONLY); if (doubleEncode) { ZVAL_BOOL(&_5, 1); } else { @@ -780,7 +780,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, 826, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_3, 827, PH_NOISY_CC | PH_READONLY); if (doubleEncode) { ZVAL_BOOL(&_7, 1); } else { @@ -788,7 +788,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, 827, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_4, 828, PH_NOISY_CC | PH_READONLY); if (doubleEncode) { ZVAL_BOOL(&_9, 1); } else { @@ -844,19 +844,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, 823, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 824, 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, 824, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 825, 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, 825, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 826, 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, 826, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 827, 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, 827, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_4, 828, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_4, "setEncoding", NULL, 0, &encoding_zv); zephir_check_call_status(); RETURN_THIS(); @@ -905,23 +905,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, 823, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 824, 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, 824, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 825, 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, 825, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 826, 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, 826, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 827, 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, 827, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_4, 828, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_5, flags); ZEPHIR_CALL_METHOD(NULL, &_4, "setFlags", NULL, 0, &_5); zephir_check_call_status(); @@ -946,7 +946,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, 825, escaper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 826, escaper); RETURN_THISW(); } @@ -993,7 +993,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, 826, escaper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 827, escaper); RETURN_THISW(); } @@ -1015,7 +1015,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, 827, escaper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 828, escaper); RETURN_THISW(); } @@ -1044,7 +1044,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, 827, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 828, 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 981bc8f04c..4a0220926b 100644 --- a/ext/phalcon/html/escaper/attributeescaper.zep.c +++ b/ext/phalcon/html/escaper/attributeescaper.zep.c @@ -290,9 +290,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, 828, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 829, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 830, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 829, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 830, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 831, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_FUNCTION("htmlspecialchars", NULL, 200, &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 d5a5055944..91dff32c01 100644 --- a/ext/phalcon/html/escaper/htmlescaper.zep.c +++ b/ext/phalcon/html/escaper/htmlescaper.zep.c @@ -108,9 +108,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, 831, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 832, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 833, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 832, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 833, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 834, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_FUNCTION("htmlspecialchars", NULL, 200, &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 b87e0636a6..8bc8207e99 100644 --- a/ext/phalcon/html/escaper/traits/escapertrait.zep.c +++ b/ext/phalcon/html/escaper/traits/escapertrait.zep.c @@ -205,9 +205,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, 834, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 835, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 834, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 835, &__$false); } RETURN_THISW(); } @@ -231,7 +231,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, 835, &encoding_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 836, &encoding_zv); RETURN_THISW(); } @@ -256,7 +256,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, 836, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 837, &_0); RETURN_THISW(); } diff --git a/ext/phalcon/html/helper/anchor.zep.c b/ext/phalcon/html/helper/anchor.zep.c index ee516a5d5f..c50042e727 100644 --- a/ext/phalcon/html/helper/anchor.zep.c +++ b/ext/phalcon/html/helper/anchor.zep.c @@ -87,9 +87,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, 837, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 838, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 837, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 838, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -157,7 +157,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, 837, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 838, 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 c13985fcde..1b3dddb41f 100644 --- a/ext/phalcon/html/helper/breadcrumbs.zep.c +++ b/ext/phalcon/html/helper/breadcrumbs.zep.c @@ -140,7 +140,7 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, __construct) } ZEPHIR_CALL_PARENT(NULL, phalcon_html_helper_breadcrumbs_ce, getThis(), "__construct", NULL, 0, escaper); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 838, url); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 839, url); ZEPHIR_MM_RESTORE(); } @@ -195,8 +195,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, 839, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 840, &indent_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 840, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 841, &indent_zv); RETURN_THIS(); } @@ -272,7 +272,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, 841, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 842, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&count); ZVAL_LONG(&count, (zephir_fast_count_int(&_0) + 1)); ZEPHIR_INIT_VAR(&_1); @@ -308,7 +308,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, 841, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 842, &_0); ZEPHIR_MM_RESTORE(); } @@ -331,7 +331,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, 842, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 843, &_0); RETURN_THIS(); } @@ -403,9 +403,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, 841, PH_NOISY_CC); + zephir_read_property_cached(&elements, this_ptr, _zephir_prop_0, 842, PH_NOISY_CC); zephir_array_unset_long(&elements, index, PH_SEPARATE); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 841, &elements); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 842, &elements); ZEPHIR_MM_RESTORE(); } @@ -481,11 +481,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, 841, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 842, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_0)) { RETURN_MM_STRING(""); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 841, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 842, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&data, &_1); ZEPHIR_INIT_VAR(&output); array_init(&output); @@ -507,7 +507,7 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, render) { ZEPHIR_INIT_NVAR(&element); ZVAL_COPY(&element, _4); - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_1, 843, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_1, 844, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_7$$4); zephir_array_fetch_string(&_7$$4, &_6$$4, SL("line"), PH_NOISY, "phalcon/Html/Helper/Breadcrumbs.zep", 234); ZEPHIR_CALL_METHOD(&_5$$4, this_ptr, "getLink", &_8, 0, &_7$$4, &element); @@ -532,7 +532,7 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, render) } ZEPHIR_CALL_METHOD(&element, _2, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_1, 843, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$5, this_ptr, _zephir_prop_1, 844, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_13$$5); zephir_array_fetch_string(&_13$$5, &_12$$5, SL("line"), PH_NOISY, "phalcon/Html/Helper/Breadcrumbs.zep", 234); ZEPHIR_CALL_METHOD(&_11$$5, this_ptr, "getLink", &_8, 0, &_13$$5, &element); @@ -541,31 +541,31 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, render) } } ZEPHIR_INIT_NVAR(&element); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 843, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 844, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_15); zephir_array_fetch_string(&_15, &_1, SL("last"), PH_NOISY, "phalcon/Html/Helper/Breadcrumbs.zep", 240); ZEPHIR_CALL_METHOD(&_14, this_ptr, "getLink", &_8, 0, &_15, &lastElement); zephir_check_call_status(); zephir_array_append(&output, &_14, PH_SEPARATE, "phalcon/Html/Helper/Breadcrumbs.zep", 240); - zephir_read_property_cached(&_16, this_ptr, _zephir_prop_1, 843, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16, this_ptr, _zephir_prop_1, 844, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_17); zephir_array_fetch_string(&_17, &_16, SL("main"), PH_NOISY, "phalcon/Html/Helper/Breadcrumbs.zep", 243); ZEPHIR_INIT_VAR(&_18); zephir_create_array(&_18, 4, 0); - zephir_read_property_cached(&_20, this_ptr, _zephir_prop_2, 842, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20, this_ptr, _zephir_prop_2, 843, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_19, this_ptr, "processAttributes", NULL, 0, &_20); zephir_check_call_status(); zephir_array_update_string(&_18, SL("attributes"), &_19, PH_COPY | PH_SEPARATE); zephir_memory_observe(&_21); - zephir_read_property_cached(&_21, this_ptr, _zephir_prop_3, 839, PH_NOISY_CC); + zephir_read_property_cached(&_21, this_ptr, _zephir_prop_3, 840, PH_NOISY_CC); zephir_array_update_string(&_18, SL("delimiter"), &_21, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_21); - zephir_read_property_cached(&_21, this_ptr, _zephir_prop_4, 840, PH_NOISY_CC); + zephir_read_property_cached(&_21, this_ptr, _zephir_prop_4, 841, PH_NOISY_CC); zephir_array_update_string(&_18, SL("indent"), &_21, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_VAR(&_22); - zephir_read_property_cached(&_23, this_ptr, _zephir_prop_4, 840, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_24, this_ptr, _zephir_prop_5, 844, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_25, this_ptr, _zephir_prop_3, 839, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23, this_ptr, _zephir_prop_4, 841, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24, this_ptr, _zephir_prop_5, 845, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25, this_ptr, _zephir_prop_3, 840, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_26); ZEPHIR_CONCAT_VVV(&_26, &_23, &_24, &_25); zephir_fast_join(&_22, &_26, &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, 842, &attributes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 843, &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, 845, &prefix_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 838, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 846, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 839, &__$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, 844, &separator_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 845, &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, 843, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 844, &_0); RETURN_THIS(); } @@ -775,22 +775,22 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, getLink) zephir_get_arrval(&element, element_param); _0 = !(zephir_isempty_dim_string(&element, SL("link"))); if (_0) { - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 838, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 839, PH_NOISY_CC | PH_READONLY); _0 = Z_TYPE_P(&_1) != IS_NULL; } if (_0) { - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 838, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 839, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_5$$3, &element, SL("link"), PH_NOISY | PH_READONLY, "phalcon/Html/Helper/Breadcrumbs.zep", 327); ZEPHIR_CALL_METHOD(&link, &_4$$3, "get", NULL, 0, &_5$$3); zephir_check_call_status(); } else { _2 = !(zephir_isempty_dim_string(&element, SL("link"))); if (_2) { - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 845, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 846, PH_NOISY_CC | PH_READONLY); _2 = !(ZEPHIR_IS_EMPTY(&_3)); } if (_2) { - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_1, 845, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_1, 846, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_7$$4, &element, SL("link"), PH_NOISY | PH_READONLY, "phalcon/Html/Helper/Breadcrumbs.zep", 329); ZEPHIR_INIT_NVAR(&link); ZEPHIR_CONCAT_VV(&link, &_6$$4, &_7$$4); @@ -799,7 +799,7 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, getLink) zephir_array_fetch_string(&link, &element, SL("link"), PH_NOISY, "phalcon/Html/Helper/Breadcrumbs.zep", 331); } } - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 840, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 841, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_10); zephir_create_array(&_10, 4, 0); zephir_array_fetch_string(&_12, &element, SL("attributes"), PH_NOISY | PH_READONLY, "phalcon/Html/Helper/Breadcrumbs.zep", 338); @@ -809,18 +809,18 @@ PHP_METHOD(Phalcon_Html_Helper_Breadcrumbs, getLink) zephir_memory_observe(&_13); zephir_array_fetch_string(&_13, &element, SL("icon"), PH_NOISY, "phalcon/Html/Helper/Breadcrumbs.zep", 339); zephir_array_update_string(&_10, SL("icon"), &_13, PH_COPY | PH_SEPARATE); - zephir_read_property_cached(&_14, this_ptr, _zephir_prop_3, 846, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14, this_ptr, _zephir_prop_3, 847, PH_NOISY_CC | PH_READONLY); zephir_array_fetch_string(&_15, &element, SL("text"), PH_NOISY | PH_READONLY, "phalcon/Html/Helper/Breadcrumbs.zep", 340); ZEPHIR_CALL_METHOD(&_11, &_14, "html", NULL, 0, &_15); zephir_check_call_status(); zephir_array_update_string(&_10, SL("text"), &_11, PH_COPY | PH_SEPARATE); - zephir_read_property_cached(&_16, this_ptr, _zephir_prop_3, 846, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16, this_ptr, _zephir_prop_3, 847, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_11, &_16, "attributes", NULL, 0, &link); zephir_check_call_status(); zephir_array_update_string(&_10, SL("link"), &_11, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(&_9, this_ptr, "toInterpolate", NULL, 0, &template_zv, &_10); zephir_check_call_status(); - zephir_read_property_cached(&_17, this_ptr, _zephir_prop_4, 839, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17, this_ptr, _zephir_prop_4, 840, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_VVV(return_value, &_8, &_9, &_17); RETURN_MM(); } diff --git a/ext/phalcon/html/helper/button.zep.c b/ext/phalcon/html/helper/button.zep.c index ed1b752958..59f0c1de89 100644 --- a/ext/phalcon/html/helper/button.zep.c +++ b/ext/phalcon/html/helper/button.zep.c @@ -87,9 +87,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, 847, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 848, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 847, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 848, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -148,7 +148,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, 847, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 848, 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 70df4b79ef..2e4b3569e7 100644 --- a/ext/phalcon/html/helper/doctype.zep.c +++ b/ext/phalcon/html/helper/doctype.zep.c @@ -124,10 +124,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, 848, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 849, &_0); ZEPHIR_INIT_VAR(&_1); ZEPHIR_GET_CONSTANT(&_1, "PHP_EOL"); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 849, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 850, &_1); ZEPHIR_MM_RESTORE(); } @@ -177,8 +177,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, 848, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 849, &delimiter_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 849, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 850, &delimiter_zv); RETURN_THIS(); } @@ -214,7 +214,7 @@ 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, 848, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 849, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_LONG(&_0, 1)) { goto zephir_switch_0_clause_0; } if (ZEPHIR_IS_LONG(&_0, 2)) { goto zephir_switch_0_clause_1; } if (ZEPHIR_IS_LONG(&_0, 3)) { goto zephir_switch_0_clause_2; } @@ -226,52 +226,52 @@ PHP_METHOD(Phalcon_Html_Helper_Doctype, __toString) if (ZEPHIR_IS_LONG(&_0, 10)) { goto zephir_switch_0_clause_8; } goto zephir_switch_0_end; zephir_switch_0_clause_0: ; - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SV(return_value, "", &_1$$3); return; zephir_switch_0_clause_1: ; - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SVSV(return_value, "", &_3$$4); return; zephir_switch_0_clause_2: ; - zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SVSV(return_value, "", &_5$$5); return; zephir_switch_0_clause_3: ; - zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SVSV(return_value, "", &_7$$6); return; zephir_switch_0_clause_4: ; - zephir_read_property_cached(&_8$$7, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_9$$7, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$7, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$7, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SVSV(return_value, "", &_9$$7); return; zephir_switch_0_clause_5: ; - zephir_read_property_cached(&_10$$8, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11$$8, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$8, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$8, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SVSV(return_value, "", &_11$$8); return; zephir_switch_0_clause_6: ; - zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_13$$9, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$9, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$9, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SVSV(return_value, "", &_13$$9); return; zephir_switch_0_clause_7: ; - zephir_read_property_cached(&_14$$10, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_15$$10, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$10, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$10, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SVSV(return_value, "", &_15$$10); return; zephir_switch_0_clause_8: ; - zephir_read_property_cached(&_16$$11, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_17$$11, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$11, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$11, this_ptr, _zephir_prop_1, 850, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SVSV(return_value, "", &_17$$11); return; zephir_switch_0_end: ; - zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 849, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18, this_ptr, _zephir_prop_1, 850, 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 c1b14102b7..4504998bda 100644 --- a/ext/phalcon/html/helper/element.zep.c +++ b/ext/phalcon/html/helper/element.zep.c @@ -87,9 +87,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, 850, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 851, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 850, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 851, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -151,7 +151,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, 850, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 851, 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 6685eaf9a2..b8b406fd84 100644 --- a/ext/phalcon/html/helper/friendlytitle.zep.c +++ b/ext/phalcon/html/helper/friendlytitle.zep.c @@ -76,7 +76,7 @@ PHP_METHOD(Phalcon_Html_Helper_FriendlyTitle, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 851, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 852, &_0); ZEPHIR_MM_RESTORE(); } @@ -143,7 +143,7 @@ PHP_METHOD(Phalcon_Html_Helper_FriendlyTitle, __invoke) } /* try_start_1: */ - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 851, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 852, 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 8082c01b72..88da379710 100644 --- a/ext/phalcon/html/helper/input/checkboxgroup.zep.c +++ b/ext/phalcon/html/helper/input/checkboxgroup.zep.c @@ -80,20 +80,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, 852, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 853, 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, 852, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 853, PH_NOISY_CC); if (Z_TYPE_P(&_1) == IS_ARRAY) { zephir_memory_observe(&selected); - zephir_read_property_cached(&selected, this_ptr, _zephir_prop_0, 852, PH_NOISY_CC); + zephir_read_property_cached(&selected, this_ptr, _zephir_prop_0, 853, 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, 852, PH_NOISY_CC); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_0, 853, 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 48e79c470f..ef78f6a173 100644 --- a/ext/phalcon/html/helper/input/generic.zep.c +++ b/ext/phalcon/html/helper/input/generic.zep.c @@ -87,7 +87,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, 853, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 854, &type_zv); ZEPHIR_MM_RESTORE(); } @@ -110,7 +110,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, 853, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 854, &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 4726ac4fc1..b1e55ae44a 100644 --- a/ext/phalcon/html/helper/input/radiogroup.zep.c +++ b/ext/phalcon/html/helper/input/radiogroup.zep.c @@ -75,12 +75,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, 854, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 855, 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, 854, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 855, 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 2df23e9108..bf084d9afb 100644 --- a/ext/phalcon/html/helper/input/select.zep.c +++ b/ext/phalcon/html/helper/input/select.zep.c @@ -143,7 +143,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, 855, PH_NOISY_CC); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 856, PH_NOISY_CC); zephir_array_fast_append(&_3, &_4); zephir_array_fast_append(&_3, &text_zv); zephir_array_fast_append(&_3, &attributes); @@ -231,7 +231,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, 855, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 856, PH_NOISY_CC); zephir_array_fast_append(&_2, &_3); zephir_array_fast_append(&_2, &text_zv); zephir_array_fast_append(&_2, &attributes); @@ -587,7 +587,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, 856, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 857, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_INIT_VAR(&_1$$3); zephir_create_array(&_1$$3, 3, 0); @@ -605,15 +605,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, 857, PH_NOISY_CC); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 858, PH_NOISY_CC); ZEPHIR_ADD_ASSIGN(&_5$$3, &_2$$3) - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 857, &_5$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 858, &_5$$3); } else { ZEPHIR_INIT_VAR(&_7$$4); ZVAL_LONG(&_7$$4, 1); - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_1, 857, PH_NOISY_CC); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_1, 858, PH_NOISY_CC); ZEPHIR_SUB_ASSIGN(&_6$$4, &_7$$4) - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 857, &_6$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 858, &_6$$4); ZEPHIR_INIT_VAR(&_8$$4); zephir_create_array(&_8$$4, 3, 0); ZEPHIR_INIT_VAR(&_9$$4); @@ -628,11 +628,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, 856, PH_NOISY_CC); + zephir_read_property_cached(&_11, this_ptr, _zephir_prop_0, 857, PH_NOISY_CC); if (!zephir_is_true(&_11)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 856, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 857, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 856, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 857, &__$false); } RETURN_THIS(); } @@ -680,7 +680,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, 855, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 856, PH_NOISY_CC); zephir_array_fast_append(&_2, &_3); zephir_array_fast_append(&_2, &text_zv); ZEPHIR_INIT_VAR(&_4); @@ -714,7 +714,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, 858, &selected_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 859, &selected_zv); RETURN_THISW(); } @@ -747,9 +747,9 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select, strict) } else { } if (flag) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 859, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 860, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 859, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 860, &__$false); } RETURN_THISW(); } @@ -854,14 +854,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, 858, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 859, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_STRING_IDENTICAL(&_1$$3, "")) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 859, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 860, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_2$$4)) { - zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_0, 858, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_0, 859, 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, 858, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$6, this_ptr, _zephir_prop_0, 859, 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 524fec0fd6..1b559443e5 100644 --- a/ext/phalcon/html/helper/input/select/arraydata.zep.c +++ b/ext/phalcon/html/helper/input/select/arraydata.zep.c @@ -106,8 +106,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, 860, &data); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 861, &attributes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 861, &data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 862, &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 6cb907f0ca..a46756ecd9 100644 --- a/ext/phalcon/html/helper/input/select/resultsetdata.zep.c +++ b/ext/phalcon/html/helper/input/select/resultsetdata.zep.c @@ -136,9 +136,9 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select_ResultsetData, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 862, resultset); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 863, &using); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 864, &attributesMap); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 863, resultset); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 864, &using); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 865, &attributesMap); ZEPHIR_MM_RESTORE(); } @@ -162,7 +162,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, 865, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 866, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "resolve", NULL, 0); zephir_check_call_status(); @@ -188,7 +188,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, 866, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 867, 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(); @@ -308,17 +308,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, 863, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 864, 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", 130); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 863, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 864, 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", 131); ZEPHIR_INIT_VAR(&options); array_init(&options); ZEPHIR_INIT_VAR(&attrs); array_init(&attrs); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 862, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 863, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_2) == IS_STRING) { ZEPHIR_INIT_VAR(&_4); zephir_string_to_char_array(&_4, &_2); @@ -351,11 +351,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(&_10$$3); - zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_2, 864, PH_NOISY_CC); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_2, 865, PH_NOISY_CC); if (!(ZEPHIR_IS_EMPTY(&_10$$3))) { ZEPHIR_INIT_NVAR(&optionAttrs); array_init(&optionAttrs); - zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_2, 864, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_2, 865, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_11$$5) == IS_STRING) { ZEPHIR_INIT_NVAR(&_13$$5); zephir_string_to_char_array(&_13$$5, &_11$$5); @@ -470,11 +470,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(&_28$$15); - zephir_read_property_cached(&_28$$15, this_ptr, _zephir_prop_2, 864, PH_NOISY_CC); + zephir_read_property_cached(&_28$$15, this_ptr, _zephir_prop_2, 865, PH_NOISY_CC); if (!(ZEPHIR_IS_EMPTY(&_28$$15))) { ZEPHIR_INIT_NVAR(&optionAttrs); array_init(&optionAttrs); - zephir_read_property_cached(&_29$$17, this_ptr, _zephir_prop_2, 864, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$17, this_ptr, _zephir_prop_2, 865, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_29$$17) == IS_STRING) { ZEPHIR_INIT_NVAR(&_31$$17); zephir_string_to_char_array(&_31$$17, &_29$$17); @@ -554,8 +554,8 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select_ResultsetData, resolve) } } ZEPHIR_INIT_NVAR(&option); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 866, &options); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 865, &attrs); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 867, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 866, &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 ccd9b6f29c..a4f1161e14 100644 --- a/ext/phalcon/html/helper/input/textarea.zep.c +++ b/ext/phalcon/html/helper/input/textarea.zep.c @@ -73,11 +73,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, 867, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 868, 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, 867, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 868, &_1); zephir_memory_observe(&value); if (!(zephir_array_isset_string_fetch(&value, &attributes, SL("value"), 0))) { ZEPHIR_INIT_NVAR(&value); @@ -85,7 +85,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, 868, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 869, 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 e80c70c751..4ece7991b9 100644 --- a/ext/phalcon/html/helper/label.zep.c +++ b/ext/phalcon/html/helper/label.zep.c @@ -87,9 +87,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, 869, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 870, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 869, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 870, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -148,7 +148,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, 869, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 870, PH_NOISY_CC); _0 = zephir_is_true(&_1); } ZEPHIR_INIT_VAR(&_2); diff --git a/ext/phalcon/html/helper/ol.zep.c b/ext/phalcon/html/helper/ol.zep.c index c4513612c2..08cecd0373 100644 --- a/ext/phalcon/html/helper/ol.zep.c +++ b/ext/phalcon/html/helper/ol.zep.c @@ -88,9 +88,9 @@ PHP_METHOD(Phalcon_Html_Helper_Ol, __construct) ZEPHIR_CALL_PARENT(NULL, phalcon_html_helper_ol_ce, getThis(), "__construct", NULL, 0, escaper, doctype); zephir_check_call_status(); if (forceRaw) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 278, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 279, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 278, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 279, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -160,14 +160,14 @@ PHP_METHOD(Phalcon_Html_Helper_Ol, add) ZEPHIR_INIT_VAR(&_2); zephir_create_array(&_2, 4, 0); zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 279, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 280, PH_NOISY_CC); zephir_array_fast_append(&_2, &_3); zephir_array_fast_append(&_2, &text_zv); zephir_array_fast_append(&_2, &attributes); _4 = raw; if (!(_4)) { ZEPHIR_OBS_NVAR(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 278, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 279, PH_NOISY_CC); _4 = zephir_is_true(&_3); } ZEPHIR_INIT_NVAR(&_1); diff --git a/ext/phalcon/html/helper/preload.zep.c b/ext/phalcon/html/helper/preload.zep.c index 103831a296..3fc6434ba2 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, 870, response); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 871, response); ZEPHIR_MM_RESTORE(); } @@ -153,7 +153,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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 871, 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); @@ -178,7 +178,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, 870, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 871, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_6$$3, "setRawHeader", NULL, 0, &header); zephir_check_call_status(); } diff --git a/ext/phalcon/html/helper/style.zep.c b/ext/phalcon/html/helper/style.zep.c index 2caa159707..960459b321 100644 --- a/ext/phalcon/html/helper/style.zep.c +++ b/ext/phalcon/html/helper/style.zep.c @@ -143,9 +143,9 @@ PHP_METHOD(Phalcon_Html_Helper_Style, setStyle) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &flag_param); if (flag) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 280, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 281, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 280, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 281, &__$false); } RETURN_THISW(); } @@ -190,7 +190,7 @@ PHP_METHOD(Phalcon_Html_Helper_Style, getAttributes) zephir_array_update_string(&required, SL("href"), &url_zv, PH_COPY | PH_SEPARATE); add_assoc_stringl_ex(&required, SL("type"), SL("text/css")); add_assoc_stringl_ex(&required, SL("media"), SL("screen")); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 280, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 281, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { zephir_array_unset_string(&required, SL("rel"), PH_SEPARATE); } @@ -215,7 +215,7 @@ PHP_METHOD(Phalcon_Html_Helper_Style, getTag) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 280, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 281, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_1)) { ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "style"); diff --git a/ext/phalcon/html/helper/title.zep.c b/ext/phalcon/html/helper/title.zep.c index 91d7e050d2..4f4f47b82d 100644 --- a/ext/phalcon/html/helper/title.zep.c +++ b/ext/phalcon/html/helper/title.zep.c @@ -125,8 +125,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, 871, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 872, &indent_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 872, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 873, &indent_zv); RETURN_THIS(); } @@ -182,28 +182,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, 873, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 874, 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, 874, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 875, PH_NOISY_CC); zephir_array_fast_append(&_1, &_2); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 875, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 876, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&items, "array_merge", NULL, 202, &_0, &_1, &_3); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_4); array_init(&_4); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 875, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 876, &_4); ZEPHIR_INIT_VAR(&_5); array_init(&_5); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 873, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 874, &_5); ZEPHIR_INIT_VAR(&_6); ZEPHIR_INIT_NVAR(&_6); ZVAL_STRING(&_6, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 874, &_6); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_3, 872, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 875, &_6); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_3, 873, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_6); - zephir_read_property_cached(&_9, this_ptr, _zephir_prop_4, 876, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_4, 877, PH_NOISY_CC | PH_READONLY); zephir_fast_join(&_6, &_9, &items); ZEPHIR_INIT_VAR(&_10); array_init(&_10); @@ -212,7 +212,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, 871, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12, this_ptr, _zephir_prop_5, 872, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_VVV(return_value, &_7, &_8, &_12); RETURN_MM(); } @@ -254,7 +254,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, 877, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 878, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_0, &_1, "html", NULL, 0, &text); zephir_check_call_status(); } @@ -315,18 +315,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, 877, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 878, 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, 873, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 874, 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, 873, &prepend); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 874, &prepend); RETURN_THIS(); } @@ -371,12 +371,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, 877, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 878, 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, 874, &text); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 875, &text); RETURN_THIS(); } @@ -424,11 +424,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, 877, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 878, 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, 876, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 877, &_0); RETURN_THIS(); } diff --git a/ext/phalcon/html/helper/voidtag.zep.c b/ext/phalcon/html/helper/voidtag.zep.c index ff781da199..afcc9ea9cc 100644 --- a/ext/phalcon/html/helper/voidtag.zep.c +++ b/ext/phalcon/html/helper/voidtag.zep.c @@ -88,10 +88,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, 878, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 879, PH_NOISY_CC | PH_READONLY); _1 = Z_TYPE_P(&_0) != IS_NULL; if (_1) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 878, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 879, 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 455c531be2..ad6b1577a4 100644 --- a/ext/phalcon/html/tagfactory.zep.c +++ b/ext/phalcon/html/tagfactory.zep.c @@ -230,17 +230,17 @@ PHP_METHOD(Phalcon_Html_TagFactory, __construct) url = &url_sub; url = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 879, escaper); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 880, response); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 881, url); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 880, escaper); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 881, response); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 882, 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, 882, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 883, &_0); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getDefaultServices", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 883, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 884, &_1); zephir_is_iterable(&services, 0, "phalcon/Html/TagFactory.zep", 166); if (Z_TYPE_P(&services) == IS_ARRAY) { ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&services), _3, _4, _2) @@ -348,7 +348,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, 883, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &name_zv)); } @@ -392,7 +392,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, 883, 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_value(&_0, &name_zv))) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_html_exceptions_servicenotregistered_ce); @@ -402,9 +402,9 @@ PHP_METHOD(Phalcon_Html_TagFactory, newInstance) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 884, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 885, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_2, &name_zv))) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 883, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 884, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&factory); zephir_array_fetch(&factory, &_3$$4, &name_zv, PH_NOISY, "phalcon/Html/TagFactory.zep", 207); ZEPHIR_INIT_VAR(&_4$$4); @@ -412,7 +412,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, 884, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 885, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_6); zephir_array_fetch(&_6, &_5, &name_zv, PH_NOISY, "phalcon/Html/TagFactory.zep", 211); RETURN_CCTOR(&_6); @@ -527,11 +527,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, 879, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 880, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&escaper, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 880, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 881, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&response, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 881, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 882, 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 be30596f01..9e2a38a798 100644 --- a/ext/phalcon/http/cookie.zep.c +++ b/ext/phalcon/http/cookie.zep.c @@ -247,23 +247,23 @@ PHP_METHOD(Phalcon_Http_Cookie, __construct) } else { zephir_get_arrval(&options, options_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 885, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 886, &name_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, expire); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 886, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 887, &path_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 887, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 888, &path_zv); if (secure) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 888, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 889, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 888, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 889, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 889, &domain_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 890, &domain_zv); if (httpOnly) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 890, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 891, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 890, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 891, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 891, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 892, &options); if (Z_TYPE_P(value) != IS_NULL) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "setValue", NULL, 0, value); zephir_check_call_status(); @@ -330,7 +330,7 @@ PHP_METHOD(Phalcon_Http_Cookie, delete) ZEPHIR_CALL_METHOD(NULL, &session, "remove", NULL, 0, &_0$$3); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 892, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 893, &__$null); ZEPHIR_INIT_VAR(&_1); zephir_time(&_1); ZEPHIR_INIT_VAR(&_2); @@ -339,7 +339,7 @@ PHP_METHOD(Phalcon_Http_Cookie, delete) zephir_sub_function(&_3, &_1, &_2); ZEPHIR_CALL_METHOD(&options, this_ptr, "getCookieOptions", NULL, 0, &_3); zephir_check_call_status(); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 885, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 886, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, ""); ZEPHIR_CALL_FUNCTION(NULL, "setcookie", NULL, 0, &_4, &_1, &options); @@ -534,18 +534,18 @@ PHP_METHOD(Phalcon_Http_Cookie, getValue) zephir_check_call_status(); ZEPHIR_INIT_VAR(&container); ZVAL_NULL(&container); - 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, 886, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&name, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 893, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 894, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_FALSE_IDENTICAL(&_0)) { zephir_memory_observe(&value); if (!(zephir_array_isset_fetch(&value, &_COOKIE, &name, 0))) { RETVAL_ZVAL(defaultValue, 1, 0); RETURN_MM(); } - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 894, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 895, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_1$$3)) { - zephir_read_property_cached(&_2$$5, this_ptr, _zephir_prop_3, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$5, this_ptr, _zephir_prop_3, 896, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_2$$5); if (Z_TYPE_P(&container) == IS_NULL) { ZEPHIR_INIT_VAR(&_3$$6); @@ -570,7 +570,7 @@ PHP_METHOD(Phalcon_Http_Cookie, getValue) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2$$5, this_ptr, _zephir_prop_4, 896, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$5, this_ptr, _zephir_prop_4, 897, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&signKey, &_2$$5); if (Z_TYPE_P(&signKey) == IS_STRING) { ZEPHIR_CALL_METHOD(&decryptedValue, &crypt, "decryptBase64", NULL, 0, &value, &signKey); @@ -582,13 +582,13 @@ PHP_METHOD(Phalcon_Http_Cookie, getValue) } else { ZEPHIR_CPY_WRT(&decryptedValue, &value); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 892, &decryptedValue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 893, &decryptedValue); if (Z_TYPE_P(filters) != IS_NULL) { - zephir_read_property_cached(&_7$$11, this_ptr, _zephir_prop_6, 897, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$11, this_ptr, _zephir_prop_6, 898, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&filter, &_7$$11); if (Z_TYPE_P(&filter) != IS_OBJECT) { if (Z_TYPE_P(&container) == IS_NULL) { - zephir_read_property_cached(&_8$$13, this_ptr, _zephir_prop_3, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$13, this_ptr, _zephir_prop_3, 896, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_8$$13); if (Z_TYPE_P(&container) == IS_NULL) { ZEPHIR_INIT_VAR(&_9$$14); @@ -605,7 +605,7 @@ PHP_METHOD(Phalcon_Http_Cookie, getValue) ZEPHIR_CALL_METHOD(&_10$$12, &container, "getShared", NULL, 0, &_11$$12); zephir_check_call_status(); ZEPHIR_CPY_WRT(&filter, &_10$$12); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 897, &filter); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 898, &filter); } ZEPHIR_RETURN_CALL_METHOD(&filter, "sanitize", NULL, 0, &decryptedValue, filters); zephir_check_call_status(); @@ -673,7 +673,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, 898, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_CALL_METHOD(&session, this_ptr, "getStartedSession", NULL, 0); zephir_check_call_status(); @@ -684,33 +684,33 @@ PHP_METHOD(Phalcon_Http_Cookie, restore) zephir_check_call_status(); zephir_memory_observe(&expire); if (zephir_array_isset_string_fetch(&expire, &definition, SL("expire"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 886, &expire); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 887, &expire); } zephir_memory_observe(&domain); if (zephir_array_isset_string_fetch(&domain, &definition, SL("domain"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 889, &domain); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 890, &domain); } zephir_memory_observe(&path); if (zephir_array_isset_string_fetch(&path, &definition, SL("path"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 887, &path); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 888, &path); } zephir_memory_observe(&secure); if (zephir_array_isset_string_fetch(&secure, &definition, SL("secure"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 888, &secure); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 889, &secure); } zephir_memory_observe(&httpOnly); if (zephir_array_isset_string_fetch(&httpOnly, &definition, SL("httpOnly"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 890, &httpOnly); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 891, &httpOnly); } zephir_memory_observe(&options); if (zephir_array_isset_string_fetch(&options, &definition, SL("options"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 891, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 892, &options); } } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 898, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 899, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 898, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 899, &__$false); } } RETURN_THIS(); @@ -802,23 +802,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, 885, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 886, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&name, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 892, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 893, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&value, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 886, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 887, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&expire, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 889, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 890, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&domain, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 887, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 888, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&path, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 888, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 889, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&secure, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 890, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 891, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&httpOnly, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_7, 891, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_7, 892, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_8, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_8, 896, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); ZEPHIR_INIT_VAR(&definition); array_init(&definition); @@ -841,7 +841,7 @@ PHP_METHOD(Phalcon_Http_Cookie, send) zephir_check_call_status(); } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_9, 894, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_9, 895, PH_NOISY_CC | PH_READONLY); _3 = zephir_is_true(&_0); if (_3) { _3 = !(ZEPHIR_IS_EMPTY(&value)); @@ -870,7 +870,7 @@ PHP_METHOD(Phalcon_Http_Cookie, send) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_8$$5, this_ptr, _zephir_prop_10, 896, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$5, this_ptr, _zephir_prop_10, 897, 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); @@ -884,7 +884,7 @@ PHP_METHOD(Phalcon_Http_Cookie, send) } else { ZEPHIR_CPY_WRT(&encryptValue, &value); } - zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 886, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11, this_ptr, _zephir_prop_2, 887, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&options, this_ptr, "getCookieOptions", NULL, 0, &_11); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(NULL, "setcookie", NULL, 0, &name, &encryptValue, &options); @@ -918,7 +918,7 @@ PHP_METHOD(Phalcon_Http_Cookie, setDomain) ZVAL_STR_COPY(&domain_zv, domain); ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkRestored", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 889, &domain_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 890, &domain_zv); RETURN_THIS(); } @@ -948,7 +948,7 @@ PHP_METHOD(Phalcon_Http_Cookie, setExpiration) zephir_check_call_status(); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, expire); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 886, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 887, &_0); RETURN_THIS(); } @@ -979,9 +979,9 @@ PHP_METHOD(Phalcon_Http_Cookie, setHttpOnly) ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkRestored", NULL, 0); zephir_check_call_status(); if (httpOnly) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 890, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 891, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 890, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 891, &__$false); } RETURN_THIS(); } @@ -1011,7 +1011,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, 891, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 892, &options); RETURN_THIS(); } @@ -1041,7 +1041,7 @@ PHP_METHOD(Phalcon_Http_Cookie, setPath) ZVAL_STR_COPY(&path_zv, path); ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkRestored", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 887, &path_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 888, &path_zv); RETURN_THIS(); } @@ -1073,9 +1073,9 @@ PHP_METHOD(Phalcon_Http_Cookie, setSecure) ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkRestored", NULL, 0); zephir_check_call_status(); if (secure) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 888, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 889, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 888, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 889, &__$false); } RETURN_THIS(); } @@ -1121,7 +1121,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, 896, &signKey_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 897, &signKey_zv); RETURN_THIS(); } @@ -1149,11 +1149,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, 892, value); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 893, value); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 893, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 894, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 893, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 894, &__$false); } RETURN_THISW(); } @@ -1179,9 +1179,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, 894, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 895, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 894, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 895, &__$false); } RETURN_THISW(); } @@ -1240,7 +1240,7 @@ PHP_METHOD(Phalcon_Http_Cookie, checkRestored) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 898, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 899, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "restore", NULL, 0); zephir_check_call_status(); @@ -1298,7 +1298,7 @@ PHP_METHOD(Phalcon_Http_Cookie, getCookieOptions) 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, &expiresDefault_param); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 891, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 892, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "expires"); @@ -1306,25 +1306,25 @@ PHP_METHOD(Phalcon_Http_Cookie, getCookieOptions) ZEPHIR_CALL_METHOD(&_1, this_ptr, "getArrVal", NULL, 0, &options, &_2, &_3); zephir_check_call_status(); zephir_array_update_string(&options, SL("expires"), &_1, PH_COPY | PH_SEPARATE); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 889, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 890, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "domain"); ZEPHIR_CALL_METHOD(&_4, this_ptr, "getArrVal", NULL, 0, &options, &_2, &_3); zephir_check_call_status(); zephir_array_update_string(&options, SL("domain"), &_4, PH_COPY | PH_SEPARATE); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 887, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 888, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "path"); ZEPHIR_CALL_METHOD(&_5, this_ptr, "getArrVal", NULL, 0, &options, &_2, &_6); zephir_check_call_status(); zephir_array_update_string(&options, SL("path"), &_5, PH_COPY | PH_SEPARATE); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_3, 888, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_3, 889, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "secure"); ZEPHIR_CALL_METHOD(&_7, this_ptr, "getArrVal", NULL, 0, &options, &_2, &_8); zephir_check_call_status(); zephir_array_update_string(&options, SL("secure"), &_7, PH_COPY | PH_SEPARATE); - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_4, 890, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_4, 891, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "httponly"); ZEPHIR_CALL_METHOD(&_9, this_ptr, "getArrVal", NULL, 0, &options, &_2, &_10); @@ -1346,7 +1346,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, 885, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 886, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_SV(return_value, "_PHCOOKIE_", &_0); return; } @@ -1376,7 +1376,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, 895, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 896, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); _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 7ce45b63eb..cb52a2c869 100644 --- a/ext/phalcon/http/request.zep.c +++ b/ext/phalcon/http/request.zep.c @@ -284,13 +284,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, 899, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 900, 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, 899, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 900, &_1$$3); } RETURN_MM_MEMBER(getThis(), "attributes"); } @@ -483,16 +483,16 @@ PHP_METHOD(Phalcon_Http_Request, getClientAddress) RETURN_MM_BOOL(0); } if (trustForwardedHeader) { - zephir_read_property_cached(&_0$$4, this_ptr, _zephir_prop_0, 900, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$4, this_ptr, _zephir_prop_0, 901, 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, 900, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_0, 901, 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, 901, PH_NOISY_CC); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 902, PH_NOISY_CC); _3$$4 = !(ZEPHIR_IS_EMPTY(&_2$$4)); if (_3$$4) { ZEPHIR_CALL_METHOD(&_4$$4, this_ptr, "isProxyTrusted", NULL, 0, &address); @@ -527,7 +527,7 @@ PHP_METHOD(Phalcon_Http_Request, getClientAddress) ZEPHIR_INIT_NVAR(&forwardedIp); ZVAL_COPY(&forwardedIp, _8$$8); ZEPHIR_OBS_NVAR(&_9$$9); - zephir_read_property_cached(&_9$$9, this_ptr, _zephir_prop_1, 901, PH_NOISY_CC); + zephir_read_property_cached(&_9$$9, this_ptr, _zephir_prop_1, 902, PH_NOISY_CC); _10$$9 = !(ZEPHIR_IS_EMPTY(&_9$$9)); if (_10$$9) { ZEPHIR_CALL_METHOD(&_11$$9, this_ptr, "isProxyTrusted", NULL, 0, &forwardedIp); @@ -562,7 +562,7 @@ PHP_METHOD(Phalcon_Http_Request, getClientAddress) ZEPHIR_CALL_METHOD(&forwardedIp, _7$$8, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&_15$$12); - zephir_read_property_cached(&_15$$12, this_ptr, _zephir_prop_1, 901, PH_NOISY_CC); + zephir_read_property_cached(&_15$$12, this_ptr, _zephir_prop_1, 902, PH_NOISY_CC); _16$$12 = !(ZEPHIR_IS_EMPTY(&_15$$12)); if (_16$$12) { ZEPHIR_CALL_METHOD(&_17$$12, this_ptr, "isProxyTrusted", NULL, 0, &forwardedIp); @@ -774,7 +774,7 @@ PHP_METHOD(Phalcon_Http_Request, getFilteredData) } else { } zephir_memory_observe(&filters); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 902, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 903, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_1); zephir_array_fetch(&_1, &_0, &methodKey_zv, 0, "phalcon/Http/Request.zep", 361); if (!(zephir_array_isset_fetch(&filters, &_1, &name_zv, 0))) { @@ -1354,7 +1354,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, 903, PH_NOISY_CC); + zephir_read_property_cached(&strict, this_ptr, _zephir_prop_0, 904, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "HTTP_HOST"); ZEPHIR_CALL_METHOD(&host, this_ptr, "getServer", NULL, 0, &_0); @@ -1585,7 +1585,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, 904, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$5, this_ptr, _zephir_prop_0, 905, 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)) { @@ -1682,11 +1682,11 @@ PHP_METHOD(Phalcon_Http_Request, getPatch) noRecursive = 0; } else { } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 905, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 906, 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, 905, &_0); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 905, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 906, &_0); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); if (notAllowEmpty) { ZVAL_BOOL(&_3, 1); } else { @@ -1850,8 +1850,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, 905, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 905, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 906, &_0); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); if (notAllowEmpty) { ZVAL_BOOL(&_2, 1); } else { @@ -1994,11 +1994,11 @@ PHP_METHOD(Phalcon_Http_Request, getPut) noRecursive = 0; } else { } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 905, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 906, 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, 905, &_0); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 905, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 906, &_0); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 906, PH_NOISY_CC | PH_READONLY); if (notAllowEmpty) { ZVAL_BOOL(&_3, 1); } else { @@ -2127,14 +2127,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, 906, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 907, 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, 906, &contents); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 907, &contents); RETURN_CCTOR(&contents); } RETURN_CCTOR(&rawBody); @@ -3372,9 +3372,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, 904, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 905, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 904, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 905, &__$false); } RETURN_THISW(); } @@ -3567,9 +3567,9 @@ PHP_METHOD(Phalcon_Http_Request, setStrictHostCheck) } else { } if (flag) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 903, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 904, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 903, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 904, &__$false); } RETURN_THISW(); } @@ -3699,7 +3699,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, 900, &trustedHeader); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 901, &trustedHeader); RETURN_THIS(); } @@ -5016,10 +5016,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, 907, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 908, 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, 908, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 909, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_1$$3); if (Z_TYPE_P(&container) == IS_NULL) { ZEPHIR_INIT_VAR(&_2$$4); @@ -5035,7 +5035,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, 907, &filterService); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 908, &filterService); } RETURN_MM_MEMBER(getThis(), "filterService"); } @@ -5845,7 +5845,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, 901, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 902, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); @@ -6052,19 +6052,19 @@ PHP_METHOD(Phalcon_Http_Request, setEventsManager) _2 = ZEPHIR_IS_TRUE_IDENTICAL(&_1); if (_2) { zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 909, PH_NOISY_CC); _2 = Z_TYPE_P(&_3) != IS_NULL; } if (_2) { zephir_memory_observe(&_4$$3); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 908, PH_NOISY_CC); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 909, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_5$$3); ZVAL_STRING(&_5$$3, "eventsManager"); ZVAL_BOOL(&_6$$3, 1); ZEPHIR_CALL_METHOD(NULL, &_4$$3, "set", NULL, 0, &_5$$3, eventsManager, &_6$$3); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 909, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 910, eventsManager); ZEPHIR_MM_RESTORE(); } @@ -6130,16 +6130,16 @@ PHP_METHOD(Phalcon_Http_Request, fireManagerEvent) stopOnFalse = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 909, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 910, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { _1$$3 = stopOnFalse; if (_1$$3) { zephir_memory_observe(&_2$$3); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 909, PH_NOISY_CC); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 910, PH_NOISY_CC); _1$$3 = zephir_instance_of_ev(&_2$$3, phalcon_events_manager_ce); } if (_1$$3) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 909, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 910, PH_NOISY_CC | PH_READONLY); if (cancellable) { ZVAL_BOOL(&_4$$4, 1); } else { @@ -6150,7 +6150,7 @@ PHP_METHOD(Phalcon_Http_Request, fireManagerEvent) zephir_check_call_status(); RETURN_MM(); } - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 909, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 910, PH_NOISY_CC | PH_READONLY); if (cancellable) { ZVAL_BOOL(&_7$$3, 1); } else { diff --git a/ext/phalcon/http/request/bag/abstractbag.zep.c b/ext/phalcon/http/request/bag/abstractbag.zep.c index 13f71985df..b40b953f47 100644 --- a/ext/phalcon/http/request/bag/abstractbag.zep.c +++ b/ext/phalcon/http/request/bag/abstractbag.zep.c @@ -100,7 +100,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, __construct) } ZEPHIR_CALL_METHOD(&_0, this_ptr, "normalizeItems", NULL, 0, &items); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 281, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 282, &_0); ZEPHIR_MM_RESTORE(); } @@ -134,7 +134,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, clear) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 281, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 282, &_0); ZEPHIR_MM_RESTORE(); } @@ -151,7 +151,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, count) if (UNEXPECTED(!_zephir_prop_0)) { _zephir_prop_0 = zend_string_init("items", 5, 1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 281, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 282, PH_NOISY_CC | PH_READONLY); RETURN_LONG(zephir_fast_count_int(&_0)); } @@ -196,7 +196,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, get) zephir_check_call_status(); ZEPHIR_CPY_WRT(key, &_0); zephir_memory_observe(&value); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 281, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 282, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&value, &_1, key, 0)) { if (Z_TYPE_P(&value) != IS_NULL) { RETURN_CCTOR(&value); @@ -252,7 +252,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, getArray) zephir_check_call_status(); ZEPHIR_CPY_WRT(key, &_0); zephir_memory_observe(&value); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 281, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 282, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&value, &_1, key, 0)) { if (Z_TYPE_P(&value) == IS_ARRAY) { RETURN_CCTOR(&value); @@ -301,7 +301,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, getBool) zephir_check_call_status(); ZEPHIR_CPY_WRT(key, &_0); zephir_memory_observe(&value); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 281, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 282, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&value, &_1, key, 0)) { if (Z_TYPE_P(&value) != IS_NULL) { RETURN_MM_BOOL(zephir_get_boolval(&value)); @@ -350,7 +350,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, getFloat) zephir_check_call_status(); ZEPHIR_CPY_WRT(key, &_0); zephir_memory_observe(&value); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 281, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 282, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&value, &_1, key, 0)) { if (Z_TYPE_P(&value) != IS_NULL) { RETURN_MM_DOUBLE(zephir_get_doubleval(&value)); @@ -398,7 +398,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, getInt) zephir_check_call_status(); ZEPHIR_CPY_WRT(key, &_0); zephir_memory_observe(&value); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 281, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 282, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&value, &_1, key, 0)) { if (Z_TYPE_P(&value) != IS_NULL) { RETURN_MM_LONG(zephir_get_intval(&value)); @@ -428,7 +428,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, getIterator) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); object_init_ex(return_value, spl_ce_ArrayIterator); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 281, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 282, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 19, &_0); zephir_check_call_status(); RETURN_MM(); @@ -481,7 +481,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, getString) zephir_check_call_status(); ZEPHIR_CPY_WRT(key, &_0); zephir_memory_observe(&value); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 281, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 282, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&value, &_1, key, 0)) { if (Z_TYPE_P(&value) != IS_NULL) { zephir_cast_to_string(&_2$$4, &value); @@ -519,7 +519,7 @@ PHP_METHOD(Phalcon_Http_Request_Bag_AbstractBag, has) zephir_fetch_params(1, 1, 0, &key); ZEPHIR_CALL_METHOD(&_0, this_ptr, "normalizeKey", NULL, 0, key); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 281, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 282, PH_NOISY_CC | PH_READONLY); RETURN_MM_BOOL(zephir_array_key_exists(&_1, &_0)); } diff --git a/ext/phalcon/http/request/file.zep.c b/ext/phalcon/http/request/file.zep.c index 0b41a9a6ee..36468b0e4f 100644 --- a/ext/phalcon/http/request/file.zep.c +++ b/ext/phalcon/http/request/file.zep.c @@ -182,7 +182,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, 910, &name); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 911, &name); ZEPHIR_INIT_VAR(&_0$$3); ZVAL_STRING(&_0$$3, "PATHINFO_EXTENSION"); ZEPHIR_CALL_FUNCTION(&_1$$3, "defined", NULL, 148, &_0$$3); @@ -191,31 +191,31 @@ PHP_METHOD(Phalcon_Http_Request_File, __construct) ZVAL_LONG(&_2$$4, 4); ZEPHIR_CALL_FUNCTION(&_3$$4, "pathinfo", NULL, 206, &name, &_2$$4); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 911, &_3$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 912, &_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, 912, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 913, &_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, 913, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 914, &_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, 914, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 915, &_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, 915, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 916, &_8); if (!(ZEPHIR_IS_EMPTY(&key_zv))) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 916, &key_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 917, &key_zv); } ZEPHIR_MM_RESTORE(); } @@ -274,17 +274,17 @@ 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, 917, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 918, 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, 912, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 913, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&mime, "finfo_file", NULL, 0, &finfo, &_2$$4); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&mime)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 917, &mime); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 918, &mime); } } } @@ -340,7 +340,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, 912, PH_NOISY_CC); + zephir_read_property_cached(&name, this_ptr, _zephir_prop_0, 913, PH_NOISY_CC); _0 = !(ZEPHIR_IS_EMPTY(&name)); if (_0) { ZEPHIR_CALL_FUNCTION(&_1, "is_uploaded_file", NULL, 34, &name); @@ -375,7 +375,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, 912, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 913, 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 6cef2a2f95..b501481b4e 100644 --- a/ext/phalcon/http/response.zep.c +++ b/ext/phalcon/http/response.zep.c @@ -168,7 +168,7 @@ PHP_METHOD(Phalcon_Http_Response, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 918, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 919, &_0); ZEPHIR_INIT_VAR(&_1); object_init_ex(&_1, phalcon_support_helper_json_encode_ce); if (zephir_has_constructor(&_1)) { @@ -176,7 +176,7 @@ PHP_METHOD(Phalcon_Http_Response, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 919, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 920, &_1); if (!ZEPHIR_IS_NULL(&content_zv)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "setContent", NULL, 0, &content_zv); zephir_check_call_status(); @@ -216,7 +216,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, 920, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 921, &_1); RETURN_THIS(); } @@ -240,7 +240,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, 920, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 921, PH_NOISY_CC); zephir_cast_to_string(&_1, &_0); RETURN_CTOR(&_1); } @@ -274,7 +274,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, 921, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 922, 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); @@ -288,7 +288,7 @@ PHP_METHOD(Phalcon_Http_Response, getDI) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 921, &container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 922, &container); } RETURN_CCTOR(&container); } @@ -330,7 +330,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, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 919, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "Status"); ZEPHIR_CALL_METHOD(&_1, &_0, "get", NULL, 0, &_2); @@ -378,7 +378,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, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 919, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "Status"); ZEPHIR_CALL_METHOD(&_1, &_0, "get", NULL, 0, &_2); @@ -602,7 +602,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, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 919, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "remove", NULL, 0, &name_zv); zephir_check_call_status(); RETURN_THIS(); @@ -626,7 +626,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, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 919, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "reset", NULL, 0); zephir_check_call_status(); RETURN_THIS(); @@ -666,7 +666,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, 922, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 923, 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); @@ -680,12 +680,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, 920, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 921, 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, 923, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_2, 924, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&file, &_3$$5); _4$$5 = Z_TYPE_P(&file) == IS_STRING; if (_4$$5) { @@ -697,9 +697,9 @@ PHP_METHOD(Phalcon_Http_Response, send) } } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 922, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 923, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 922, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 923, &__$false); } RETURN_THIS(); } @@ -723,7 +723,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, 924, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 925, 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); @@ -761,9 +761,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, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 919, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&headers, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 925, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 926, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_0); _1 = Z_TYPE_P(&eventsManager) != IS_NULL; if (_1) { @@ -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, 920, &content_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 921, &content_zv); RETURN_THISW(); } @@ -965,7 +965,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, 924, cookies); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 925, cookies); RETURN_THISW(); } @@ -987,7 +987,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, 921, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 922, container); } /** @@ -1196,7 +1196,7 @@ PHP_METHOD(Phalcon_Http_Response, setFileToSend) zephir_check_call_status(); } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 923, &filePath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 924, &filePath_zv); RETURN_THIS(); } @@ -1232,7 +1232,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, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 919, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &name_zv, value); zephir_check_call_status(); RETURN_THIS(); @@ -1294,7 +1294,7 @@ PHP_METHOD(Phalcon_Http_Response, setHeaders) } ZEPHIR_INIT_NVAR(&value); ZVAL_COPY(&value, _2); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 919, PH_NOISY_CC | PH_READONLY); zephir_cast_to_string(&_6$$3, &value); ZEPHIR_CALL_METHOD(NULL, &_5$$3, "set", NULL, 0, &name, &_6$$3); zephir_check_call_status(); @@ -1319,7 +1319,7 @@ PHP_METHOD(Phalcon_Http_Response, setHeaders) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&value, _0, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$4, this_ptr, _zephir_prop_0, 919, PH_NOISY_CC | PH_READONLY); zephir_cast_to_string(&_10$$4, &value); ZEPHIR_CALL_METHOD(NULL, &_9$$4, "set", NULL, 0, &name, &_10$$4); zephir_check_call_status(); @@ -1381,7 +1381,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, 919, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 920, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_3, jsonOptions); ZVAL_LONG(&_4, depth); ZEPHIR_CALL_METHOD(&_2, &_1, "__invoke", NULL, 0, content, &_3, &_4); @@ -1496,7 +1496,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, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 919, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "setRaw", NULL, 0, &header_zv); zephir_check_call_status(); RETURN_THIS(); @@ -1563,7 +1563,7 @@ PHP_METHOD(Phalcon_Http_Response, setStatusCode) } else { zephir_get_strval(&message, message_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 919, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(¤tHeadersRaw, &_0, "toArray", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(¤tHeadersRaw) == IS_STRING) { @@ -1595,7 +1595,7 @@ PHP_METHOD(Phalcon_Http_Response, setStatusCode) _7$$3 = zephir_is_true(&_9$$3); } if (_7$$3) { - zephir_read_property_cached(&_11$$4, this_ptr, _zephir_prop_0, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$4, this_ptr, _zephir_prop_0, 919, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_11$$4, "remove", NULL, 0, &key); zephir_check_call_status(); } @@ -1629,7 +1629,7 @@ PHP_METHOD(Phalcon_Http_Response, setStatusCode) _14$$5 = zephir_is_true(&_16$$5); } if (_14$$5) { - zephir_read_property_cached(&_17$$6, this_ptr, _zephir_prop_0, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$6, this_ptr, _zephir_prop_0, 919, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_17$$6, "remove", NULL, 0, &key); zephir_check_call_status(); } @@ -1653,14 +1653,14 @@ PHP_METHOD(Phalcon_Http_Response, setStatusCode) zephir_array_fetch_long(&defaultMessage, &statusCodes, code, PH_NOISY, "phalcon/Http/Response.zep", 717); zephir_get_strval(&message, &defaultMessage); } - zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19, this_ptr, _zephir_prop_0, 919, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_20); ZVAL_LONG(&_20, code); ZEPHIR_INIT_VAR(&_21); ZEPHIR_CONCAT_SVSV(&_21, "HTTP/1.1 ", &_20, " ", &message); ZEPHIR_CALL_METHOD(NULL, &_19, "setRaw", NULL, 0, &_21); zephir_check_call_status(); - zephir_read_property_cached(&_22, this_ptr, _zephir_prop_0, 918, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22, this_ptr, _zephir_prop_0, 919, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_23); ZVAL_LONG(&_23, code); ZEPHIR_INIT_VAR(&_24); @@ -1721,19 +1721,19 @@ PHP_METHOD(Phalcon_Http_Response, setEventsManager) _2 = ZEPHIR_IS_TRUE_IDENTICAL(&_1); if (_2) { zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 921, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 922, PH_NOISY_CC); _2 = Z_TYPE_P(&_3) != IS_NULL; } if (_2) { zephir_memory_observe(&_4$$3); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 921, PH_NOISY_CC); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 922, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_5$$3); ZVAL_STRING(&_5$$3, "eventsManager"); ZVAL_BOOL(&_6$$3, 1); ZEPHIR_CALL_METHOD(NULL, &_4$$3, "set", NULL, 0, &_5$$3, eventsManager, &_6$$3); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 925, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 926, eventsManager); ZEPHIR_MM_RESTORE(); } @@ -1799,16 +1799,16 @@ PHP_METHOD(Phalcon_Http_Response, fireManagerEvent) stopOnFalse = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 925, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 926, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { _1$$3 = stopOnFalse; if (_1$$3) { zephir_memory_observe(&_2$$3); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 925, PH_NOISY_CC); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 926, PH_NOISY_CC); _1$$3 = zephir_instance_of_ev(&_2$$3, phalcon_events_manager_ce); } if (_1$$3) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 925, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 926, PH_NOISY_CC | PH_READONLY); if (cancellable) { ZVAL_BOOL(&_4$$4, 1); } else { @@ -1819,7 +1819,7 @@ PHP_METHOD(Phalcon_Http_Response, fireManagerEvent) zephir_check_call_status(); RETURN_MM(); } - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 925, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 926, PH_NOISY_CC | PH_READONLY); if (cancellable) { ZVAL_BOOL(&_7$$3, 1); } else { diff --git a/ext/phalcon/http/response/cookies.zep.c b/ext/phalcon/http/response/cookies.zep.c index fa6a4b2322..248e048b23 100644 --- a/ext/phalcon/http/response/cookies.zep.c +++ b/ext/phalcon/http/response/cookies.zep.c @@ -167,9 +167,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, 926, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 927, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 926, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 927, &__$false); } ZEPHIR_CALL_METHOD(NULL, this_ptr, "setSignKey", NULL, 0, &signKey_zv); zephir_check_call_status(); @@ -212,7 +212,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, 927, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 928, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&cookie, &_0, &name_zv, 0))) { if (!(zephir_array_isset_value(&_COOKIE, &name_zv))) { RETURN_MM_BOOL(0); @@ -221,9 +221,9 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, delete) object_init_ex(&cookie, phalcon_http_cookie_ce); ZEPHIR_CALL_METHOD(NULL, &cookie, "__construct", NULL, 0, &name_zv); zephir_check_call_status(); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 928, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 929, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_1$$3) != IS_NULL) { - zephir_read_property_cached(&_2$$5, this_ptr, _zephir_prop_1, 928, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$5, this_ptr, _zephir_prop_1, 929, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &cookie, "setDi", NULL, 0, &_2$$5); zephir_check_call_status(); } @@ -275,7 +275,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, 927, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 928, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&cookie, &_0, &name_zv, 0)) { RETURN_CCTOR(&cookie); } @@ -292,11 +292,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, 926, PH_NOISY_CC); + zephir_read_property_cached(&encryption, this_ptr, _zephir_prop_1, 927, 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, 929, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_2, 930, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &cookie, "setSignKey", NULL, 0, &_4$$4); zephir_check_call_status(); } @@ -338,7 +338,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, 927, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 928, PH_NOISY_CC | PH_READONLY); _1 = zephir_array_isset_value(&_0, &name_zv); if (!(_1)) { _1 = zephir_array_isset_value(&_COOKIE, &name_zv); @@ -374,7 +374,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, 927, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 928, &_0); RETURN_THIS(); } @@ -420,7 +420,7 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, send) if (_1) { RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 927, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 928, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_3) == IS_STRING) { ZEPHIR_INIT_VAR(&_5); zephir_string_to_char_array(&_5, &_3); @@ -461,9 +461,9 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, send) } ZEPHIR_INIT_NVAR(&cookie); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 930, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 931, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 930, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 931, &__$false); } RETURN_MM_BOOL(1); } @@ -614,11 +614,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, 926, PH_NOISY_CC); + zephir_read_property_cached(&encryption, this_ptr, _zephir_prop_0, 927, PH_NOISY_CC); zephir_memory_observe(&cookie); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 927, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 928, 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, 928, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 929, 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); @@ -640,13 +640,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, 928, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 929, 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, 929, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_3, 930, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &cookie, "setSignKey", NULL, 0, &_6$$4); zephir_check_call_status(); } @@ -677,11 +677,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, 929, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$5, this_ptr, _zephir_prop_3, 930, 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, 931, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_4, 932, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_FALSE_IDENTICAL(&_10)) { ZEPHIR_CALL_METHOD(&container, this_ptr, "checkGetContainer", NULL, 0); zephir_check_call_status(); @@ -692,9 +692,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, 931, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 932, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 931, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 932, &__$false); } } RETURN_THIS(); @@ -736,7 +736,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, 929, &signKey_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 930, &signKey_zv); RETURN_THIS(); } @@ -761,9 +761,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, 926, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 927, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 926, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 927, &__$false); } RETURN_THISW(); } @@ -785,7 +785,7 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, checkGetContainer) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 928, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 929, 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 dd37970876..3d23cd53d4 100644 --- a/ext/phalcon/http/response/headers.zep.c +++ b/ext/phalcon/http/response/headers.zep.c @@ -87,7 +87,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, 932, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 933, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&headers, &_0); zephir_memory_observe(&headerValue); if (!(zephir_array_isset_fetch(&headerValue, &headers, &name_zv, 0))) { @@ -115,7 +115,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, 932, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 933, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 19, &_0); zephir_check_call_status(); RETURN_MM(); @@ -141,7 +141,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, 932, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 933, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_key_exists(&_0, &name_zv)); } @@ -179,10 +179,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, 932, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 933, 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, 932, &headers); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 933, &headers); RETURN_THIS(); } @@ -205,7 +205,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, 932, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 933, &_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, 933, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 934, 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, 932, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 933, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_3) == IS_STRING) { ZEPHIR_INIT_VAR(&_5); zephir_string_to_char_array(&_5, &_3); @@ -357,9 +357,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, 933, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 934, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 933, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 934, &__$false); } RETURN_MM_BOOL(1); } diff --git a/ext/phalcon/image/adapter/gd.zep.c b/ext/phalcon/image/adapter/gd.zep.c index 592f11527e..726bf5bd51 100644 --- a/ext/phalcon/image/adapter/gd.zep.c +++ b/ext/phalcon/image/adapter/gd.zep.c @@ -193,10 +193,10 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __construct) ZVAL_NULL(&image); ZEPHIR_CALL_METHOD(NULL, this_ptr, "check", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 934, &file_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 935, &file_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 935, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 936, &_0); ZEPHIR_INIT_VAR(&_1); if (maxPixels > 0) { ZEPHIR_INIT_NVAR(&_1); @@ -205,17 +205,17 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __construct) ZEPHIR_INIT_NVAR(&_1); ZVAL_LONG(&_1, 50000000); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 936, &_1); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 934, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 937, &_1); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 935, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, this_ptr, "phpFileExists", NULL, 0, &_0); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_2)) { - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 934, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 935, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_4$$3, "realpath", NULL, 158, &_3$$3); zephir_check_call_status(); zephir_cast_to_string(&_5$$3, &_4$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 937, &_5$$3); - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 934, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 938, &_5$$3); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 935, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&imageInfo, "getimagesize", NULL, 0, &_6$$3); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&imageInfo)) { @@ -229,20 +229,20 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __construct) zephir_check_call_status(); zephir_memory_observe(&_11$$4); zephir_array_fetch_long(&_11$$4, &imageInfo, 0, PH_NOISY, "phalcon/Image/Adapter/Gd.zep", 93); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 938, &_11$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 939, &_11$$4); zephir_memory_observe(&_12$$4); zephir_array_fetch_long(&_12$$4, &imageInfo, 1, PH_NOISY, "phalcon/Image/Adapter/Gd.zep", 94); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 939, &_12$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 940, &_12$$4); zephir_memory_observe(&_13$$4); zephir_array_fetch_long(&_13$$4, &imageInfo, 2, PH_NOISY, "phalcon/Image/Adapter/Gd.zep", 95); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 935, &_13$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 936, &_13$$4); zephir_memory_observe(&_14$$4); zephir_array_fetch_string(&_14$$4, &imageInfo, SL("mime"), PH_NOISY, "phalcon/Image/Adapter/Gd.zep", 96); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 940, &_14$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 941, &_14$$4); } else { ZEPHIR_INIT_VAR(&_15$$5); object_init_ex(&_15$$5, phalcon_image_exceptions_imageloadfailed_ce); - zephir_read_property_cached(&_16$$5, this_ptr, _zephir_prop_0, 934, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$5, this_ptr, _zephir_prop_0, 935, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_15$$5, "__construct", NULL, 0, &_16$$5); zephir_check_call_status(); zephir_throw_exception_debug(&_15$$5, "phalcon/Image/Adapter/Gd.zep", 98); @@ -250,7 +250,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __construct) return; } zephir_memory_observe(&_17$$3); - zephir_read_property_cached(&_17$$3, this_ptr, _zephir_prop_1, 935, PH_NOISY_CC); + zephir_read_property_cached(&_17$$3, this_ptr, _zephir_prop_1, 936, PH_NOISY_CC); if (ZEPHIR_IS_LONG(&_17$$3, 1)) { goto zephir_switch_0_clause_0; } if (ZEPHIR_IS_LONG(&_17$$3, 2)) { goto zephir_switch_0_clause_1; } if (ZEPHIR_IS_LONG(&_17$$3, 9)) { goto zephir_switch_0_clause_2; } @@ -260,40 +260,40 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __construct) if (ZEPHIR_IS_LONG(&_17$$3, 16)) { goto zephir_switch_0_clause_6; } goto zephir_switch_0_clause_7; zephir_switch_0_clause_0: ; - zephir_read_property_cached(&_18$$6, this_ptr, _zephir_prop_0, 934, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$6, this_ptr, _zephir_prop_0, 935, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&image, "imagecreatefromgif", NULL, 0, &_18$$6); zephir_check_call_status(); goto zephir_switch_0_end; zephir_switch_0_clause_1: ; zephir_switch_0_clause_2: ; - zephir_read_property_cached(&_19$$7, this_ptr, _zephir_prop_0, 934, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19$$7, this_ptr, _zephir_prop_0, 935, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&image, "imagecreatefromjpeg", NULL, 0, &_19$$7); zephir_check_call_status(); goto zephir_switch_0_end; zephir_switch_0_clause_3: ; - zephir_read_property_cached(&_20$$8, this_ptr, _zephir_prop_0, 934, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$8, this_ptr, _zephir_prop_0, 935, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&image, "imagecreatefrompng", NULL, 0, &_20$$8); zephir_check_call_status(); goto zephir_switch_0_end; zephir_switch_0_clause_4: ; - zephir_read_property_cached(&_21$$9, this_ptr, _zephir_prop_0, 934, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_21$$9, this_ptr, _zephir_prop_0, 935, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&image, "imagecreatefromwebp", NULL, 0, &_21$$9); zephir_check_call_status(); goto zephir_switch_0_end; zephir_switch_0_clause_5: ; - zephir_read_property_cached(&_22$$10, this_ptr, _zephir_prop_0, 934, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$10, this_ptr, _zephir_prop_0, 935, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&image, "imagecreatefromwbmp", NULL, 0, &_22$$10); zephir_check_call_status(); goto zephir_switch_0_end; zephir_switch_0_clause_6: ; - zephir_read_property_cached(&_23$$11, this_ptr, _zephir_prop_0, 934, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$11, this_ptr, _zephir_prop_0, 935, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&image, "imagecreatefromxbm", NULL, 0, &_23$$11); zephir_check_call_status(); goto zephir_switch_0_end; zephir_switch_0_clause_7: ; 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_6, 940, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$12, this_ptr, _zephir_prop_6, 941, 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", 128); @@ -301,8 +301,8 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __construct) return; zephir_switch_0_end: ; - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 941, &image); - zephir_read_property_cached(&_26$$3, this_ptr, _zephir_prop_7, 941, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 942, &image); + zephir_read_property_cached(&_26$$3, this_ptr, _zephir_prop_7, 942, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 0, &_26$$3, &__$true); zephir_check_call_status(); } else { @@ -313,7 +313,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, 934, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$14, this_ptr, _zephir_prop_0, 935, 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", 137); @@ -324,28 +324,28 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __construct) ZVAL_LONG(&_31$$13, height); ZEPHIR_CALL_FUNCTION(&image, "imagecreatetruecolor", NULL, 0, &_30$$13, &_31$$13); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 941, &image); - zephir_read_property_cached(&_30$$13, this_ptr, _zephir_prop_7, 941, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 942, &image); + zephir_read_property_cached(&_30$$13, this_ptr, _zephir_prop_7, 942, 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_7, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_31$$13, this_ptr, _zephir_prop_7, 942, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 0, &_31$$13, &__$true); zephir_check_call_status(); - zephir_read_property_cached(&_32$$13, this_ptr, _zephir_prop_0, 934, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 937, &_32$$13); + zephir_read_property_cached(&_32$$13, this_ptr, _zephir_prop_0, 935, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 938, &_32$$13); ZVAL_UNDEF(&_33$$13); ZVAL_LONG(&_33$$13, width); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 938, &_33$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 939, &_33$$13); ZVAL_UNDEF(&_33$$13); ZVAL_LONG(&_33$$13, height); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 939, &_33$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 940, &_33$$13); ZVAL_UNDEF(&_33$$13); ZVAL_LONG(&_33$$13, 3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 935, &_33$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 936, &_33$$13); ZEPHIR_INIT_VAR(&_34$$13); ZEPHIR_INIT_NVAR(&_34$$13); ZVAL_STRING(&_34$$13, "image/png"); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 940, &_34$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 941, &_34$$13); } ZEPHIR_MM_RESTORE(); } @@ -363,7 +363,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, 941, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 942, &__$null); } /** @@ -518,10 +518,10 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processBackground) zephir_check_call_status(); zephir_round(&_0, &_4, NULL, NULL); opacity = zephir_get_intval(&_0); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 942, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_5); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 938, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 940, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&background, this_ptr, "processCreate", NULL, 0, &_5, &_6); zephir_check_call_status(); ZVAL_LONG(&_7, red); @@ -532,8 +532,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(&_7, this_ptr, _zephir_prop_1, 938, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 940, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_9, 0); ZVAL_LONG(&_10, 0); ZVAL_LONG(&_11, 0); @@ -541,7 +541,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processBackground) ZEPHIR_CALL_FUNCTION(©, "imagecopy", NULL, 0, &background, &image, &_9, &_10, &_11, &_12, &_7, &_8); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(©)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 941, &background); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 942, &background); } ZEPHIR_MM_RESTORE(); } @@ -568,7 +568,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, 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, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 942, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); counter = 0; while (1) { @@ -666,16 +666,16 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processCrop) ZVAL_LONG(&_0, height); zephir_array_update_string(&rect, SL("height"), &_0, PH_COPY | PH_SEPARATE); zephir_memory_observe(¤t); - zephir_read_property_cached(¤t, this_ptr, _zephir_prop_0, 941, PH_NOISY_CC); + zephir_read_property_cached(¤t, this_ptr, _zephir_prop_0, 942, PH_NOISY_CC); ZEPHIR_CALL_FUNCTION(&image, "imagecrop", NULL, 0, ¤t, &rect); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 941, &image); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 942, &image); ZEPHIR_CALL_FUNCTION(&_1, "imagesx", NULL, 0, &image); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 938, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 939, &_1); ZEPHIR_CALL_FUNCTION(&_2, "imagesy", NULL, 0, &image); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 939, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 940, &_2); ZEPHIR_MM_RESTORE(); } @@ -701,7 +701,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processFlip) 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, &direction_param); - 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, 942, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); if (direction == 11) { ZVAL_LONG(&_1$$3, 1); @@ -784,7 +784,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processMask) ZEPHIR_CALL_FUNCTION(&maskImage, "imagecreatefromstring", NULL, 0, &_0); zephir_check_call_status(); zephir_memory_observe(¤t); - zephir_read_property_cached(¤t, this_ptr, _zephir_prop_0, 941, PH_NOISY_CC); + zephir_read_property_cached(¤t, this_ptr, _zephir_prop_0, 942, PH_NOISY_CC); ZEPHIR_CALL_FUNCTION(&_1, "imagesx", NULL, 0, &maskImage); zephir_check_call_status(); maskWidth = zephir_get_intval(&_1); @@ -794,8 +794,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_1, 938, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_2, 940, 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); @@ -810,21 +810,21 @@ 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_1, 938, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 939, PH_NOISY_CC | PH_READONLY); _9 = !ZEPHIR_IS_LONG_IDENTICAL(&_5, maskWidth); if (!(_9)) { - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 940, PH_NOISY_CC | PH_READONLY); _9 = !ZEPHIR_IS_LONG_IDENTICAL(&_6, maskHeight); } if (_9) { - zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_1, 938, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_1, 939, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&width, &_10$$3); - zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_2, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_2, 940, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&height, &_10$$3); ZEPHIR_CALL_FUNCTION(&tempImage, "imagecreatetruecolor", NULL, 0, &width, &height); zephir_check_call_status(); - zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_1, 938, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_2, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_1, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_2, 940, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_12$$3, 0); ZVAL_LONG(&_13$$3, 0); ZVAL_LONG(&_14$$3, 0); @@ -837,13 +837,13 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processMask) } x = 0; while (1) { - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 938, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 939, PH_NOISY_CC | PH_READONLY); if (!(ZEPHIR_GT_LONG(&_7, x))) { break; } y = 0; while (1) { - zephir_read_property_cached(&_18$$4, this_ptr, _zephir_prop_2, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$4, this_ptr, _zephir_prop_2, 940, PH_NOISY_CC | PH_READONLY); if (!(ZEPHIR_GT_LONG(&_18$$4, y))) { break; } @@ -881,7 +881,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processMask) } x++; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 941, &newImage); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 942, &newImage); ZEPHIR_MM_RESTORE(); } @@ -927,17 +927,17 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, 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, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 942, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); x = 0; while (1) { - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 938, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 939, 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_2, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 940, PH_NOISY_CC | PH_READONLY); if (!(ZEPHIR_GT_LONG(&_1$$3, y))) { break; } @@ -955,10 +955,10 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processPixelate) ZEPHIR_INIT_NVAR(&_5$$4); zephir_add_function(&_5$$4, &_3$$4, &_2$$4); y1 = zephir_get_intval(&_5$$4); - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_1, 938, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_1, 939, PH_NOISY_CC | PH_READONLY); _7$$4 = ZEPHIR_LE_LONG(&_6$$4, x1); if (!(_7$$4)) { - zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_2, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_2, 940, PH_NOISY_CC | PH_READONLY); _7$$4 = ZEPHIR_LE_LONG(&_8$$4, y1); } if (_7$$4) { @@ -1059,7 +1059,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processReflection) zephir_check_call_status(); zephir_round(&_0, &_4, NULL, NULL); opacity = zephir_get_intval(&_0); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 942, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_5); if (opacity < 127) { ZEPHIR_INIT_VAR(&_6$$3); @@ -1070,16 +1070,16 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processReflection) zephir_div_long_long(&_7$$4, 127, height); stepping = zephir_get_intval(&_7$$4); } - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 938, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 940, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_2); ZVAL_LONG(&_2, height); ZEPHIR_INIT_NVAR(&_1); zephir_add_function(&_1, &_8, &_2); ZEPHIR_CALL_METHOD(&reflection, this_ptr, "processCreate", NULL, 0, &_5, &_1); zephir_check_call_status(); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 938, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 940, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_10, 0); ZVAL_LONG(&_11, 0); ZVAL_LONG(&_12, 0); @@ -1091,7 +1091,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processReflection) if (!(height >= offset)) { break; } - zephir_read_property_cached(&_14$$5, this_ptr, _zephir_prop_2, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$5, this_ptr, _zephir_prop_2, 940, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_15$$5); ZVAL_LONG(&_15$$5, offset); ZEPHIR_INIT_NVAR(&_16$$5); @@ -1101,7 +1101,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processReflection) ZEPHIR_INIT_NVAR(&_17$$5); zephir_sub_function(&_17$$5, &_16$$5, &_15$$5); sourceY = zephir_get_intval(&_17$$5); - zephir_read_property_cached(&_14$$5, this_ptr, _zephir_prop_2, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$5, this_ptr, _zephir_prop_2, 940, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_15$$5); ZVAL_LONG(&_15$$5, offset); ZEPHIR_INIT_NVAR(&_18$$5); @@ -1118,11 +1118,11 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processReflection) zephir_round(&_21$$7, &_22$$7, NULL, NULL); destinationOpacity = zephir_get_intval(&_21$$7); } - zephir_read_property_cached(&_14$$5, this_ptr, _zephir_prop_1, 938, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$5, this_ptr, _zephir_prop_1, 939, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_23$$5, 1); ZEPHIR_CALL_METHOD(&line, this_ptr, "processCreate", NULL, 0, &_14$$5, &_23$$5); zephir_check_call_status(); - zephir_read_property_cached(&_23$$5, this_ptr, _zephir_prop_1, 938, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$5, this_ptr, _zephir_prop_1, 939, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_24$$5, 0); ZVAL_LONG(&_25$$5, 0); ZVAL_LONG(&_26$$5, 0); @@ -1137,7 +1137,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processReflection) ZVAL_LONG(&_28$$5, destinationOpacity); ZEPHIR_CALL_FUNCTION(NULL, "imagefilter", &_29, 0, &line, &_24$$5, &_25$$5, &_26$$5, &_27$$5, &_28$$5); zephir_check_call_status(); - zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_1, 938, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24$$5, this_ptr, _zephir_prop_1, 939, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_25$$5, 0); ZVAL_LONG(&_26$$5, destinationY); ZVAL_LONG(&_27$$5, 0); @@ -1147,13 +1147,13 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processReflection) zephir_check_call_status(); offset++; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 941, &reflection); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 942, &reflection); ZEPHIR_CALL_FUNCTION(&_31, "imagesx", NULL, 0, &reflection); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 938, &_31); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 939, &_31); ZEPHIR_CALL_FUNCTION(&_32, "imagesy", NULL, 0, &reflection); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 939, &_32); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 940, &_32); ZEPHIR_MM_RESTORE(); } @@ -1185,7 +1185,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, 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, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 942, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); ZEPHIR_INIT_VAR(&_1); zephir_fast_strtolower(&_1, &extension); @@ -1283,7 +1283,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processResize) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 2, 0, &width_param, &height_param); zephir_memory_observe(¤t); - zephir_read_property_cached(¤t, this_ptr, _zephir_prop_0, 941, PH_NOISY_CC); + zephir_read_property_cached(¤t, this_ptr, _zephir_prop_0, 942, PH_NOISY_CC); ZVAL_LONG(&_0, width); ZVAL_LONG(&_1, height); ZEPHIR_CALL_FUNCTION(&image, "imagecreatetruecolor", NULL, 0, &_0, &_1); @@ -1292,8 +1292,8 @@ 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_1, 938, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 940, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2, 0); ZVAL_LONG(&_3, 0); ZVAL_LONG(&_4, 0); @@ -1302,13 +1302,13 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processResize) ZVAL_LONG(&_7, height); ZEPHIR_CALL_FUNCTION(NULL, "imagecopyresampled", NULL, 0, &image, ¤t, &_2, &_3, &_4, &_5, &_6, &_7, &_0, &_1); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 941, &image); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 942, &image); ZEPHIR_CALL_FUNCTION(&_8, "imagesx", NULL, 0, &image); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 938, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 939, &_8); ZEPHIR_CALL_FUNCTION(&_9, "imagesy", NULL, 0, &image); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 939, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 940, &_9); ZEPHIR_MM_RESTORE(); } @@ -1351,7 +1351,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processRotate) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, °rees_param); zephir_memory_observe(¤t); - zephir_read_property_cached(¤t, this_ptr, _zephir_prop_0, 941, PH_NOISY_CC); + zephir_read_property_cached(¤t, this_ptr, _zephir_prop_0, 942, PH_NOISY_CC); ZVAL_LONG(&_0, 0); ZVAL_LONG(&_1, 0); ZVAL_LONG(&_2, 0); @@ -1375,9 +1375,9 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processRotate) ZEPHIR_CALL_FUNCTION(©, "imagecopymerge", NULL, 0, ¤t, &image, &_0, &_1, &_2, &_3, &width, &height, &_4); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(©)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 941, &image); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 938, &width); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 939, &height); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 942, &image); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 939, &width); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 940, &height); } ZEPHIR_MM_RESTORE(); } @@ -1436,13 +1436,13 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSave) quality_param = ZEND_CALL_ARG(execute_data, 2); zephir_memory_observe(&file_zv); ZVAL_STR_COPY(&file_zv, file); - 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, 942, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); ZVAL_LONG(&_0, 4); ZEPHIR_CALL_FUNCTION(&extension, "pathinfo", NULL, 206, &file_zv, &_0); zephir_check_call_status(); if (1 == ZEPHIR_IS_EMPTY(&extension)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 935, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 936, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_2$$3, "image_type_to_extension", NULL, 0, &_1$$3, &__$false); zephir_check_call_status(); zephir_cast_to_string(&_3$$3, &_2$$3); @@ -1462,7 +1462,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSave) zephir_switch_0_clause_0: ; ZVAL_UNDEF(&_5$$4); ZVAL_LONG(&_5$$4, 1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 935, &_5$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 936, &_5$$4); ZEPHIR_CALL_FUNCTION(NULL, "imagegif", NULL, 0, &image, &file_zv); zephir_check_call_status(); goto zephir_switch_0_end; @@ -1470,7 +1470,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSave) zephir_switch_0_clause_2: ; ZVAL_UNDEF(&_6$$5); ZVAL_LONG(&_6$$5, 2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 935, &_6$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 936, &_6$$5); if (quality >= 0) { ZVAL_LONG(&_8$$6, quality); ZVAL_LONG(&_9$$6, 1); @@ -1488,28 +1488,28 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSave) zephir_switch_0_clause_3: ; ZVAL_UNDEF(&_10$$8); ZVAL_LONG(&_10$$8, 3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 935, &_10$$8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 936, &_10$$8); ZEPHIR_CALL_FUNCTION(NULL, "imagepng", NULL, 0, &image, &file_zv); zephir_check_call_status(); goto zephir_switch_0_end; zephir_switch_0_clause_4: ; ZVAL_UNDEF(&_11$$9); ZVAL_LONG(&_11$$9, 15); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 935, &_11$$9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 936, &_11$$9); ZEPHIR_CALL_FUNCTION(NULL, "imagewbmp", NULL, 0, &image, &file_zv); zephir_check_call_status(); goto zephir_switch_0_end; zephir_switch_0_clause_5: ; ZVAL_UNDEF(&_12$$10); ZVAL_LONG(&_12$$10, 18); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 935, &_12$$10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 936, &_12$$10); ZEPHIR_CALL_FUNCTION(NULL, "imagewebp", NULL, 0, &image, &file_zv); zephir_check_call_status(); goto zephir_switch_0_end; zephir_switch_0_clause_6: ; ZVAL_UNDEF(&_13$$11); ZVAL_LONG(&_13$$11, 16); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 935, &_13$$11); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 936, &_13$$11); ZEPHIR_CALL_FUNCTION(NULL, "imagexbm", NULL, 0, &image, &file_zv); zephir_check_call_status(); goto zephir_switch_0_end; @@ -1523,10 +1523,10 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSave) return; zephir_switch_0_end: ; - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 935, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 936, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_15, "image_type_to_mime_type", NULL, 0, &_0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 940, &_15); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 941, &_15); RETURN_MM_BOOL(1); } @@ -1614,7 +1614,7 @@ 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, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 942, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_5); ZVAL_LONG(&_5, (amount - 8)); ZVAL_LONG(&_6, 0); @@ -1623,10 +1623,10 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSharpen) if (ZEPHIR_IS_TRUE_IDENTICAL(&result)) { ZEPHIR_CALL_FUNCTION(&_7$$3, "imagesx", NULL, 0, &image); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 938, &_7$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 939, &_7$$3); ZEPHIR_CALL_FUNCTION(&_8$$3, "imagesy", NULL, 0, &image); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 939, &_8$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 940, &_8$$3); } ZEPHIR_MM_RESTORE(); } @@ -1731,7 +1731,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processText) zephir_memory_observe(&fontFile_zv); ZVAL_STR_COPY(&fontFile_zv, fontFile); } - 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, 942, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); bottomLeftX = 0; bottomLeftY = 0; @@ -1797,7 +1797,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processText) ZEPHIR_INIT_VAR(&height); zephir_add_function(&height, &_15$$3, &_16$$3); if (ZEPHIR_LT_LONG(offsetX, 0)) { - zephir_read_property_cached(&_17$$6, this_ptr, _zephir_prop_1, 938, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$6, this_ptr, _zephir_prop_1, 939, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_18$$6); zephir_sub_function(&_18$$6, &_17$$6, &width); ZEPHIR_INIT_VAR(&_19$$6); @@ -1805,7 +1805,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processText) ZEPHIR_CPY_WRT(offsetX, &_19$$6); } if (ZEPHIR_LT_LONG(offsetY, 0)) { - zephir_read_property_cached(&_20$$7, this_ptr, _zephir_prop_2, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$7, this_ptr, _zephir_prop_2, 940, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_21$$7); zephir_sub_function(&_21$$7, &_20$$7, &height); ZEPHIR_INIT_VAR(&_22$$7); @@ -1834,7 +1834,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processText) ZEPHIR_CALL_FUNCTION(&height, "imagefontheight", NULL, 0, &_25$$8); zephir_check_call_status(); if (ZEPHIR_LT_LONG(offsetX, 0)) { - zephir_read_property_cached(&_28$$9, this_ptr, _zephir_prop_1, 938, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$9, this_ptr, _zephir_prop_1, 939, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_29$$9); zephir_sub_function(&_29$$9, &_28$$9, &width); ZEPHIR_INIT_VAR(&_30$$9); @@ -1842,7 +1842,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processText) ZEPHIR_CPY_WRT(offsetX, &_30$$9); } if (ZEPHIR_LT_LONG(offsetY, 0)) { - zephir_read_property_cached(&_31$$10, this_ptr, _zephir_prop_2, 939, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_31$$10, this_ptr, _zephir_prop_2, 940, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_32$$10); zephir_sub_function(&_32$$10, &_31$$10, &height); ZEPHIR_INIT_VAR(&_33$$10); @@ -1910,7 +1910,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processWatermark) zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&overlay, "imagecreatefromstring", NULL, 0, &_0); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 941, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 942, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_1); ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 0, &overlay, &__$true); zephir_check_call_status(); diff --git a/ext/phalcon/image/adapter/imagick.zep.c b/ext/phalcon/image/adapter/imagick.zep.c index 11d1c81ce7..330157d930 100644 --- a/ext/phalcon/image/adapter/imagick.zep.c +++ b/ext/phalcon/image/adapter/imagick.zep.c @@ -207,8 +207,8 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, __construct) object_init_ex(&image, zephir_get_internal_ce(SL("imagick"))); ZEPHIR_CALL_METHOD(NULL, &image, "__construct", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 942, &file_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 943, &image); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 943, &file_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 944, &image); ZEPHIR_INIT_VAR(&_0); if (maxPixels > 0) { ZEPHIR_INIT_NVAR(&_0); @@ -217,17 +217,17 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, __construct) ZEPHIR_INIT_NVAR(&_0); ZVAL_LONG(&_0, 50000000); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 944, &_0); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 942, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 945, &_0); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 943, 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, 942, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 943, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_4$$3, "realpath", NULL, 158, &_3$$3); zephir_check_call_status(); zephir_cast_to_string(&_5$$3, &_4$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 945, &_5$$3); - zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_3, 945, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 946, &_5$$3); + zephir_read_property_cached(&_7$$3, this_ptr, _zephir_prop_3, 946, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_6$$3, &image, "pingImage", NULL, 0, &_7$$3); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_6$$3)) { @@ -242,13 +242,13 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, __construct) ZEPHIR_CALL_METHOD(NULL, &image, "clear", NULL, 0); zephir_check_call_status(); } - zephir_read_property_cached(&_13$$3, this_ptr, _zephir_prop_3, 945, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$3, this_ptr, _zephir_prop_3, 946, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_12$$3, &image, "readImage", NULL, 0, &_13$$3); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_12$$3)) { ZEPHIR_INIT_VAR(&_14$$5); object_init_ex(&_14$$5, phalcon_image_exceptions_imageloadfailed_ce); - zephir_read_property_cached(&_15$$5, this_ptr, _zephir_prop_0, 942, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$5, this_ptr, _zephir_prop_0, 943, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_14$$5, "__construct", NULL, 0, &_15$$5); zephir_check_call_status(); zephir_throw_exception_debug(&_14$$5, "phalcon/Image/Adapter/Imagick.zep", 113); @@ -267,7 +267,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, __construct) } ZEPHIR_CALL_METHOD(&_19$$3, &image, "getImageType", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 946, &_19$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 947, &_19$$3); ZEPHIR_INIT_VAR(&_20$$3); ZEPHIR_CALL_METHOD(&_21$$3, &image, "getImageFormat", NULL, 0); zephir_check_call_status(); @@ -282,7 +282,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, __construct) ZEPHIR_CALL_METHOD(NULL, &image, "destroy", NULL, 0); zephir_check_call_status(); ZEPHIR_CPY_WRT(&image, &coalesced); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 943, &image); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 944, &image); } } else { _23$$8 = 0 == width; @@ -292,7 +292,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, __construct) if (_23$$8) { ZEPHIR_INIT_VAR(&_24$$9); object_init_ex(&_24$$9, phalcon_image_exceptions_imageloadfailed_ce); - zephir_read_property_cached(&_25$$9, this_ptr, _zephir_prop_0, 942, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$9, this_ptr, _zephir_prop_0, 943, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_24$$9, "__construct", NULL, 0, &_25$$9); zephir_check_call_status(); zephir_throw_exception_debug(&_24$$9, "phalcon/Image/Adapter/Imagick.zep", 138); @@ -317,23 +317,23 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, __construct) ZVAL_STRING(&_27$$8, "png"); ZEPHIR_CALL_METHOD(NULL, &image, "setImageFormat", NULL, 0, &_27$$8); zephir_check_call_status(); - zephir_read_property_cached(&_28$$8, this_ptr, _zephir_prop_0, 942, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 945, &_28$$8); + zephir_read_property_cached(&_28$$8, this_ptr, _zephir_prop_0, 943, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 946, &_28$$8); } ZEPHIR_CALL_METHOD(&_30, &image, "getImageWidth", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 947, &_30); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 948, &_30); ZEPHIR_CALL_METHOD(&_31, &image, "getImageHeight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 948, &_31); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 949, &_31); ZEPHIR_CALL_METHOD(&_32, &image, "getImageType", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 946, &_32); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 947, &_32); ZEPHIR_CALL_METHOD(&_33, &image, "getImageFormat", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_34); ZEPHIR_CONCAT_SV(&_34, "image/", &_33); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 949, &_34); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 950, &_34); ZEPHIR_MM_RESTORE(); } @@ -358,12 +358,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, 943, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 944, PH_NOISY_CC); if (zephir_is_instance_of(&_0, SL("Imagick"))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 944, 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, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 944, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_2$$3, "destroy", NULL, 0); zephir_check_call_status(); } @@ -462,7 +462,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, liquidRescale) rigidity = 0; } else { } - 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, 944, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); ZVAL_LONG(&_0, 0); ZEPHIR_CALL_METHOD(NULL, &image, "setIteratorIndex", NULL, 0, &_0); @@ -494,10 +494,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, 947, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 948, &_10); ZEPHIR_CALL_METHOD(&_11, &image, "getImageHeight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 948, &_11); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 949, &_11); RETURN_THIS(); } @@ -534,7 +534,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, setResourceLimit) 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, &type_param, &limit_param); - 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, 944, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); _1 = type >= 0; if (_1) { @@ -643,7 +643,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, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 944, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_1); ZVAL_LONG(&_1, 0); ZEPHIR_CALL_METHOD(NULL, &image, "setIteratorIndex", NULL, 0, &_1); @@ -652,8 +652,8 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processBackground) if (!(1)) { break; } - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 948, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 948, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 949, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &background, "newImage", &_6, 0, &_4$$3, &_5$$3, &pixel1); zephir_check_call_status(); @@ -728,7 +728,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processBackground) zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &image, "destroy", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 943, &background); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 944, &background); ZEPHIR_MM_RESTORE(); } @@ -761,7 +761,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, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 944, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); ZVAL_LONG(&_0, 0); ZEPHIR_CALL_METHOD(NULL, &image, "setIteratorIndex", NULL, 0, &_0); @@ -827,7 +827,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, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 944, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); ZVAL_LONG(&_0, 0); ZEPHIR_CALL_METHOD(NULL, &image, "setIteratorIndex", NULL, 0, &_0); @@ -856,10 +856,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, 947, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 948, &_9); ZEPHIR_CALL_METHOD(&_10, &image, "getImageHeight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 948, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 949, &_10); ZEPHIR_MM_RESTORE(); } @@ -898,7 +898,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, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 944, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); ZVAL_LONG(&_0, 0); ZEPHIR_CALL_METHOD(NULL, &image, "setIteratorIndex", NULL, 0, &_0); @@ -960,7 +960,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processMask) ZEPHIR_CALL_METHOD(NULL, &image, "__construct", NULL, 0); zephir_check_call_status(); zephir_memory_observe(¤t); - zephir_read_property_cached(¤t, this_ptr, _zephir_prop_0, 943, PH_NOISY_CC); + zephir_read_property_cached(¤t, this_ptr, _zephir_prop_0, 944, PH_NOISY_CC); ZEPHIR_CALL_METHOD(&_0, mask, "render", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &image, "readImageBlob", NULL, 0, &_0); @@ -1044,15 +1044,15 @@ 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, 947, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 948, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_div_zval_long(&_1, &_0, amount); width = zephir_get_intval(&_1); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 948, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 949, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); zephir_div_zval_long(&_2, &_0, amount); height = zephir_get_intval(&_2); - 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, 944, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); ZVAL_LONG(&_0, 0); ZEPHIR_CALL_METHOD(NULL, &image, "setIteratorIndex", NULL, 0, &_0); @@ -1065,8 +1065,8 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processPixelate) ZVAL_LONG(&_4$$3, height); ZEPHIR_CALL_METHOD(NULL, &image, "scaleImage", &_5, 0, &_3$$3, &_4$$3); zephir_check_call_status(); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 947, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 948, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 948, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 949, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &image, "scaleImage", &_6, 0, &_3$$3, &_4$$3); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_7$$3, &image, "nextImage", &_8, 0); @@ -1166,8 +1166,8 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processReflection) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 3, 0, &height_param, &opacity_param, &fadeIn_param); zephir_memory_observe(¤t); - zephir_read_property_cached(¤t, this_ptr, _zephir_prop_0, 943, PH_NOISY_CC); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 950, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(¤t, this_ptr, _zephir_prop_0, 944, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 951, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&reflection); if (ZEPHIR_GE_LONG(&_0, 30100)) { if (zephir_clone(&reflection, ¤t) == FAILURE) { @@ -1292,7 +1292,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processReflection) if (!(1)) { break; } - zephir_read_property_cached(&_31$$10, this_ptr, _zephir_prop_2, 947, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_31$$10, this_ptr, _zephir_prop_2, 948, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_32$$10, height); ZEPHIR_CALL_METHOD(NULL, &image, "newImage", &_33, 0, &_31$$10, &_32$$10, &pixel); zephir_check_call_status(); @@ -1347,7 +1347,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processReflection) ZVAL_STRING(&_46$$13, "Imagick::COMPOSITE_OVER"); ZEPHIR_CALL_FUNCTION(&_47$$13, "constant", &_18, 149, &_46$$13); zephir_check_call_status(); - zephir_read_property_cached(&_48$$13, this_ptr, _zephir_prop_3, 948, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_48$$13, this_ptr, _zephir_prop_3, 949, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_49$$13, 0); ZEPHIR_CALL_METHOD(&result, &image, "compositeImage", &_43, 0, &reflection, &_47$$13, &_49$$13, &_48$$13); zephir_check_call_status(); @@ -1378,13 +1378,13 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processReflection) zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, ¤t, "destroy", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 943, &image); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 944, &image); ZEPHIR_CALL_METHOD(&_28, &image, "getImageWidth", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 947, &_28); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 948, &_28); ZEPHIR_CALL_METHOD(&_55, &image, "getImageHeight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 948, &_55); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 949, &_55); ZEPHIR_MM_RESTORE(); } @@ -1432,7 +1432,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, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 944, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); ZEPHIR_CALL_METHOD(NULL, &image, "setFormat", NULL, 0, &extension); zephir_check_call_status(); @@ -1442,12 +1442,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, 946, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 947, &_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, 949, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 950, &_3); ZEPHIR_INIT_VAR(&_4); zephir_fast_strtolower(&_4, &extension); zephir_get_strval(&extension, &_4); @@ -1521,7 +1521,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, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 944, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); ZVAL_LONG(&_0, 0); ZEPHIR_CALL_METHOD(NULL, &image, "setIteratorIndex", NULL, 0, &_0); @@ -1542,10 +1542,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, 947, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 948, &_6); ZEPHIR_CALL_METHOD(&_7, &image, "getImageHeight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 948, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 949, &_7); ZEPHIR_MM_RESTORE(); } @@ -1591,7 +1591,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, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 944, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); ZVAL_LONG(&_0, 0); ZEPHIR_CALL_METHOD(NULL, &image, "setIteratorIndex", NULL, 0, &_0); @@ -1607,8 +1607,8 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processRotate) ZVAL_LONG(&_1$$3, degrees); ZEPHIR_CALL_METHOD(NULL, &image, "rotateImage", &_2, 0, &pixel, &_1$$3); zephir_check_call_status(); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 947, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 948, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 948, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 949, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_4$$3, 0); ZVAL_LONG(&_5$$3, 0); ZEPHIR_CALL_METHOD(NULL, &image, "setImagePage", &_6, 0, &_1$$3, &_3$$3, &_4$$3, &_5$$3); @@ -1621,10 +1621,10 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processRotate) } ZEPHIR_CALL_METHOD(&_9, &image, "getImageWidth", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 947, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 948, &_9); ZEPHIR_CALL_METHOD(&_10, &image, "getImageHeight", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 948, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 949, &_10); ZEPHIR_MM_RESTORE(); } @@ -1678,7 +1678,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processSave) quality_param = ZEND_CALL_ARG(execute_data, 2); zephir_memory_observe(&file_zv); ZVAL_STR_COPY(&file_zv, file); - 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, 944, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); ZVAL_LONG(&_0, 4); ZEPHIR_CALL_FUNCTION(&extension, "pathinfo", NULL, 206, &file_zv, &_0); @@ -1689,12 +1689,12 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processSave) 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, 946, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 947, &_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, 949, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 950, &_3); ZEPHIR_INIT_VAR(&_4); zephir_fast_strtolower(&_4, &extension); ZEPHIR_CPY_WRT(&extension, &_4); @@ -1782,7 +1782,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processSharpen) } amount = zephir_get_intval(&_0); sigma = (zephir_safe_div_double_long(((double) amount * 3.0), 100)); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 944, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_1); ZVAL_LONG(&_1, 0); ZEPHIR_CALL_METHOD(NULL, &image, "setIteratorIndex", NULL, 0, &_1); @@ -2089,7 +2089,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processText) _22 = zephir_get_intval(offsetY); ZEPHIR_INIT_NVAR(offsetY); ZVAL_LONG(offsetY, _22); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 943, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 944, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_1); ZVAL_LONG(&_1, 0); ZEPHIR_CALL_METHOD(NULL, &image, "setIteratorIndex", NULL, 0, &_1); @@ -2177,7 +2177,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processWatermark) ZEPHIR_CALL_METHOD(NULL, &image, "evaluateImage", NULL, 0, &_2, &_4, &_3); zephir_check_call_status(); zephir_memory_observe(¤t); - zephir_read_property_cached(¤t, this_ptr, _zephir_prop_0, 943, PH_NOISY_CC); + zephir_read_property_cached(¤t, this_ptr, _zephir_prop_0, 944, PH_NOISY_CC); ZVAL_LONG(&_4, 0); ZEPHIR_CALL_METHOD(NULL, ¤t, "setIteratorIndex", NULL, 0, &_4); zephir_check_call_status(); @@ -2254,7 +2254,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, check) ZVAL_STRING(&_3$$4, "Imagick::IMAGICK_EXTNUM"); ZEPHIR_CALL_FUNCTION(&_4$$4, "constant", NULL, 149, &_3$$4); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 950, &_4$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 951, &_4$$4); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/logger/abstractlogger.zep.c b/ext/phalcon/logger/abstractlogger.zep.c index 2b9d5e9bab..7d22252014 100644 --- a/ext/phalcon/logger/abstractlogger.zep.c +++ b/ext/phalcon/logger/abstractlogger.zep.c @@ -250,15 +250,15 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, __construct) ZEPHIR_CALL_METHOD(NULL, timezone, "__construct", NULL, 0, &defaultTimezone); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 282, &name_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 283, timezone); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 283, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 284, timezone); if (Z_TYPE_P(clock) == IS_NULL) { ZEPHIR_INIT_NVAR(clock); object_init_ex(clock, phalcon_time_clock_systemclock_ce); ZEPHIR_CALL_METHOD(NULL, clock, "__construct", NULL, 262, timezone); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 284, clock); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 285, clock); ZEPHIR_CALL_METHOD(NULL, this_ptr, "setAdapters", NULL, 0, &adapters); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -313,8 +313,8 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, begin) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 285, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 286, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 286, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 287, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&collection, "array_diff_key", NULL, 9, &_0, &_1); zephir_check_call_status(); if (Z_TYPE_P(&collection) == IS_STRING) { @@ -387,8 +387,8 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, commit) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 285, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 286, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 286, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 287, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&collection, "array_diff_key", NULL, 9, &_0, &_1); zephir_check_call_status(); if (Z_TYPE_P(&collection) == IS_STRING) { @@ -471,7 +471,7 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, excludeAdapters) zephir_get_arrval(&adapters, adapters_param); } zephir_memory_observe(®istered); - zephir_read_property_cached(®istered, this_ptr, _zephir_prop_0, 285, PH_NOISY_CC); + zephir_read_property_cached(®istered, this_ptr, _zephir_prop_0, 286, PH_NOISY_CC); zephir_is_iterable(&adapters, 0, "phalcon/Logger/AbstractLogger.zep", 217); if (Z_TYPE_P(&adapters) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&adapters), _0) @@ -539,7 +539,7 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, getAdapter) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 285, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 286, PH_NOISY_CC | PH_READONLY); if (1 != zephir_array_isset_value(&_0, &name_zv)) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_logger_exceptions_adapternotfound_ce); @@ -549,7 +549,7 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, getAdapter) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 285, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 286, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_3); zephir_array_fetch(&_3, &_2, &name_zv, PH_NOISY, "phalcon/Logger/AbstractLogger.zep", 231); RETURN_CCTOR(&_3); @@ -614,7 +614,7 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, removeAdapter) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 285, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 286, PH_NOISY_CC | PH_READONLY); if (1 != zephir_array_isset_value(&_0, &name_zv)) { ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_logger_exceptions_adapternotfound_ce); @@ -656,8 +656,8 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, rollback) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 285, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 286, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 286, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 287, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&collection, "array_diff_key", NULL, 9, &_0, &_1); zephir_check_call_status(); if (Z_TYPE_P(&collection) == IS_STRING) { @@ -727,7 +727,7 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, setAdapters) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &adapters_param); zephir_get_arrval(&adapters, adapters_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 285, &adapters); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 286, &adapters); RETURN_THIS(); } @@ -768,7 +768,7 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, setLogLevel) ZEPHIR_INIT_NVAR(&_0); ZVAL_LONG(&_0, 8); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 287, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 288, &_0); RETURN_THIS(); } @@ -846,9 +846,9 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, addMessage) } else { zephir_get_arrval(&context, context_param); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 287, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_GE_LONG(&_0, level)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 285, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 286, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_1$$3)) { ZEPHIR_INIT_VAR(&_2$$4); object_init_ex(&_2$$4, phalcon_logger_exceptions_noadaptersconfigured_ce); @@ -869,14 +869,14 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, addMessage) } ZEPHIR_INIT_VAR(&item); object_init_ex(&item, phalcon_logger_item_ce); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 284, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 285, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_4$$3, &_3$$3, "now", NULL, 0); zephir_check_call_status(); ZVAL_LONG(&_5$$3, level); ZEPHIR_CALL_METHOD(NULL, &item, "__construct", NULL, 265, &message_zv, &levelName, &_5$$3, &_4$$3, &context); zephir_check_call_status(); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 285, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_3, 286, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 286, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_3, 287, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&collection, "array_diff_key", NULL, 9, &_5$$3, &_6$$3); zephir_check_call_status(); if (Z_TYPE_P(&collection) == IS_STRING) { @@ -935,7 +935,7 @@ PHP_METHOD(Phalcon_Logger_AbstractLogger, addMessage) } ZEPHIR_INIT_VAR(&_14); array_init(&_14); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 286, &_14); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 287, &_14); RETURN_MM_BOOL(1); } diff --git a/ext/phalcon/logger/adapter/stream.zep.c b/ext/phalcon/logger/adapter/stream.zep.c index cfeee38b89..b2fd6d3f90 100644 --- a/ext/phalcon/logger/adapter/stream.zep.c +++ b/ext/phalcon/logger/adapter/stream.zep.c @@ -151,8 +151,8 @@ PHP_METHOD(Phalcon_Logger_Adapter_Stream, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 951, &name_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 952, &mode); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 952, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 953, &mode); ZEPHIR_MM_RESTORE(); } @@ -177,11 +177,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, 953, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 954, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 953, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 954, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&handler, &_1$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 953, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 954, &__$null); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "phpFclose", NULL, 0, &handler); zephir_check_call_status(); RETURN_MM(); @@ -240,25 +240,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, 953, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 954, PH_NOISY_CC | PH_READONLY); if (!(Z_TYPE_P(&_0) == IS_RESOURCE)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 951, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 952, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 952, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 953, 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, 953, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 954, &__$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, 951, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_2, 952, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_1, 952, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_2, 953, 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", 122); ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 953, &fileHandler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 954, &fileHandler); } ZEPHIR_CALL_METHOD(&_6, this_ptr, "getFormattedItem", NULL, 0, item); zephir_check_call_status(); @@ -266,7 +266,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, 953, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 954, 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 d2606fa70c..b4852d79eb 100644 --- a/ext/phalcon/logger/adapter/syslog.zep.c +++ b/ext/phalcon/logger/adapter/syslog.zep.c @@ -128,9 +128,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, 954, &name_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 955, &option); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 956, &facility); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 955, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 956, &option); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 957, &facility); ZEPHIR_MM_RESTORE(); } @@ -152,7 +152,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, 957, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 958, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { RETURN_MM_BOOL(1); } @@ -211,16 +211,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, 954, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 955, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 956, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 955, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 956, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 957, 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, 954, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 956, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 955, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_2, 957, 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", 85); @@ -228,9 +228,9 @@ PHP_METHOD(Phalcon_Logger_Adapter_Syslog, process) return; } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 957, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 958, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 957, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 958, &__$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 b0f3f1cb18..304db10ffc 100644 --- a/ext/phalcon/logger/formatter/json.zep.c +++ b/ext/phalcon/logger/formatter/json.zep.c @@ -97,9 +97,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, 958, &dateFormat_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 959, &interpolatorLeft_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 960, &interpolatorRight_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 959, &dateFormat_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 960, &interpolatorLeft_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 961, &interpolatorRight_zv); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/logger/formatter/line.zep.c b/ext/phalcon/logger/formatter/line.zep.c index f85a50c802..79d9139512 100644 --- a/ext/phalcon/logger/formatter/line.zep.c +++ b/ext/phalcon/logger/formatter/line.zep.c @@ -118,10 +118,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, 961, &format_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 962, &dateFormat_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 963, &interpolatorLeft_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 964, &interpolatorRight_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 962, &format_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 963, &dateFormat_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 964, &interpolatorLeft_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 965, &interpolatorRight_zv); ZEPHIR_MM_RESTORE(); } @@ -173,25 +173,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, 961, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 962, 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, 963, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 964, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 964, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 965, 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, 963, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 964, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 964, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 965, 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, 963, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 964, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 964, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_2, 965, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_11); ZEPHIR_CONCAT_VSV(&_11, &_9, "message", &_10); ZEPHIR_CALL_METHOD(&_5, item, "getMessage", NULL, 0); @@ -240,7 +240,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, 961, &format_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 962, &format_zv); RETURN_THISW(); } diff --git a/ext/phalcon/logger/item.zep.c b/ext/phalcon/logger/item.zep.c index f6c036274f..754d37ff41 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, 965, &message_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 966, &levelName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 966, &message_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 967, &levelName_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, level); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 967, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 968, dateTime); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 969, &context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 968, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 969, dateTime); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 970, &context); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/logger/loggerfactory.zep.c b/ext/phalcon/logger/loggerfactory.zep.c index dad217d4a5..93a5540b79 100644 --- a/ext/phalcon/logger/loggerfactory.zep.c +++ b/ext/phalcon/logger/loggerfactory.zep.c @@ -67,7 +67,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, 970, factory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 971, factory); } /** @@ -202,7 +202,7 @@ PHP_METHOD(Phalcon_Logger_LoggerFactory, load) ZVAL_STRING(&_9$$3, "options"); ZEPHIR_CALL_METHOD(&adapterOptions, this_ptr, "getArrVal", NULL, 0, &adapter, &_9$$3, &_8$$3); zephir_check_call_status(); - zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 970, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$3, this_ptr, _zephir_prop_0, 971, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_11$$3, &_10$$3, "newInstance", NULL, 0, &adapterClass, &adapterFileName, &adapterOptions); zephir_check_call_status(); zephir_array_update_zval(&data, &adapterName, &_11$$3, PH_COPY | PH_SEPARATE); @@ -241,7 +241,7 @@ PHP_METHOD(Phalcon_Logger_LoggerFactory, load) ZVAL_STRING(&_15$$4, "options"); ZEPHIR_CALL_METHOD(&adapterOptions, this_ptr, "getArrVal", NULL, 0, &adapter, &_15$$4, &_14$$4); zephir_check_call_status(); - zephir_read_property_cached(&_16$$4, this_ptr, _zephir_prop_0, 970, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$4, this_ptr, _zephir_prop_0, 971, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_17$$4, &_16$$4, "newInstance", NULL, 0, &adapterClass, &adapterFileName, &adapterOptions); zephir_check_call_status(); zephir_array_update_zval(&data, &adapterName, &_17$$4, PH_COPY | PH_SEPARATE); diff --git a/ext/phalcon/messages/message.zep.c b/ext/phalcon/messages/message.zep.c index 17fc2a7218..f97e0c30c2 100644 --- a/ext/phalcon/messages/message.zep.c +++ b/ext/phalcon/messages/message.zep.c @@ -158,13 +158,13 @@ PHP_METHOD(Phalcon_Messages_Message, __construct) } else { zephir_get_arrval(&metaData, metaData_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 971, &message_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 972, &field_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 973, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 972, &message_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 973, &field_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 974, &type_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, code); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 974, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 975, &metaData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 975, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 976, &metaData); ZEPHIR_MM_RESTORE(); } @@ -247,19 +247,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, 972, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 973, 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, 971, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 972, 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, 973, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 974, 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, 974, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 975, 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, 975, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 976, PH_NOISY_CC); zephir_array_update_string(return_value, SL("metaData"), &_0, PH_COPY | PH_SEPARATE); RETURN_MM(); } @@ -285,7 +285,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, 974, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 975, &_0); RETURN_THISW(); } @@ -308,7 +308,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, 972, &field_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 973, &field_zv); RETURN_THISW(); } @@ -331,7 +331,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, 971, &message_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 972, &message_zv); RETURN_THISW(); } @@ -360,7 +360,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, 975, &metaData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 976, &metaData); RETURN_THIS(); } @@ -383,7 +383,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, 973, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 974, &type_zv); RETURN_THISW(); } diff --git a/ext/phalcon/messages/messages.zep.c b/ext/phalcon/messages/messages.zep.c index 0400713be5..d06e189c8f 100644 --- a/ext/phalcon/messages/messages.zep.c +++ b/ext/phalcon/messages/messages.zep.c @@ -98,7 +98,7 @@ PHP_METHOD(Phalcon_Messages_Messages, __construct) } else { zephir_get_arrval(&messages, messages_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 976, &messages); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 977, &messages); ZEPHIR_MM_RESTORE(); } @@ -185,11 +185,11 @@ PHP_METHOD(Phalcon_Messages_Messages, appendMessages) return; } zephir_memory_observe(¤tMessages); - zephir_read_property_cached(¤tMessages, this_ptr, _zephir_prop_0, 976, PH_NOISY_CC); + zephir_read_property_cached(¤tMessages, this_ptr, _zephir_prop_0, 977, PH_NOISY_CC); if (Z_TYPE_P(messages) == IS_ARRAY) { ZEPHIR_INIT_VAR(&finalMessages); zephir_fast_array_merge(&finalMessages, ¤tMessages, messages); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 976, &finalMessages); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 977, &finalMessages); } else { ZEPHIR_CALL_METHOD(NULL, messages, "rewind", NULL, 0); zephir_check_call_status(); @@ -247,7 +247,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, 976, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 977, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&messages, &_0); if (Z_TYPE_P(&messages) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); @@ -338,7 +338,7 @@ PHP_METHOD(Phalcon_Messages_Messages, jsonSerialize) ZEPHIR_INIT_VAR(&records); array_init(&records); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 976, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 977, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); @@ -426,7 +426,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, 976, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 977, PH_NOISY_CC | PH_READONLY); RETURN_LONG(zephir_fast_count_int(&_0)); } @@ -453,10 +453,10 @@ 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, 976, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 977, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_1); zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 977, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 978, PH_NOISY_CC); zephir_array_fetch(&_1, &_0, &_2, PH_NOISY, "phalcon/Messages/Traits/MessagesHelperTrait.zep", 44); RETURN_CCTOR(&_1); } @@ -505,7 +505,7 @@ PHP_METHOD(Phalcon_Messages_Messages, 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, 976, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 977, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, offset)); } @@ -540,7 +540,7 @@ PHP_METHOD(Phalcon_Messages_Messages, offsetGet) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &offset); zephir_memory_observe(&message); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 976, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 977, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&message, &_0, offset, 0)) { RETURN_CCTOR(&message); } @@ -626,7 +626,7 @@ 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, &offset); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 976, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 977, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, offset)) { zephir_memory_observe(&_1$$3); _2$$3 = zephir_fetch_property_write(this_ptr, _zephir_prop_0, &_1$$3); @@ -654,7 +654,7 @@ PHP_METHOD(Phalcon_Messages_Messages, rewind) } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 977, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 978, &_0); } /** @@ -675,8 +675,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, 976, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 977, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 977, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 978, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &_1)); } diff --git a/ext/phalcon/messages/traits/messageshelpertrait.zep.c b/ext/phalcon/messages/traits/messageshelpertrait.zep.c index 134d6ef148..c96311a84d 100644 --- a/ext/phalcon/messages/traits/messageshelpertrait.zep.c +++ b/ext/phalcon/messages/traits/messageshelpertrait.zep.c @@ -68,7 +68,7 @@ PHP_METHOD(Phalcon_Messages_Traits_MessagesHelperTrait, 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, 978, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 979, PH_NOISY_CC | PH_READONLY); RETURN_LONG(zephir_fast_count_int(&_0)); } @@ -95,10 +95,10 @@ PHP_METHOD(Phalcon_Messages_Traits_MessagesHelperTrait, 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, 978, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 979, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_1); zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 979, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 980, PH_NOISY_CC); zephir_array_fetch(&_1, &_0, &_2, PH_NOISY, "phalcon/Messages/Traits/MessagesHelperTrait.zep", 44); RETURN_CCTOR(&_1); } @@ -147,7 +147,7 @@ PHP_METHOD(Phalcon_Messages_Traits_MessagesHelperTrait, 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, 978, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 979, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, offset)); } @@ -182,7 +182,7 @@ PHP_METHOD(Phalcon_Messages_Traits_MessagesHelperTrait, offsetGet) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &offset); zephir_memory_observe(&message); - 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, 979, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&message, &_0, offset, 0)) { RETURN_CCTOR(&message); } @@ -268,7 +268,7 @@ PHP_METHOD(Phalcon_Messages_Traits_MessagesHelperTrait, 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, &offset); - 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, 979, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, offset)) { zephir_memory_observe(&_1$$3); _2$$3 = zephir_fetch_property_write(this_ptr, _zephir_prop_0, &_1$$3); @@ -296,7 +296,7 @@ PHP_METHOD(Phalcon_Messages_Traits_MessagesHelperTrait, rewind) } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 979, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 980, &_0); } /** @@ -317,8 +317,8 @@ PHP_METHOD(Phalcon_Messages_Traits_MessagesHelperTrait, 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, 978, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 979, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 979, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 980, 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 59590605b3..e3601e23dd 100644 --- a/ext/phalcon/mvc/application.zep.c +++ b/ext/phalcon/mvc/application.zep.c @@ -207,7 +207,7 @@ PHP_METHOD(Phalcon_Mvc_Application, handle) ZVAL_STR_COPY(&uri_zv, uri); ZEPHIR_INIT_VAR(&view); ZVAL_NULL(&view); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 980, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 981, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (Z_TYPE_P(&container) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); @@ -218,7 +218,7 @@ PHP_METHOD(Phalcon_Mvc_Application, handle) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 981, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 982, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_0); _2 = Z_TYPE_P(&eventsManager) != IS_NULL; if (_2) { @@ -282,7 +282,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, 982, PH_NOISY_CC); + zephir_read_property_cached(&moduleName, this_ptr, _zephir_prop_2, 983, PH_NOISY_CC); } ZEPHIR_INIT_VAR(&moduleObject); ZVAL_NULL(&moduleObject); @@ -371,7 +371,7 @@ PHP_METHOD(Phalcon_Mvc_Application, handle) zephir_check_call_status(); } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 983, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 984, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&implicitView, &_0); if (ZEPHIR_IS_TRUE_IDENTICAL(&implicitView)) { ZEPHIR_INIT_VAR(&_25$$23); @@ -498,12 +498,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, 984, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 985, 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, 985, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_45, this_ptr, _zephir_prop_5, 986, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_45)) { ZEPHIR_CALL_METHOD(NULL, &response, "sendCookies", NULL, 0); zephir_check_call_status(); @@ -532,9 +532,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, 985, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 986, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 985, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 986, &__$false); } RETURN_THISW(); } @@ -562,9 +562,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, 984, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 985, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 984, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 985, &__$false); } RETURN_THISW(); } @@ -593,9 +593,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, 983, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 984, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 983, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 984, &__$false); } RETURN_THISW(); } diff --git a/ext/phalcon/mvc/controller.zep.c b/ext/phalcon/mvc/controller.zep.c index f1ae89e9a2..1db07a5422 100644 --- a/ext/phalcon/mvc/controller.zep.c +++ b/ext/phalcon/mvc/controller.zep.c @@ -111,7 +111,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, 986, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 987, PH_NOISY_CC); RETURN_CCTOR(&_0); } @@ -135,7 +135,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, 986, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 987, eventsManager); } /** @@ -192,7 +192,7 @@ PHP_METHOD(Phalcon_Mvc_Controller, fireManagerEvent) } else { } zephir_memory_observe(&eventsManager); - zephir_read_property_cached(&eventsManager, this_ptr, _zephir_prop_0, 986, PH_NOISY_CC); + zephir_read_property_cached(&eventsManager, this_ptr, _zephir_prop_0, 987, 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 c0e8aba8a1..eb9cc38d42 100644 --- a/ext/phalcon/mvc/dispatcher.zep.c +++ b/ext/phalcon/mvc/dispatcher.zep.c @@ -158,7 +158,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, 987, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 988, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_0); if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_1$$3); @@ -246,7 +246,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, 988, &controllerName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 989, &controllerName_zv); RETURN_THISW(); } @@ -269,7 +269,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, 989, &controllerSuffix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 990, &controllerSuffix_zv); RETURN_THISW(); } @@ -292,7 +292,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, 990, &controllerName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 991, &controllerName_zv); RETURN_THISW(); } @@ -322,7 +322,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, 987, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 988, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_0); if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_2$$3); @@ -376,7 +376,7 @@ PHP_METHOD(Phalcon_Mvc_Dispatcher, throwDispatchException) exceptionCode = 0; } else { } - 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, 992, 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 69c03b750b..45ff74420f 100644 --- a/ext/phalcon/mvc/micro.zep.c +++ b/ext/phalcon/mvc/micro.zep.c @@ -295,7 +295,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, 992, handler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 993, handler); RETURN_THISW(); } @@ -384,7 +384,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, 993, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 994, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&modelBinder, &_0); if (Z_TYPE_P(&modelBinder) == IS_NULL) { array_init(return_value); @@ -473,11 +473,11 @@ 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, 994, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkDiContainer", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 995, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_1$$3); ZEPHIR_INIT_VAR(&_3$$3); ZVAL_STRING(&_3$$3, "router"); @@ -501,18 +501,18 @@ PHP_METHOD(Phalcon_Mvc_Micro, getRouter) ZVAL_STRING(&_9$$4, "router"); ZEPHIR_CALL_METHOD(&_7$$4, &container, "getShared", NULL, 0, &_9$$4, &_8$$4); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 994, &_7$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 995, &_7$$4); } else { ZEPHIR_INIT_VAR(&_11$$5); ZVAL_STRING(&_11$$5, "router"); ZEPHIR_CALL_METHOD(&_10$$5, this_ptr, "getSharedService", NULL, 0, &_11$$5); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 994, &_10$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 995, &_10$$5); } - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 994, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_1$$3, "clear", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_12$$3, this_ptr, _zephir_prop_0, 994, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$3, this_ptr, _zephir_prop_0, 995, PH_NOISY_CC | PH_READONLY); ZVAL_BOOL(&_13$$3, 1); ZEPHIR_CALL_METHOD(NULL, &_12$$3, "removeExtraSlashes", NULL, 0, &_13$$3); zephir_check_call_status(); @@ -549,7 +549,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, 995, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 996, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "get", NULL, 0, &serviceName_zv); zephir_check_call_status(); RETURN_MM(); @@ -584,7 +584,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, 995, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 996, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getShared", NULL, 0, &serviceName_zv); zephir_check_call_status(); RETURN_MM(); @@ -809,7 +809,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZVAL_NULL(&returnedValue); ZEPHIR_INIT_VAR(&status); ZVAL_NULL(&status); - 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, 996, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (Z_TYPE_P(&container) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); @@ -825,12 +825,12 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_INIT_NVAR(&returnedValue); ZVAL_NULL(&returnedValue); - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_2$$4) != IS_NULL) { zephir_memory_observe(&_3$$5); - zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC); if (zephir_instance_of_ev(&_3$$5, phalcon_events_manager_ce)) { - zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_9$$6); ZVAL_STRING(&_9$$6, "micro:beforeHandleRoute"); ZVAL_NULL(&_10$$6); @@ -842,7 +842,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) RETURN_MM_BOOL(0); } } else { - zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_6$$5); ZVAL_STRING(&_6$$5, "micro:beforeHandleRoute"); ZEPHIR_CALL_METHOD(&_5$$5, &_4$$5, "fire", NULL, 0, &_6$$5, this_ptr); @@ -863,7 +863,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(&_15$$9, this_ptr, _zephir_prop_2, 997, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$9, this_ptr, _zephir_prop_2, 998, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_16$$9, &matchedRoute, "getRouteId", NULL, 0); zephir_check_call_status_or_jump(try_end_1); if (UNEXPECTED(!(zephir_array_isset_fetch(&handler, &_15$$9, &_16$$9, 0)))) { @@ -875,13 +875,13 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) goto try_end_1; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 998, &handler); - zephir_read_property_cached(&_18$$9, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 999, &handler); + zephir_read_property_cached(&_18$$9, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_18$$9) != IS_NULL) { zephir_memory_observe(&_19$$11); - zephir_read_property_cached(&_19$$11, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC); + zephir_read_property_cached(&_19$$11, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC); if (zephir_instance_of_ev(&_19$$11, phalcon_events_manager_ce)) { - zephir_read_property_cached(&_23$$12, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$12, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_25$$12); ZVAL_STRING(&_25$$12, "micro:beforeExecuteRoute"); ZVAL_NULL(&_26$$12); @@ -893,7 +893,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) RETURN_MM_BOOL(0); } } else { - zephir_read_property_cached(&_20$$11, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$11, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_22$$11); ZVAL_STRING(&_22$$11, "micro:beforeExecuteRoute"); ZEPHIR_CALL_METHOD(&_21$$11, &_20$$11, "fire", NULL, 0, &_22$$11, this_ptr); @@ -903,14 +903,14 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) } } ZEPHIR_OBS_NVAR(&handler); - zephir_read_property_cached(&handler, this_ptr, _zephir_prop_3, 998, PH_NOISY_CC); + zephir_read_property_cached(&handler, this_ptr, _zephir_prop_3, 999, PH_NOISY_CC); } - zephir_read_property_cached(&_29$$9, this_ptr, _zephir_prop_4, 999, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$9, this_ptr, _zephir_prop_4, 1000, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&beforeHandlers, &_29$$9); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1000, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1001, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1000, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1001, &__$false); } if (Z_TYPE_P(&beforeHandlers) == IS_STRING) { ZEPHIR_INIT_VAR(&_31$$9); @@ -948,7 +948,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(&_37$$15, this_ptr, _zephir_prop_5, 1000, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_37$$15, this_ptr, _zephir_prop_5, 1001, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_37$$15)) { RETURN_CCTOR(&status); } @@ -994,7 +994,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(&_43$$20, this_ptr, _zephir_prop_5, 1000, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_43$$20, this_ptr, _zephir_prop_5, 1001, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_43$$20)) { RETURN_CCTOR(&status); } @@ -1003,7 +1003,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(&_29$$9, this_ptr, _zephir_prop_6, 993, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$9, this_ptr, _zephir_prop_6, 994, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&modelBinder, &_29$$9); _44$$9 = Z_TYPE_P(&handler) == IS_OBJECT; if (_44$$9) { @@ -1068,9 +1068,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(&_29$$9, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$9, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_29$$9) != IS_NULL) { - zephir_read_property_cached(&_56$$33, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_56$$33, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_58$$33); ZVAL_STRING(&_58$$33, "micro:afterBinding"); ZEPHIR_CALL_METHOD(&_57$$33, &_56$$33, "fire", NULL, 0, &_58$$33, this_ptr); @@ -1079,12 +1079,12 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) RETURN_MM_BOOL(0); } } - zephir_read_property_cached(&_59$$9, this_ptr, _zephir_prop_7, 1001, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_59$$9, this_ptr, _zephir_prop_7, 1002, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&afterBindingHandlers, &_59$$9); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1000, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1001, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1000, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1001, &__$false); } if (Z_TYPE_P(&afterBindingHandlers) == IS_STRING) { ZEPHIR_INIT_VAR(&_61$$9); @@ -1122,7 +1122,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(&_66$$35, this_ptr, _zephir_prop_5, 1000, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_66$$35, this_ptr, _zephir_prop_5, 1001, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_66$$35)) { RETURN_CCTOR(&status); } @@ -1168,28 +1168,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(&_72$$40, this_ptr, _zephir_prop_5, 1000, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_72$$40, this_ptr, _zephir_prop_5, 1001, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_72$$40)) { RETURN_CCTOR(&status); } } } ZEPHIR_INIT_NVAR(&afterBinding); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1002, &returnedValue); - zephir_read_property_cached(&_59$$9, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1003, &returnedValue); + zephir_read_property_cached(&_59$$9, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_59$$9) != IS_NULL) { - zephir_read_property_cached(&_73$$45, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_73$$45, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_74$$45); ZVAL_STRING(&_74$$45, "micro:afterExecuteRoute"); ZEPHIR_CALL_METHOD(NULL, &_73$$45, "fire", NULL, 0, &_74$$45, this_ptr); zephir_check_call_status_or_jump(try_end_1); } - zephir_read_property_cached(&_75$$9, this_ptr, _zephir_prop_9, 1003, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_75$$9, this_ptr, _zephir_prop_9, 1004, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&afterHandlers, &_75$$9); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1000, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1001, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1000, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1001, &__$false); } if (Z_TYPE_P(&afterHandlers) == IS_STRING) { ZEPHIR_INIT_VAR(&_77$$9); @@ -1227,7 +1227,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(&_82$$46, this_ptr, _zephir_prop_5, 1000, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_82$$46, this_ptr, _zephir_prop_5, 1001, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_82$$46)) { break; } @@ -1273,7 +1273,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(&_88$$51, this_ptr, _zephir_prop_5, 1000, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_88$$51, this_ptr, _zephir_prop_5, 1001, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_88$$51)) { break; } @@ -1281,9 +1281,9 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) } ZEPHIR_INIT_NVAR(&after); } else { - zephir_read_property_cached(&_89$$56, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_89$$56, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_89$$56) != IS_NULL) { - zephir_read_property_cached(&_90$$57, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_90$$57, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_92$$57); ZVAL_STRING(&_92$$57, "micro:beforeNotFound"); ZEPHIR_CALL_METHOD(&_91$$57, &_90$$57, "fire", NULL, 0, &_92$$57, this_ptr); @@ -1292,7 +1292,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) RETURN_MM_BOOL(0); } } - zephir_read_property_cached(&_93$$56, this_ptr, _zephir_prop_10, 1004, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_93$$56, this_ptr, _zephir_prop_10, 1005, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(¬FoundHandler, &_93$$56); if (UNEXPECTED(!(zephir_is_callable(¬FoundHandler)))) { ZEPHIR_INIT_VAR(&_94$$59); @@ -1307,20 +1307,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(&_95$$4, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_95$$4, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_95$$4) != IS_NULL) { - zephir_read_property_cached(&_96$$60, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_96$$60, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_97$$60); ZVAL_STRING(&_97$$60, "micro:afterHandleRoute"); ZEPHIR_CALL_METHOD(NULL, &_96$$60, "fire", NULL, 0, &_97$$60, this_ptr, &returnedValue); zephir_check_call_status_or_jump(try_end_1); } - zephir_read_property_cached(&_98$$4, this_ptr, _zephir_prop_11, 1005, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_98$$4, this_ptr, _zephir_prop_11, 1006, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&finishHandlers, &_98$$4); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1000, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1001, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1000, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1001, &__$false); } if (Z_TYPE_P(&finishHandlers) == IS_STRING) { ZEPHIR_INIT_NVAR(&_14$$4); @@ -1361,7 +1361,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_CALL_USER_FUNC_ARRAY(&status, &finish, &_104$$63); zephir_check_call_status_or_jump(try_end_1); } - zephir_read_property_cached(&_105$$61, this_ptr, _zephir_prop_5, 1000, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_105$$61, this_ptr, _zephir_prop_5, 1001, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_105$$61)) { break; } @@ -1410,7 +1410,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_CALL_USER_FUNC_ARRAY(&status, &finish, &_111$$68); zephir_check_call_status_or_jump(try_end_1); } - zephir_read_property_cached(&_112$$66, this_ptr, _zephir_prop_5, 1000, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_112$$66, this_ptr, _zephir_prop_5, 1001, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_112$$66)) { break; } @@ -1427,17 +1427,17 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) if (zephir_is_instance_of(&_113, SL("Throwable"))) { zend_clear_exception(); ZEPHIR_CPY_WRT(&e, &_113); - zephir_read_property_cached(&_114$$71, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_114$$71, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_114$$71) != IS_NULL) { - zephir_read_property_cached(&_115$$72, this_ptr, _zephir_prop_1, 996, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_115$$72, this_ptr, _zephir_prop_1, 997, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_116$$72); ZVAL_STRING(&_116$$72, "micro:beforeException"); ZEPHIR_CALL_METHOD(NULL, &_115$$72, "fire", NULL, 0, &_116$$72, this_ptr, &e); zephir_check_call_status(); } - zephir_read_property_cached(&_117$$71, this_ptr, _zephir_prop_12, 992, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_117$$71, this_ptr, _zephir_prop_12, 993, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_117$$71) != IS_NULL) { - zephir_read_property_cached(&_118$$73, this_ptr, _zephir_prop_12, 992, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_118$$73, this_ptr, _zephir_prop_12, 993, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(!(zephir_is_callable(&_118$$73)))) { ZEPHIR_INIT_VAR(&_119$$74); object_init_ex(&_119$$74, phalcon_mvc_micro_exceptions_errorhandlernotcallable_ce); @@ -1447,7 +1447,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_120$$73, this_ptr, _zephir_prop_12, 992, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_120$$73, this_ptr, _zephir_prop_12, 993, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_121$$73); zephir_create_array(&_121$$73, 1, 0); zephir_array_fast_append(&_121$$73, &e); @@ -1476,9 +1476,9 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) } } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_13, 1006, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_13, 1007, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { - zephir_read_property_cached(&_122$$81, this_ptr, _zephir_prop_13, 1006, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_122$$81, this_ptr, _zephir_prop_13, 1007, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(!(zephir_is_callable(&_122$$81)))) { ZEPHIR_INIT_VAR(&_123$$82); object_init_ex(&_123$$82, phalcon_mvc_micro_exceptions_responsehandlernotcallable_ce); @@ -1488,7 +1488,7 @@ PHP_METHOD(Phalcon_Mvc_Micro, handle) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_124$$81, this_ptr, _zephir_prop_13, 1006, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_124$$81, this_ptr, _zephir_prop_13, 1007, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&returnedValue); ZEPHIR_CALL_USER_FUNC(&returnedValue, &_124$$81); zephir_check_call_status(); @@ -1553,7 +1553,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, 995, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 996, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "has", NULL, 0, &serviceName_zv); zephir_check_call_status(); RETURN_MM(); @@ -1854,7 +1854,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, 1004, handler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1005, handler); RETURN_THISW(); } @@ -1973,7 +1973,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, 995, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 996, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "remove", NULL, 0, offset); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -2129,7 +2129,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, 998, activeHandler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 999, activeHandler); RETURN_THISW(); } @@ -2151,7 +2151,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, 995, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 996, container); } /** @@ -2172,7 +2172,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, 996, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 997, eventsManager); } /** @@ -2232,7 +2232,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, 993, modelBinder); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 994, modelBinder); RETURN_THIS(); } @@ -2257,7 +2257,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, 1006, handler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1007, handler); RETURN_THISW(); } @@ -2302,7 +2302,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, 995, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 996, PH_NOISY_CC | PH_READONLY); if (isShared) { ZVAL_BOOL(&_1, 1); } else { @@ -2329,9 +2329,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, 1000, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1001, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1000, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1001, &__$false); } } @@ -2399,13 +2399,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, 995, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 996, 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, 995, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 996, &_1$$3); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/mvc/micro/collection.zep.c b/ext/phalcon/mvc/micro/collection.zep.c index 186851dcc5..0d57126bdb 100644 --- a/ext/phalcon/mvc/micro/collection.zep.c +++ b/ext/phalcon/mvc/micro/collection.zep.c @@ -539,11 +539,11 @@ PHP_METHOD(Phalcon_Mvc_Micro_Collection, setHandler) isLazy = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1007, handler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1008, handler); if (isLazy) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1008, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1009, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1008, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1009, &__$false); } RETURN_THISW(); } @@ -569,9 +569,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, 1008, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1009, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1008, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1009, &__$false); } RETURN_THISW(); } @@ -595,7 +595,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, 1009, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1010, &prefix_zv); RETURN_THISW(); } diff --git a/ext/phalcon/mvc/micro/lazyloader.zep.c b/ext/phalcon/mvc/micro/lazyloader.zep.c index b9ad9283c8..f63e6ebb21 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, 1010, &definition_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1011, &definition_zv); } /** @@ -126,9 +126,9 @@ PHP_METHOD(Phalcon_Mvc_Micro_LazyLoader, callMethod) modelBinder = &modelBinder_sub; modelBinder = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1011, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1012, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&handler, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1010, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1011, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&definition, &_0); if (Z_TYPE_P(&handler) != IS_OBJECT) { if (!(zephir_class_exists(&definition, 1))) { @@ -143,7 +143,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, 1011, &handler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1012, &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 4f63e91178..4b881d2e6d 100644 --- a/ext/phalcon/mvc/model.zep.c +++ b/ext/phalcon/mvc/model.zep.c @@ -342,7 +342,7 @@ PHP_METHOD(Phalcon_Mvc_Model, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1012, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1013, container); if (Z_TYPE_P(modelsManager) == IS_NULL) { ZEPHIR_INIT_VAR(&_3$$5); ZVAL_STRING(&_3$$5, "modelsManager"); @@ -361,7 +361,7 @@ PHP_METHOD(Phalcon_Mvc_Model, __construct) return; } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1013, modelsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1014, 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)) { @@ -427,7 +427,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1014, 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) { @@ -554,14 +554,14 @@ 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, 1014, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1015, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_1$$3, &lowerProperty)) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 1015, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_3$$4); zephir_array_fetch(&_3$$4, &_2$$4, &lowerProperty, PH_NOISY, "phalcon/Mvc/Model.zep", 415); RETURN_CCTOR(&_3$$4); } - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 1015, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 1016, 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); @@ -570,20 +570,20 @@ PHP_METHOD(Phalcon_Mvc_Model, __get) } _7$$3 = _5$$3; if (_7$$3) { - zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_1, 1015, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_1, 1016, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_9$$3); zephir_array_fetch(&_9$$3, &_8$$3, &lowerProperty, PH_NOISY, "phalcon/Mvc/Model.zep", 426); _7$$3 = Z_TYPE_P(&_9$$3) == IS_OBJECT; } _10$$3 = _7$$3; if (_10$$3) { - zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_1, 1015, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$3, this_ptr, _zephir_prop_1, 1016, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_12$$3); zephir_array_fetch(&_12$$3, &_11$$3, &lowerProperty, PH_NOISY, "phalcon/Mvc/Model.zep", 427); _10$$3 = zephir_instance_of_ev(&_12$$3, phalcon_mvc_modelinterface_ce); } if (_10$$3) { - zephir_read_property_cached(&_13$$5, this_ptr, _zephir_prop_1, 1015, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$5, this_ptr, _zephir_prop_1, 1016, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_14$$5); zephir_array_fetch(&_14$$5, &_13$$5, &lowerProperty, PH_NOISY, "phalcon/Mvc/Model.zep", 428); RETURN_CCTOR(&_14$$5); @@ -695,7 +695,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, 1016, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1017, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&dirtyState, &_0); ZEPHIR_CALL_METHOD(&_2, this_ptr, "getModelsManager", NULL, 0); zephir_check_call_status(); @@ -704,16 +704,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, 1017, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1018, 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, 1017, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1018, PH_NOISY_CC | PH_READONLY); _4 = !ZEPHIR_IS_EQUAL(&attributes, &_1); } if (_4) { - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 1017, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 1018, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&snapshot, &_5$$3); } zephir_create_array(return_value, 3, 0); @@ -796,7 +796,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, 1016, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 1017, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&dirtyState, &_2$$4); ZEPHIR_CALL_METHOD(&_3$$4, value, "getDirtyState", NULL, 0); zephir_check_call_status(); @@ -806,7 +806,7 @@ PHP_METHOD(Phalcon_Mvc_Model, __set) } zephir_unset_property_array(this_ptr, ZEND_STRL("related"), &lowerProperty); zephir_update_property_array(this_ptr, SL("dirtyRelated"), &lowerProperty, value); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1016, &dirtyState); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1017, &dirtyState); RETVAL_ZVAL(value, 1, 0); RETURN_MM(); } @@ -841,7 +841,7 @@ PHP_METHOD(Phalcon_Mvc_Model, __set) zephir_update_property_array(this_ptr, SL("dirtyRelated"), &lowerProperty, &referencedModel); ZVAL_UNDEF(&_7$$9); ZVAL_LONG(&_7$$9, 1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1016, &_7$$9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1017, &_7$$9); RETVAL_ZVAL(value, 1, 0); RETURN_MM(); } @@ -906,7 +906,7 @@ 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, 1016, &_15$$17); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1017, &_15$$17); } else { zephir_unset_property_array(this_ptr, ZEND_STRL("dirtyRelated"), &lowerProperty); } @@ -1042,7 +1042,7 @@ PHP_METHOD(Phalcon_Mvc_Model, __unserialize) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1012, &container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1013, &container); ZEPHIR_INIT_VAR(&_4); ZVAL_STRING(&_4, "modelsManager"); ZEPHIR_CALL_METHOD(&_3, &container, "getShared", NULL, 0, &_4); @@ -1059,7 +1059,7 @@ PHP_METHOD(Phalcon_Mvc_Model, __unserialize) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1013, &manager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1014, &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)) { @@ -1120,7 +1120,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, 1016, &dirtyState); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1017, &dirtyState); } ZEPHIR_CALL_METHOD(&_3, &manager, "isKeepingSnapshots", NULL, 0, this_ptr); zephir_check_call_status(); @@ -1133,9 +1133,9 @@ PHP_METHOD(Phalcon_Mvc_Model, __unserialize) } else { ZEPHIR_CPY_WRT(&_14$$13, &properties); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1017, &_14$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1018, &_14$$13); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1017, &properties); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1018, &properties); } } ZEPHIR_MM_RESTORE(); @@ -3624,7 +3624,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "addBehavior", NULL, 0, this_ptr, behavior); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -3877,7 +3877,7 @@ PHP_METHOD(Phalcon_Mvc_Model, assign) } ZEPHIR_INIT_VAR(&rawValues); array_init(&rawValues); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1018, &rawValues); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1019, &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); @@ -4120,7 +4120,7 @@ PHP_METHOD(Phalcon_Mvc_Model, assign) } } ZEPHIR_INIT_NVAR(&attribute); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1018, &rawValues); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1019, &rawValues); RETURN_THIS(); } @@ -4204,7 +4204,7 @@ PHP_METHOD(Phalcon_Mvc_Model, create) ZEPHIR_CALL_METHOD(NULL, &_3$$3, "__construct", NULL, 3, &_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, 1019, &_2$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1020, &_2$$3); RETURN_MM_BOOL(0); } ZEPHIR_RETURN_CALL_METHOD(this_ptr, "save", NULL, 0); @@ -4331,10 +4331,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, 1020, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1021, &_0); ZEPHIR_INIT_VAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1019, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1020, &_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); @@ -4513,9 +4513,9 @@ PHP_METHOD(Phalcon_Mvc_Model, delete) zephir_check_call_status(); if (zephir_is_true(&_33)) { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1021, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1022, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1021, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1022, &__$false); } ZEPHIR_INIT_VAR(&_36$$20); ZVAL_STRING(&_36$$20, "beforeDelete"); @@ -4524,7 +4524,7 @@ PHP_METHOD(Phalcon_Mvc_Model, delete) if (ZEPHIR_IS_FALSE_IDENTICAL(&_35$$20)) { RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_37$$20, this_ptr, _zephir_prop_2, 1021, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_37$$20, this_ptr, _zephir_prop_2, 1022, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_37$$20)) { RETURN_MM_BOOL(1); } @@ -4569,22 +4569,22 @@ PHP_METHOD(Phalcon_Mvc_Model, delete) } } if (zephir_is_true(&success)) { - zephir_read_property_cached(&_43$$29, this_ptr, _zephir_prop_3, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_43$$29, this_ptr, _zephir_prop_3, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_43$$29, "registerWrite", NULL, 0, this_ptr); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_44$$29); array_init(&_44$$29); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1015, &_44$$29); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1016, &_44$$29); ZEPHIR_INIT_VAR(&_45$$29); array_init(&_45$$29); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1014, &_45$$29); - zephir_read_property_cached(&_46$$29, this_ptr, _zephir_prop_3, 1013, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1015, &_45$$29); + zephir_read_property_cached(&_46$$29, this_ptr, _zephir_prop_3, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_46$$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, 1016, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1017, &_0); RETURN_CCTOR(&success); } @@ -4719,7 +4719,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, 1022, &_3$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1023, &_3$$5); RETURN_MM_BOOL(0); } } @@ -4740,15 +4740,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, 1020, &_4$$8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1021, &_4$$8); } else { ZVAL_UNDEF(&_5$$9); ZVAL_LONG(&_5$$9, 1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1020, &_5$$9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1021, &_5$$9); } ZEPHIR_INIT_NVAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1019, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1020, &_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); @@ -4761,7 +4761,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, 1022, &_8$$10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1023, &_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); @@ -4793,9 +4793,9 @@ PHP_METHOD(Phalcon_Mvc_Model, doSave) } if (_14) { ZEPHIR_OBS_NVAR(&savedSnapshot); - zephir_read_property_cached(&savedSnapshot, this_ptr, _zephir_prop_3, 1017, PH_NOISY_CC); + zephir_read_property_cached(&savedSnapshot, this_ptr, _zephir_prop_3, 1018, PH_NOISY_CC); ZEPHIR_OBS_NVAR(&savedOldSnapshot); - zephir_read_property_cached(&savedOldSnapshot, this_ptr, _zephir_prop_4, 1023, PH_NOISY_CC); + zephir_read_property_cached(&savedOldSnapshot, this_ptr, _zephir_prop_4, 1024, PH_NOISY_CC); } if (zephir_is_true(&exists)) { ZEPHIR_CALL_METHOD(&success, this_ptr, "doLowUpdate", NULL, 0, &metaData, &writeConnection, &table); @@ -4807,7 +4807,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, 1016, &_17$$16); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1017, &_17$$16); } if (hasRelatedToSave) { if (ZEPHIR_IS_FALSE_IDENTICAL(&success)) { @@ -4842,19 +4842,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, 1017, &savedSnapshot); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1023, &savedOldSnapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1018, &savedSnapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1024, &savedOldSnapshot); } } else { if (hasRelatedToSave) { ZEPHIR_INIT_VAR(&_25$$24); array_init(&_25$$24); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1014, &_25$$24); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1015, &_25$$24); } ZEPHIR_INIT_VAR(&_26$$23); array_init(&_26$$23); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1015, &_26$$23); - zephir_read_property_cached(&_27$$23, this_ptr, _zephir_prop_8, 1013, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1016, &_26$$23); + zephir_read_property_cached(&_27$$23, this_ptr, _zephir_prop_8, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_27$$23, "clearReusableObjects", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_28$$23); @@ -4864,7 +4864,7 @@ PHP_METHOD(Phalcon_Mvc_Model, doSave) } ZEPHIR_INIT_NVAR(&_16); array_init(&_16); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1022, &_16); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1023, &_16); RETURN_CCTOR(&success); } @@ -4923,7 +4923,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "notifyEvent", NULL, 0, &eventName_zv, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -4964,7 +4964,7 @@ PHP_METHOD(Phalcon_Mvc_Model, fireEventCancel) RETURN_MM_BOOL(0); } } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_1, "notifyEvent", NULL, 0, &eventName_zv, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -5018,7 +5018,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, 1017, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1018, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&snapshot, &_0); if (UNEXPECTED(Z_TYPE_P(&snapshot) != IS_ARRAY)) { ZEPHIR_INIT_VAR(&_1$$3); @@ -5149,7 +5149,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getCustomEventsManager", NULL, 0, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -5235,7 +5235,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, 1019, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 1020, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_3$$3) == IS_STRING) { ZEPHIR_INIT_VAR(&_5$$3); zephir_string_to_char_array(&_5$$3, &_3$$3); @@ -5324,9 +5324,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, 1024, PH_NOISY_CC); + zephir_read_property_cached(&metaData, this_ptr, _zephir_prop_0, 1025, PH_NOISY_CC); if (Z_TYPE_P(&metaData) == IS_NULL) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_1, 1012, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_1, 1013, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0$$3); ZEPHIR_INIT_VAR(&_2$$3); ZVAL_STRING(&_2$$3, "modelsMetadata"); @@ -5344,7 +5344,7 @@ PHP_METHOD(Phalcon_Mvc_Model, getModelsMetaData) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1024, &metaData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1025, &metaData); } RETURN_CCTOR(&metaData); } @@ -5394,14 +5394,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, 1025, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1026, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1025, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1026, 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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_2, "getReadConnection", NULL, 0, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -5426,7 +5426,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getReadConnectionService", NULL, 0, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -5495,7 +5495,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); ZEPHIR_INIT_VAR(&lowerAlias); zephir_fast_strtolower(&lowerAlias, &alias_zv); @@ -5512,16 +5512,16 @@ 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, 1014, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 1015, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_3$$4, &lowerAlias)) { - zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_1, 1014, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_1, 1015, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_5$$5); zephir_array_fetch(&_5$$5, &_4$$5, &lowerAlias, PH_NOISY, "phalcon/Mvc/Model.zep", 3137); RETURN_CCTOR(&_5$$5); } - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_2, 1015, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_2, 1016, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_6$$4, &lowerAlias)) { - zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_2, 1015, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_2, 1016, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_8$$6); zephir_array_fetch(&_8$$6, &_7$$6, &lowerAlias, PH_NOISY, "phalcon/Mvc/Model.zep", 3148); RETURN_CCTOR(&_8$$6); @@ -5554,7 +5554,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getModelSchema", NULL, 0, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -5589,7 +5589,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getModelSource", NULL, 0, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -5662,9 +5662,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, 1017, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1018, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&snapshot, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1023, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1024, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&oldSnapshot, &_0); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "orm.update_snapshot_on_save"); @@ -5692,7 +5692,7 @@ PHP_METHOD(Phalcon_Mvc_Model, getUpdatedFields) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1016, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1017, 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); @@ -5795,14 +5795,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, 1025, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1026, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1025, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1026, 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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_2, "getWriteConnection", NULL, 0, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -5827,7 +5827,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getWriteConnectionService", NULL, 0, this_ptr); zephir_check_call_status(); RETURN_MM(); @@ -5916,7 +5916,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, 1017, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1018, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(!(ZEPHIR_IS_EMPTY(&_0))); } @@ -6015,7 +6015,7 @@ PHP_METHOD(Phalcon_Mvc_Model, isRelationshipLoaded) ZVAL_STR_COPY(&relationshipAlias_zv, relationshipAlias); ZEPHIR_INIT_VAR(&_0); zephir_fast_strtolower(&_0, &relationshipAlias_zv); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1015, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1016, PH_NOISY_CC | PH_READONLY); RETURN_MM_BOOL(zephir_array_key_exists(&_1, &_0)); } @@ -6142,7 +6142,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, 1016, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1017, 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); @@ -6158,7 +6158,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_3); ZEPHIR_CALL_METHOD(&schema, this_ptr, "getSchema", NULL, 0); zephir_check_call_status(); @@ -6172,7 +6172,7 @@ PHP_METHOD(Phalcon_Mvc_Model, refresh) } else { ZEPHIR_CPY_WRT(&table, &source); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1026, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1027, 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); @@ -6188,10 +6188,10 @@ PHP_METHOD(Phalcon_Mvc_Model, refresh) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_2, 1026, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_2, 1027, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueKey, &_7$$6); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 1027, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 1028, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueParams, &_3); if (UNEXPECTED(Z_TYPE_P(&uniqueParams) != IS_ARRAY)) { ZEPHIR_INIT_VAR(&_8$$8); @@ -6262,7 +6262,7 @@ PHP_METHOD(Phalcon_Mvc_Model, refresh) zephir_array_update_string(&_18, SL("where"), &uniqueKey, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(&tables, &dialect, "select", NULL, 0, &_18); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_4, 1028, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_4, 1029, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_20, 2); ZEPHIR_CALL_METHOD(&row, &readConnection, "fetchOne", NULL, 0, &tables, &_20, &uniqueParams, &_3); zephir_check_call_status(); @@ -6369,7 +6369,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, 1016, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1017, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&dirtyState, &_0); ZEPHIR_CALL_METHOD(&_2, this_ptr, "getModelsManager", NULL, 0); zephir_check_call_status(); @@ -6378,16 +6378,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, 1017, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1018, 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, 1017, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1018, PH_NOISY_CC | PH_READONLY); _4 = !ZEPHIR_IS_EQUAL(&attributes, &_1); } if (_4) { - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 1017, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_1, 1018, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&snapshot, &_5$$3); } ZEPHIR_INIT_VAR(&_6); @@ -6425,7 +6425,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "setConnectionService", NULL, 0, this_ptr, &connectionService_zv); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -6452,7 +6452,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, 1016, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1017, &_0); RETURN_THISW(); } @@ -6479,7 +6479,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "setCustomEventsManager", NULL, 0, this_ptr, eventsManager); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -6682,7 +6682,7 @@ PHP_METHOD(Phalcon_Mvc_Model, setOldSnapshotData) } else { ZEPHIR_CPY_WRT(&snapshot, &data); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1023, &snapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1024, &snapshot); ZEPHIR_MM_RESTORE(); } @@ -6711,7 +6711,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "setReadConnectionService", NULL, 0, this_ptr, &connectionService_zv); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -6993,7 +6993,7 @@ PHP_METHOD(Phalcon_Mvc_Model, setSnapshotData) } else { ZEPHIR_CPY_WRT(&snapshot, &data); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1017, &snapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1018, &snapshot); ZEPHIR_MM_RESTORE(); } @@ -7183,7 +7183,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, 1025, transaction); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1026, transaction); RETURN_THISW(); } @@ -7212,7 +7212,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "setWriteConnectionService", NULL, 0, this_ptr, &connectionService_zv); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -7239,9 +7239,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, 1021, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1022, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1021, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1022, &__$false); } } @@ -7618,7 +7618,7 @@ PHP_METHOD(Phalcon_Mvc_Model, unserialize) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1012, &container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1013, &container); ZEPHIR_INIT_VAR(&_4$$3); ZVAL_STRING(&_4$$3, "modelsManager"); ZEPHIR_CALL_METHOD(&_3$$3, &container, "getShared", NULL, 0, &_4$$3); @@ -7635,7 +7635,7 @@ PHP_METHOD(Phalcon_Mvc_Model, unserialize) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1013, &manager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1014, &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)) { @@ -7728,7 +7728,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, 1016, &dirtyState); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1017, &dirtyState); } ZEPHIR_CALL_METHOD(&_3$$3, &manager, "isKeepingSnapshots", NULL, 0, this_ptr); zephir_check_call_status(); @@ -7741,9 +7741,9 @@ PHP_METHOD(Phalcon_Mvc_Model, unserialize) } else { ZEPHIR_CPY_WRT(&_18$$18, &properties); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1017, &_18$$18); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1018, &_18$$18); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1017, &properties); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1018, &properties); } } } @@ -7803,7 +7803,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, 1016, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1017, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(&metaData, this_ptr, "getModelsMetaData", NULL, 0); zephir_check_call_status(); @@ -7831,7 +7831,7 @@ PHP_METHOD(Phalcon_Mvc_Model, update) ZEPHIR_CALL_METHOD(NULL, &_4$$4, "__construct", NULL, 3, &_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, 1019, &_3$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1020, &_3$$4); RETURN_MM_BOOL(0); } } @@ -7881,7 +7881,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, 1019, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1020, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(!(ZEPHIR_IS_EMPTY(&_0))); } @@ -8077,7 +8077,7 @@ PHP_METHOD(Phalcon_Mvc_Model, belongsTo) } else { zephir_get_arrval(&options, options_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, 1014, 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(); @@ -8103,7 +8103,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, 1020, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1021, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_LONG(&_0, 3)) { ZEPHIR_INIT_VAR(&_1$$3); ZVAL_STRING(&_1$$3, "notDeleted"); @@ -8200,7 +8200,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); ZEPHIR_CALL_METHOD(&belongsTo, &manager, "getBelongsTo", NULL, 0, this_ptr); zephir_check_call_status(); @@ -8628,7 +8628,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); ZEPHIR_CALL_METHOD(&relations, &manager, "getHasOneAndHasMany", NULL, 0, this_ptr); zephir_check_call_status(); @@ -8779,7 +8779,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); ZEPHIR_CALL_METHOD(&relations, &manager, "getHasOneAndHasMany", NULL, 0, this_ptr); zephir_check_call_status(); @@ -8990,9 +8990,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, 1015, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1016, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&related, &_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1014, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1015, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&dirtyRelated, &_1); zephir_is_iterable(&related, 0, "phalcon/Mvc/Model.zep", 4668); ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&related), _3, _4, _2) @@ -9175,9 +9175,9 @@ PHP_METHOD(Phalcon_Mvc_Model, doLowInsert) array_init(&values); ZEPHIR_INIT_VAR(&bindSkip); ZVAL_LONG(&bindSkip, 1024); - 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, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1018, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1019, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&rawValues, &_0); ZEPHIR_CALL_METHOD(&attributes, metaData, "getAttributes", NULL, 0, this_ptr); zephir_check_call_status(); @@ -9579,8 +9579,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, 1026, &__$null); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1027, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1027, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1028, &__$null); } if (zephir_is_true(&success)) { ZEPHIR_CALL_METHOD(NULL, &manager, "registerWrite", NULL, 0, this_ptr); @@ -9618,7 +9618,7 @@ PHP_METHOD(Phalcon_Mvc_Model, doLowInsert) _70$$62 = zephir_is_true(&_71$$62); } if (_70$$62) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1017, &snapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1018, &snapshot); } } RETURN_CCTOR(&success); @@ -9782,14 +9782,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, 1018, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1019, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&rawValues, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1014, 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, 1017, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1018, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&snapshot, &_0); ZEPHIR_CALL_METHOD(&dataTypes, metaData, "getDataTypes", NULL, 0, this_ptr); zephir_check_call_status(); @@ -10125,7 +10125,7 @@ PHP_METHOD(Phalcon_Mvc_Model, doLowUpdate) } ZEPHIR_INIT_NVAR(&field); if (ZEPHIR_IS_EMPTY(&fields)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1023, &snapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1024, &snapshot); RETURN_MM_BOOL(1); } } else { @@ -10316,9 +10316,9 @@ PHP_METHOD(Phalcon_Mvc_Model, doLowUpdate) if (ZEPHIR_IS_EMPTY(&fields)) { RETURN_MM_BOOL(1); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1026, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1027, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueKey, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 1027, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 1028, 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); @@ -10434,7 +10434,7 @@ PHP_METHOD(Phalcon_Mvc_Model, doLowUpdate) zephir_array_update_string(&_83, SL("conditions"), &uniqueKey, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_83, SL("bind"), &uniqueParams, PH_COPY | PH_SEPARATE); zephir_memory_observe(&_84); - zephir_read_property_cached(&_84, this_ptr, _zephir_prop_6, 1028, PH_NOISY_CC); + zephir_read_property_cached(&_84, this_ptr, _zephir_prop_6, 1029, PH_NOISY_CC); zephir_array_update_string(&_83, SL("bindTypes"), &_84, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(&success, connection, "update", NULL, 0, table, &fields, &values, &_83, &bindTypes); zephir_check_call_status(); @@ -10458,15 +10458,15 @@ PHP_METHOD(Phalcon_Mvc_Model, doLowUpdate) } if (_87) { if (Z_TYPE_P(&snapshot) == IS_ARRAY) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1023, &snapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1024, &snapshot); ZEPHIR_INIT_VAR(&_89$$96); zephir_fast_array_merge(&_89$$96, &snapshot, &newSnapshot); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1017, &_89$$96); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1018, &_89$$96); } else { ZEPHIR_INIT_VAR(&_90$$97); array_init(&_90$$97); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1023, &_90$$97); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1017, &newSnapshot); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1024, &_90$$97); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1018, &newSnapshot); } } RETURN_CCTOR(&success); @@ -10525,7 +10525,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); ZEPHIR_INIT_VAR(&relation); ZVAL_BOOL(&relation, 0); @@ -10652,7 +10652,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, 1026, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1027, 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); @@ -10821,25 +10821,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, 1026, &joinWhere); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1027, &uniqueParams); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1028, &uniqueTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1027, &joinWhere); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1028, &uniqueParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1029, &uniqueTypes); ZEPHIR_CPY_WRT(&uniqueKey, &joinWhere); } - 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, 1017, 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(&_25$$25, this_ptr, _zephir_prop_0, 1026, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$25, this_ptr, _zephir_prop_0, 1027, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueKey, &_25$$25); } if (Z_TYPE_P(&uniqueParams) == IS_NULL) { - zephir_read_property_cached(&_26$$26, this_ptr, _zephir_prop_1, 1027, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_26$$26, this_ptr, _zephir_prop_1, 1028, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueParams, &_26$$26); } if (Z_TYPE_P(&uniqueTypes) == IS_NULL) { - zephir_read_property_cached(&_27$$27, this_ptr, _zephir_prop_2, 1028, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_27$$27, this_ptr, _zephir_prop_2, 1029, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueTypes, &_27$$27); } ZEPHIR_CALL_METHOD(&schema, this_ptr, "getSchema", NULL, 0); @@ -10866,12 +10866,12 @@ PHP_METHOD(Phalcon_Mvc_Model, has) if (zephir_is_true(&_31)) { ZVAL_UNDEF(&_32$$30); ZVAL_LONG(&_32$$30, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1016, &_32$$30); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1017, &_32$$30); RETURN_MM_BOOL(1); } else { ZVAL_UNDEF(&_33$$31); ZVAL_LONG(&_33$$31, 1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1016, &_33$$31); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1017, &_33$$31); } RETURN_MM_BOOL(0); } @@ -10964,7 +10964,7 @@ PHP_METHOD(Phalcon_Mvc_Model, hasMany) } else { zephir_get_arrval(&options, options_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, 1014, 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(); @@ -11080,7 +11080,7 @@ PHP_METHOD(Phalcon_Mvc_Model, hasManyToMany) } else { zephir_get_arrval(&options, options_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, 1014, 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(); @@ -11173,7 +11173,7 @@ PHP_METHOD(Phalcon_Mvc_Model, hasOne) } else { zephir_get_arrval(&options, options_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, 1014, 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(); @@ -11262,7 +11262,7 @@ PHP_METHOD(Phalcon_Mvc_Model, hasOneThrough) } else { zephir_get_arrval(&options, options_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, 1014, 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(); @@ -11304,7 +11304,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); if (keepSnapshot) { ZVAL_BOOL(&_1, 1); } else { @@ -11829,12 +11829,12 @@ PHP_METHOD(Phalcon_Mvc_Model, postSaveRelatedRecords) zephir_check_call_status(); doSync = zephir_get_boolval(&_15$$9); ZEPHIR_OBS_NVAR(&override); - zephir_read_property_cached(&_17$$9, this_ptr, _zephir_prop_0, 1022, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$9, this_ptr, _zephir_prop_0, 1023, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&override, &_17$$9, &name, 0)) { doSync = zephir_get_boolval(&override); } else { ZEPHIR_OBS_NVAR(&override); - zephir_read_property_cached(&_18$$9, this_ptr, _zephir_prop_0, 1022, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18$$9, this_ptr, _zephir_prop_0, 1023, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_string_fetch(&override, &_18$$9, SL("*"), 0)) { doSync = zephir_get_boolval(&override); } @@ -12843,12 +12843,12 @@ PHP_METHOD(Phalcon_Mvc_Model, postSaveRelatedRecords) zephir_check_call_status(); doSync = zephir_get_boolval(&_219$$89); ZEPHIR_OBS_NVAR(&override); - zephir_read_property_cached(&_221$$89, this_ptr, _zephir_prop_0, 1022, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_221$$89, this_ptr, _zephir_prop_0, 1023, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&override, &_221$$89, &name, 0)) { doSync = zephir_get_boolval(&override); } else { ZEPHIR_OBS_NVAR(&override); - zephir_read_property_cached(&_222$$89, this_ptr, _zephir_prop_0, 1022, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_222$$89, this_ptr, _zephir_prop_0, 1023, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_string_fetch(&override, &_222$$89, SL("*"), 0)) { doSync = zephir_get_boolval(&override); } @@ -14216,9 +14216,9 @@ PHP_METHOD(Phalcon_Mvc_Model, preSave) RETURN_MM_BOOL(0); } if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1021, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1022, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1021, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1022, &__$false); } if (exists) { ZEPHIR_INIT_NVAR(&eventName); @@ -14232,7 +14232,7 @@ PHP_METHOD(Phalcon_Mvc_Model, preSave) if (ZEPHIR_IS_FALSE_IDENTICAL(&_55$$60)) { RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_56$$60, this_ptr, _zephir_prop_0, 1021, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_56$$60, this_ptr, _zephir_prop_0, 1022, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_TRUE_IDENTICAL(&_56$$60)) { RETURN_MM_BOOL(1); } @@ -14536,7 +14536,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "setModelSchema", NULL, 0, this_ptr, &schema_zv); zephir_check_call_status(); RETURN_THIS(); @@ -14567,7 +14567,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "setModelSource", NULL, 0, this_ptr, &source_zv); zephir_check_call_status(); RETURN_THIS(); @@ -14814,7 +14814,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, 1013, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1014, PH_NOISY_CC | PH_READONLY); if (dynamicUpdate) { ZVAL_BOOL(&_1, 1); } else { diff --git a/ext/phalcon/mvc/model/binder.zep.c b/ext/phalcon/mvc/model/binder.zep.c index e35780bd76..dbc19125e5 100644 --- a/ext/phalcon/mvc/model/binder.zep.c +++ b/ext/phalcon/mvc/model/binder.zep.c @@ -108,7 +108,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Binder, __construct) cache = &cache_sub; cache = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1029, cache); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1030, cache); } /** @@ -175,7 +175,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, 1030, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1031, &_0); _1 = !((zephir_is_instance_of(handler, SL("Closure")))); if (_1) { _1 = ZEPHIR_IS_NULL(&methodName_zv); @@ -191,7 +191,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, 1031, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1032, &_3); ZEPHIR_CALL_METHOD(¶msCache, this_ptr, "getParamsFromCache", NULL, 0, &cacheKey_zv); zephir_check_call_status(); if (Z_TYPE_P(¶msCache) == IS_ARRAY) { @@ -313,7 +313,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, 1029, cache); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1030, cache); RETURN_THISW(); } @@ -384,11 +384,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, 1032, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1033, 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, 1029, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1030, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cache, &_1); _2 = Z_TYPE_P(&cache) == IS_NULL; if (!(_2)) { @@ -490,7 +490,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Binder, getParamsFromReflection) ZEPHIR_CALL_METHOD(NULL, &reflection, "__construct", NULL, 251, handler); zephir_check_call_status(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1029, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1030, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cache, &_0); ZEPHIR_CALL_METHOD(&methodParams, &reflection, "getParameters", NULL, 252); zephir_check_call_status(); diff --git a/ext/phalcon/mvc/model/criteria.zep.c b/ext/phalcon/mvc/model/criteria.zep.c index 3edfea79e9..ba05635722 100644 --- a/ext/phalcon/mvc/model/criteria.zep.c +++ b/ext/phalcon/mvc/model/criteria.zep.c @@ -356,7 +356,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, andWhere) bindTypes = &__$null; } zephir_memory_observe(¤tConditions); - 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, 1034, 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, ")"); @@ -410,7 +410,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, 1034, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 1035, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_0); ZVAL_LONG(&_0, 1); ZEPHIR_INIT_VAR(&nextHiddenParam); @@ -429,7 +429,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, 1034, &nextHiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1035, &nextHiddenParam); RETURN_THIS(); } @@ -476,7 +476,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, bind) merge = 0; } else { } - 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, 1034, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value_string(&_0, SL("bind")))) { ZEPHIR_INIT_VAR(&_1$$3); array_init(&_1$$3); @@ -484,7 +484,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, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1034, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_4); zephir_array_fetch_string(&_4, &_3, SL("bind"), PH_NOISY, "phalcon/Mvc/Model/Criteria.zep", 222); _5 = Z_TYPE_P(&_4) == IS_ARRAY; @@ -492,7 +492,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, bind) _5 = merge; } if (_5) { - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_0, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_0, 1034, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_7$$4); zephir_array_fetch_string(&_7$$4, &_6$$4, SL("bind"), PH_NOISY, "phalcon/Mvc/Model/Criteria.zep", 223); ZEPHIR_INIT_VAR(&_8$$4); @@ -706,10 +706,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, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1034, 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, 1035, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 1036, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &builder, "from", NULL, 0, &_3); zephir_check_call_status(); RETURN_CCTOR(&builder); @@ -870,7 +870,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, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1034, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_string_fetch(&columns, &_0, SL("columns"), 0))) { RETURN_MM_NULL(); } @@ -911,7 +911,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, 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, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1034, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_1); zephir_array_fetch_string(&_1, &_0, SL("di"), PH_NOISY, "phalcon/Mvc/Model/Criteria.zep", 453); RETURN_CCTOR(&_1); @@ -936,7 +936,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, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1034, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_string_fetch(&group, &_0, SL("group"), 0))) { RETURN_MM_NULL(); } @@ -962,7 +962,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, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1034, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_string_fetch(&having, &_0, SL("having"), 0))) { RETURN_MM_NULL(); } @@ -994,7 +994,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, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1034, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_string_fetch(&limit, &_0, SL("limit"), 0))) { RETURN_MM_NULL(); } @@ -1029,7 +1029,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, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1034, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_string_fetch(&order, &_0, SL("order"), 0))) { RETURN_MM_NULL(); } @@ -1066,7 +1066,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, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1034, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_string_fetch(&conditions, &_0, SL("conditions"), 0))) { RETURN_MM_NULL(); } @@ -1243,7 +1243,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, inWhere) RETURN_THIS(); } zephir_memory_observe(&hiddenParam); - zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 1034, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 1035, PH_NOISY_CC); ZEPHIR_INIT_VAR(&bindParams); array_init(&bindParams); ZEPHIR_INIT_VAR(&bindKeys); @@ -1300,7 +1300,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, 1034, &hiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1035, &hiddenParam); RETURN_THIS(); } @@ -1557,7 +1557,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, 1034, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 1035, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_0); ZVAL_LONG(&_0, 1); ZEPHIR_INIT_VAR(&nextHiddenParam); @@ -1578,7 +1578,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, 1034, &nextHiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1035, &nextHiddenParam); RETURN_THIS(); } @@ -1632,7 +1632,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, 1034, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 1035, PH_NOISY_CC); ZEPHIR_INIT_VAR(&bindParams); array_init(&bindParams); ZEPHIR_INIT_VAR(&bindKeys); @@ -1689,7 +1689,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, 1034, &hiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1035, &hiddenParam); RETURN_THIS(); } @@ -1761,7 +1761,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, orWhere) bindTypes = &__$null; } zephir_memory_observe(¤tConditions); - 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, 1034, 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, ")"); @@ -1872,7 +1872,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, 1035, &modelName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1036, &modelName_zv); RETURN_THISW(); } @@ -1967,7 +1967,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, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1034, 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); @@ -1982,7 +1982,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, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$6, this_ptr, _zephir_prop_0, 1034, 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); @@ -2071,7 +2071,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, 1033, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1034, 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/eager/loader.zep.c b/ext/phalcon/mvc/model/eager/loader.zep.c index 071ce3e1b7..c0049bb181 100644 --- a/ext/phalcon/mvc/model/eager/loader.zep.c +++ b/ext/phalcon/mvc/model/eager/loader.zep.c @@ -80,7 +80,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Eager_Loader, __construct) Z_PARAM_OBJECT_OF_CLASS(manager, phalcon_mvc_model_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, 1036, manager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1037, manager); } /** @@ -527,7 +527,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Eager_Loader, buildMap) } ZEPHIR_INIT_NVAR(&node); ZVAL_COPY(&node, _0); - zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 1036, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_0, 1037, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&relation, &_3$$3, "getRelationByAlias", NULL, 0, &modelName_zv, &alias); zephir_check_call_status(); if (UNEXPECTED(Z_TYPE_P(&relation) != IS_OBJECT)) { @@ -565,7 +565,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Eager_Loader, buildMap) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&node, &tree, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_0, 1036, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_0, 1037, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&relation, &_11$$5, "getRelationByAlias", NULL, 0, &modelName_zv, &alias); zephir_check_call_status(); if (UNEXPECTED(Z_TYPE_P(&relation) != IS_OBJECT)) { @@ -930,7 +930,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Eager_Loader, buildThroughNode) if (!(ZEPHIR_IS_EMPTY(&keys))) { ZEPHIR_INIT_VAR(&_5$$3); zephir_create_array(&_5$$3, 2, 0); - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 1036, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 1037, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_7$$3, &_6$$3, "load", NULL, 0, &intermediateModel); zephir_check_call_status(); zephir_array_fast_append(&_5$$3, &_7$$3); @@ -1500,7 +1500,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Eager_Loader, fetchReferenced) zephir_get_arrval(&options, options_param); ZEPHIR_CALL_METHOD(&referencedModel, relation, "getReferencedModel", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1036, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1037, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&modelInstance, &_0, "load", NULL, 0, &referencedModel); zephir_check_call_status(); if (ZEPHIR_IS_EMPTY(&keys)) { diff --git a/ext/phalcon/mvc/model/manager.zep.c b/ext/phalcon/mvc/model/manager.zep.c index d313c6602a..adafd49c9e 100644 --- a/ext/phalcon/mvc/model/manager.zep.c +++ b/ext/phalcon/mvc/model/manager.zep.c @@ -666,7 +666,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, 1037, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1038, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_0, &entityName))) { ZEPHIR_INIT_VAR(&_1$$3); array_init(&_1$$3); @@ -763,7 +763,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, 1038, 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(&relations, &_1, &keyRelation, 0))) { ZEPHIR_INIT_NVAR(&relations); array_init(&relations); @@ -814,7 +814,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, addBelongsTo) zephir_update_property_array(this_ptr, SL("aliases"), &_9, &relation); zephir_update_property_array(this_ptr, SL("belongsTo"), &keyRelation, &relations); zephir_memory_observe(&singleRelations); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 1039, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 1040, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&singleRelations, &_6, &entityName, 0))) { ZEPHIR_INIT_NVAR(&singleRelations); array_init(&singleRelations); @@ -910,7 +910,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, 1040, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1041, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&hasMany, &_1); zephir_memory_observe(&relations); if (!(zephir_array_isset_fetch(&relations, &hasMany, &keyRelation, 0))) { @@ -963,7 +963,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, addHasMany) zephir_update_property_array(this_ptr, SL("aliases"), &_8, &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, 1041, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1042, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&singleRelations, &_1, &entityName, 0))) { ZEPHIR_INIT_NVAR(&singleRelations); array_init(&singleRelations); @@ -1079,7 +1079,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, 1042, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1043, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&hasManyToMany, &_1); zephir_memory_observe(&relations); if (!(zephir_array_isset_fetch(&relations, &hasManyToMany, &keyRelation, 0))) { @@ -1151,7 +1151,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, addHasManyToMany) zephir_update_property_array(this_ptr, SL("aliases"), &_12, &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, 1043, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1044, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&singleRelations, &_1, &entityName, 0))) { ZEPHIR_INIT_NVAR(&singleRelations); array_init(&singleRelations); @@ -1248,7 +1248,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, 1044, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1045, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&relations, &_1, &keyRelation, 0))) { ZEPHIR_INIT_NVAR(&relations); array_init(&relations); @@ -1299,7 +1299,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, addHasOne) zephir_update_property_array(this_ptr, SL("aliases"), &_9, &relation); zephir_update_property_array(this_ptr, SL("hasOne"), &keyRelation, &relations); zephir_memory_observe(&singleRelations); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 1045, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 1046, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&singleRelations, &_6, &entityName, 0))) { ZEPHIR_INIT_NVAR(&singleRelations); array_init(&singleRelations); @@ -1415,7 +1415,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, 1046, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1047, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&hasOneThrough, &_1); zephir_memory_observe(&relations); if (!(zephir_array_isset_fetch(&relations, &hasOneThrough, &keyRelation, 0))) { @@ -1487,7 +1487,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, addHasOneThrough) zephir_update_property_array(this_ptr, SL("aliases"), &_12, &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, 1047, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1048, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&singleRelations, &_1, &entityName, 0))) { ZEPHIR_INIT_NVAR(&singleRelations); array_init(&singleRelations); @@ -1516,7 +1516,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, 1048, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1049, &_0); ZEPHIR_MM_RESTORE(); } @@ -1562,7 +1562,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, createBuilder) params = ¶ms_sub; params = &__$null; } - 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, 1050, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (UNEXPECTED(Z_TYPE_P(&container) != IS_OBJECT)) { ZEPHIR_INIT_VAR(&_1$$3); @@ -1581,7 +1581,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, 1050, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1051, &_2); RETURN_MM_MEMBER(getThis(), "builder"); } @@ -1623,7 +1623,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, 1049, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1050, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (UNEXPECTED(Z_TYPE_P(&container) != IS_OBJECT)) { ZEPHIR_INIT_VAR(&_1$$3); @@ -1643,7 +1643,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, 1051, &query); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1052, &query); RETURN_CCTOR(&query); } @@ -1907,7 +1907,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, 1039, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1040, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (!(zephir_array_isset_fetch(&relations, &_0, &_1, 0))) { @@ -1994,7 +1994,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, 1040, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1041, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&relations, &_3, &keyRelation, 0))) { RETURN_MM_BOOL(0); } @@ -2073,7 +2073,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, 1052, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1053, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (zephir_array_isset_fetch(&eventsManager, &_0, &_1, 0)) { @@ -2125,7 +2125,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, 1041, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1042, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (!(zephir_array_isset_fetch(&relations, &_0, &_1, 0))) { @@ -2204,7 +2204,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, 1040, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1041, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&relations, &_3, &keyRelation, 0))) { RETURN_MM_BOOL(0); } @@ -2240,7 +2240,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, 1043, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1044, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (!(zephir_array_isset_fetch(&relations, &_0, &_1, 0))) { @@ -2275,7 +2275,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, 1045, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1046, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (!(zephir_array_isset_fetch(&relations, &_0, &_1, 0))) { @@ -2381,7 +2381,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, 1044, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1045, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&relations, &_3, &keyRelation, 0))) { RETURN_MM_BOOL(0); } @@ -2417,7 +2417,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, 1047, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1048, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (!(zephir_array_isset_fetch(&relations, &_0, &_1, 0))) { @@ -2479,7 +2479,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, 1053, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1054, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (!(zephir_array_isset_fetch(&schema, &_0, &_1, 0))) { @@ -2523,7 +2523,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, 1054, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1055, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_0, &entityName))) { ZEPHIR_INIT_VAR(&_1$$3); ZEPHIR_INIT_VAR(&_2$$3); @@ -2532,8 +2532,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, 1055, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 1054, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 1056, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 1055, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_5); zephir_array_fetch(&_5, &_4, &entityName, PH_NOISY, "phalcon/Mvc/Model/Manager.zep", 1366); ZEPHIR_CONCAT_VV(return_value, &_3, &_5); @@ -2580,20 +2580,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, 1056, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1057, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1057, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1058, 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, 1058, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 1059, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_2$$3, &writeService)) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 1057, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_1, 1058, 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, 1059, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 1060, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getConnection", NULL, 0, model, &_4); zephir_check_call_status(); RETURN_MM(); @@ -2622,7 +2622,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, 1059, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1060, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getConnectionService", NULL, 0, model, &_0); zephir_check_call_status(); RETURN_MM(); @@ -2661,7 +2661,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, 1060, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1061, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZEPHIR_INIT_VAR(&_2); ZEPHIR_CONCAT_VSV(&_2, &modelName_zv, "$", &alias_zv); @@ -3222,7 +3222,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, 1039, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1040, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&relations, &_0, &entityName, 0)) { if (Z_TYPE_P(&relations) == IS_STRING) { ZEPHIR_INIT_VAR(&_2$$3); @@ -3263,7 +3263,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getRelations) ZEPHIR_INIT_NVAR(&relation); } ZEPHIR_OBS_NVAR(&relations); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 1041, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 1042, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&relations, &_6, &entityName, 0)) { if (Z_TYPE_P(&relations) == IS_STRING) { ZEPHIR_INIT_VAR(&_8$$6); @@ -3304,7 +3304,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_2, 1045, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12, this_ptr, _zephir_prop_2, 1046, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&relations, &_12, &entityName, 0)) { if (Z_TYPE_P(&relations) == IS_STRING) { ZEPHIR_INIT_VAR(&_14$$9); @@ -3345,7 +3345,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getRelations) ZEPHIR_INIT_NVAR(&relation); } ZEPHIR_OBS_NVAR(&relations); - zephir_read_property_cached(&_18, this_ptr, _zephir_prop_3, 1047, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_18, this_ptr, _zephir_prop_3, 1048, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&relations, &_18, &entityName, 0)) { if (Z_TYPE_P(&relations) == IS_STRING) { ZEPHIR_INIT_VAR(&_20$$12); @@ -3386,7 +3386,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, getRelations) ZEPHIR_INIT_NVAR(&relation); } ZEPHIR_OBS_NVAR(&relations); - zephir_read_property_cached(&_24, this_ptr, _zephir_prop_4, 1043, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24, this_ptr, _zephir_prop_4, 1044, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&relations, &_24, &entityName, 0)) { if (Z_TYPE_P(&relations) == IS_STRING) { ZEPHIR_INIT_VAR(&_26$$15); @@ -3493,27 +3493,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, 1038, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1039, 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, 1040, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1041, 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, 1044, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 1045, 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, 1046, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_3, 1047, 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, 1042, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_4, 1043, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&relations, &_7, &keyRelation, 0)) { RETURN_CCTOR(&relations); } @@ -3552,7 +3552,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, 1048, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1049, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&records, &_0, &key_zv, 0))) { RETURN_MM_NULL(); } @@ -3582,7 +3582,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, 1057, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1058, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getConnection", NULL, 0, model, &_0); zephir_check_call_status(); RETURN_MM(); @@ -3611,7 +3611,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, 1057, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1058, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getConnectionService", NULL, 0, model, &_0); zephir_check_call_status(); RETURN_MM(); @@ -3813,7 +3813,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, 1061, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1062, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, &className)) { RETURN_MM_BOOL(0); } @@ -3822,8 +3822,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, 1062, model); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1063, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1063, model); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1064, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_1); if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_2$$5); @@ -3831,7 +3831,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, 1062, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1063, &__$null); RETURN_MM_BOOL(1); } @@ -3860,7 +3860,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, 1061, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1062, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_fast_strtolower(&_1, &className_zv); RETURN_MM_BOOL(zephir_array_isset_value(&_0, &_1)); @@ -3900,7 +3900,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, isKeepingSnapshots) RETURN_MM_BOOL(1); } zephir_memory_observe(&isKeeping); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1064, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1065, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_1); zephir_get_class(&_1, model, 1); if (!(zephir_array_isset_fetch(&isKeeping, &_2, &_1, 0))) { @@ -3943,7 +3943,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, isUsingDynamicUpdate) RETURN_MM_BOOL(1); } zephir_memory_observe(&isUsing); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1065, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1066, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_1); zephir_get_class(&_1, model, 1); if (!(zephir_array_isset_fetch(&isUsing, &_2, &_1, 0))) { @@ -4009,7 +4009,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, 1066, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1067, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_0, &className))) { ZEPHIR_INIT_VAR(&publicProperties); array_init(&publicProperties); @@ -4063,7 +4063,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(&_9, this_ptr, _zephir_prop_0, 1066, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 1067, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&properties); zephir_array_fetch(&properties, &_9, &className, PH_NOISY, "phalcon/Mvc/Model/Manager.zep", 2005); RETURN_MM_BOOL(zephir_array_key_exists(&properties, &property_zv)); @@ -4142,7 +4142,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, 1049, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1050, PH_NOISY_CC); zephir_array_fast_append(&_1, &_2); zephir_array_fast_append(&_1, this_ptr); ZEPHIR_INIT_VAR(&model); @@ -4206,7 +4206,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, 1037, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1038, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (zephir_array_isset_fetch(&modelsBehaviors, &_0, &_1, 0)) { @@ -4256,7 +4256,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, missingMethod) } ZEPHIR_INIT_NVAR(&behavior); } - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 1063, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 1064, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_7); if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_8$$8); @@ -4326,7 +4326,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, 1037, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1038, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); zephir_get_class(&_1, model, 1); if (zephir_array_isset_fetch(&modelsBehaviors, &_0, &_1, 0)) { @@ -4376,7 +4376,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, notifyEvent) } ZEPHIR_INIT_NVAR(&behavior); } - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 1063, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 1064, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_7); if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_8$$8); @@ -4388,7 +4388,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Manager, notifyEvent) } } zephir_memory_observe(&customEventsManager); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 1052, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_2, 1053, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_9); zephir_get_class(&_9, model, 1); if (zephir_array_isset_fetch(&customEventsManager, &_7, &_9, 0)) { @@ -4435,11 +4435,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, 1056, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1057, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1057, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1058, 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); @@ -4492,13 +4492,13 @@ 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, 1037, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1038, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value(&_0, &entityName))) { RETURN_MM_NULL(); } ZEPHIR_INIT_VAR(&remaining); array_init(&remaining); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1037, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1038, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2); zephir_array_fetch(&_2, &_1, &entityName, PH_NOISY, "phalcon/Mvc/Model/Manager.zep", 2210); if (Z_TYPE_P(&_2) == IS_STRING) { @@ -4571,7 +4571,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, 1058, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1059, &_0); ZEPHIR_MM_RESTORE(); } @@ -4647,7 +4647,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, 1049, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1050, container); } /** @@ -4672,7 +4672,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, 1063, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1064, eventsManager); } /** @@ -4713,7 +4713,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, 1055, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1056, &prefix_zv); } /** @@ -4852,9 +4852,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, 1056, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1057, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1056, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1057, &__$false); } } @@ -4958,7 +4958,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, 1049, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1050, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (UNEXPECTED(Z_TYPE_P(&container) != IS_OBJECT)) { ZEPHIR_INIT_VAR(&_1$$3); @@ -5027,7 +5027,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, 1061, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1062, 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 38a8895c90..c32eb01a78 100644 --- a/ext/phalcon/mvc/model/metadata/apcu.zep.c +++ b/ext/phalcon/mvc/model/metadata/apcu.zep.c @@ -111,7 +111,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, 1067, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1068, &_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 6c12ca219f..ad0bc3e246 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, 1068, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1069, &_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, 1068, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1069, 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 1726a0dc5a..1cd6f1f606 100644 --- a/ext/phalcon/mvc/model/metadata/redis.zep.c +++ b/ext/phalcon/mvc/model/metadata/redis.zep.c @@ -114,7 +114,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, 1069, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1070, &_5); ZEPHIR_MM_RESTORE(); } @@ -136,7 +136,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, 1069, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1070, 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 fa569bc3e6..50aed81080 100644 --- a/ext/phalcon/mvc/model/metadata/stream.zep.c +++ b/ext/phalcon/mvc/model/metadata/stream.zep.c @@ -95,7 +95,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, 1070, &metaDataDir); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1071, &metaDataDir); } ZEPHIR_MM_RESTORE(); } @@ -288,7 +288,7 @@ PHP_METHOD(Phalcon_Mvc_Model_MetaData_Stream, getFilePath) ZEPHIR_CONCAT_VSV(&_2$$3, &name, "_", &_1$$3); ZEPHIR_CPY_WRT(&name, &_2$$3); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1070, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1071, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_VVS(return_value, &_3, &name, ".php"); RETURN_MM(); } diff --git a/ext/phalcon/mvc/model/query.zep.c b/ext/phalcon/mvc/model/query.zep.c index c58006f441..e3942d8163 100644 --- a/ext/phalcon/mvc/model/query.zep.c +++ b/ext/phalcon/mvc/model/query.zep.c @@ -360,7 +360,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, 1071, &phql_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1072, &phql_zv); if (Z_TYPE_P(container) == IS_OBJECT) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "setDI", NULL, 0, container); zephir_check_call_status(); @@ -368,23 +368,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, 1072, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1073, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1072, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1073, &__$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, 1072, &_0$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1073, &_0$$5); } ZEPHIR_INIT_VAR(&_2); array_init(&_2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1073, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1074, &_2); ZEPHIR_INIT_VAR(&_3); array_init(&_3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1074, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1075, &_3); ZEPHIR_MM_RESTORE(); } @@ -431,7 +431,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, 1075, &cacheOptions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1076, &cacheOptions); RETURN_THIS(); } @@ -538,9 +538,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, execute) ZVAL_NULL(&lifetime); ZEPHIR_INIT_VAR(&result); ZVAL_BOOL(&result, 0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1076, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1077, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&uniqueRow, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1075, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1076, 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)) { @@ -567,7 +567,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, 1077, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$3, this_ptr, _zephir_prop_2, 1078, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&cache, &_3$$3, "getShared", NULL, 0, &cacheService); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_4$$3); @@ -620,23 +620,23 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, execute) } RETURN_CCTOR(&preparedResult); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1078, &cache); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1079, &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, 1073, PH_NOISY_CC); + zephir_read_property_cached(&defaultBindParams, this_ptr, _zephir_prop_4, 1074, 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, 1074, PH_NOISY_CC); + zephir_read_property_cached(&defaultBindTypes, this_ptr, _zephir_prop_5, 1075, 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, 1079, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 1080, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&type, &_0); if (ZEPHIR_IS_LONG(&type, 309)) { goto zephir_switch_0_clause_0; } if (ZEPHIR_IS_LONG(&type, 306)) { goto zephir_switch_0_clause_1; } @@ -796,7 +796,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, 1076, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1077, 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(); @@ -853,10 +853,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, 1079, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1080, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_LONG(&_0, 309)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1073, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 1074, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1074, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 1075, 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(); @@ -956,12 +956,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, 1080, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1081, 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, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1072, 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(); @@ -978,7 +978,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, parse) if (Z_TYPE_P(&irPhql) == IS_ARRAY) { zephir_memory_observe(&_2$$7); zephir_array_fetch_string(&_2$$7, &ast, SL("type"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 684); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1079, &_2$$7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1080, &_2$$7); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "refreshSchemasInIntermediate", NULL, 0, &irPhql); zephir_check_call_status(); RETURN_MM(); @@ -987,8 +987,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, 1081, &ast); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1079, &type); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1082, &ast); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1080, &type); if (ZEPHIR_IS_LONG(&type, 309)) { goto zephir_switch_0_clause_0; } if (ZEPHIR_IS_LONG(&type, 306)) { goto zephir_switch_0_clause_1; } if (ZEPHIR_IS_LONG(&type, 300)) { goto zephir_switch_0_clause_2; } @@ -1034,7 +1034,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, 1080, &irPhql); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1081, &irPhql); RETURN_CCTOR(&irPhql); } @@ -1074,12 +1074,12 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, setBindParams) } if (merge) { zephir_memory_observe(¤tBindParams); - zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_0, 1073, PH_NOISY_CC); + zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_0, 1074, 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, 1073, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1074, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1073, &bindParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1074, &bindParams); } RETURN_THIS(); } @@ -1120,16 +1120,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, 1074, PH_NOISY_CC); + zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_0, 1075, 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, 1074, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1075, &_0$$4); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1074, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1075, &bindTypes); } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1074, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1075, &bindTypes); } RETURN_THIS(); } @@ -1195,9 +1195,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, setDI) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1082, &manager); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1083, &metaData); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1077, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1083, &manager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1084, &metaData); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1078, container); ZEPHIR_MM_RESTORE(); } @@ -1226,7 +1226,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, 1080, &intermediate); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1081, &intermediate); RETURN_THIS(); } @@ -1282,7 +1282,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, setResultsetRowClass) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1084, &resultsetRowClass_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1085, &resultsetRowClass_zv); RETURN_THIS(); } @@ -1312,9 +1312,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, setSharedLock) } else { } if (sharedLock) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1085, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1086, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1085, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1086, &__$false); } RETURN_THISW(); } @@ -1337,7 +1337,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, 1086, transaction); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1087, transaction); RETURN_THISW(); } @@ -1362,7 +1362,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, 1079, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1080, &_0); RETURN_THISW(); } @@ -1388,9 +1388,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, 1076, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1077, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1076, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1077, &__$false); } RETURN_THISW(); } @@ -1465,9 +1465,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", 904); zephir_memory_observe(&model); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1087, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1088, 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, 1082, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 1083, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&model, &_2$$4, "load", NULL, 0, &modelName); zephir_check_call_status(); } @@ -1629,17 +1629,17 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeInsert) ZVAL_NULL(&columnMap); zephir_memory_observe(&modelName); zephir_array_fetch_string(&modelName, &intermediate, SL("model"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 994); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1082, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1083, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); zephir_memory_observe(&model); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1087, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1088, 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, 1083, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1084, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&metaData, &_1); ZEPHIR_CALL_METHOD(&attributes, &metaData, "getAttributes", NULL, 0, &model); zephir_check_call_status(); @@ -2104,7 +2104,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeSelect) ZEPHIR_INIT_VAR(&model); ZVAL_NULL(&model); isSimpleStd = 1; - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1082, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1083, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); ZEPHIR_INIT_VAR(&connectionTypes); array_init(&connectionTypes); @@ -2124,7 +2124,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeSelect) ZEPHIR_INIT_NVAR(&modelName); ZVAL_COPY(&modelName, _3); ZEPHIR_OBS_NVAR(&model); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 1087, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 1088, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&model, &_4$$3, &modelName, 0))) { ZEPHIR_CALL_METHOD(&model, &manager, "load", &_5, 0, &modelName); zephir_check_call_status(); @@ -2177,7 +2177,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeSelect) ZEPHIR_CALL_METHOD(&modelName, _1, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&model); - zephir_read_property_cached(&_15$$9, this_ptr, _zephir_prop_1, 1087, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$9, this_ptr, _zephir_prop_1, 1088, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&model, &_15$$9, &modelName, 0))) { ZEPHIR_CALL_METHOD(&model, &manager, "load", &_16, 0, &modelName); zephir_check_call_status(); @@ -2316,7 +2316,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, 1083, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1084, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&metaData, &_0); if (Z_TYPE_P(&columns) == IS_STRING) { ZEPHIR_INIT_VAR(&_32); @@ -2345,7 +2345,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", 1236); ZEPHIR_OBS_NVAR(&instance); - zephir_read_property_cached(&_37$$33, this_ptr, _zephir_prop_1, 1087, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_37$$33, this_ptr, _zephir_prop_1, 1088, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&instance, &_37$$33, &modelName, 0))) { ZEPHIR_CALL_METHOD(&instance, &manager, "load", &_38, 0, &modelName); zephir_check_call_status(); @@ -2533,7 +2533,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", 1236); ZEPHIR_OBS_NVAR(&instance); - zephir_read_property_cached(&_68$$51, this_ptr, _zephir_prop_1, 1087, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_68$$51, this_ptr, _zephir_prop_1, 1088, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&instance, &_68$$51, &modelName, 0))) { ZEPHIR_CALL_METHOD(&instance, &manager, "load", &_69, 0, &modelName); zephir_check_call_status(); @@ -2821,7 +2821,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, 1085, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1086, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(&_109$$83, &dialect, "sharedLock", NULL, 0, &sqlSelect); zephir_check_call_status(); @@ -2980,13 +2980,13 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, executeSelect) ZEPHIR_INIT_NVAR(&resultData); ZVAL_NULL(&resultData); } - zephir_read_property_cached(&_146, this_ptr, _zephir_prop_4, 1078, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_146, this_ptr, _zephir_prop_4, 1079, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cache, &_146); if (!(isComplex)) { if (isSimpleStd) { - zephir_read_property_cached(&_147$$93, this_ptr, _zephir_prop_5, 1084, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_147$$93, this_ptr, _zephir_prop_5, 1085, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_STRING_IDENTICAL(&_147$$93, "")) { - zephir_read_property_cached(&_148$$94, this_ptr, _zephir_prop_5, 1084, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_148$$94, this_ptr, _zephir_prop_5, 1085, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&resultObject); ZEPHIR_LAST_CALL_STATUS = zephir_create_instance(&resultObject, &_148$$94); zephir_check_call_status(); @@ -3193,7 +3193,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(&_146, this_ptr, _zephir_prop_5, 1084, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_146, this_ptr, _zephir_prop_5, 1085, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, &columns1, &resultData, &cache, &_146); zephir_check_call_status(); RETURN_MM(); @@ -3361,9 +3361,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", 1576); zephir_memory_observe(&model); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1087, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1088, 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, 1082, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_1, 1083, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&model, &_2$$4, "load", NULL, 0, &modelName); zephir_check_call_status(); } @@ -4618,7 +4618,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getExpression) zephir_switch_1_clause_7: ; zephir_switch_1_clause_8: ; zephir_memory_observe(&bind); - zephir_read_property_cached(&_51$$41, this_ptr, _zephir_prop_0, 1073, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_51$$41, this_ptr, _zephir_prop_0, 1074, PH_NOISY_CC | PH_READONLY); if (UNEXPECTED(!(zephir_array_isset_fetch(&bind, &_51$$41, &name, 0)))) { ZEPHIR_INIT_VAR(&_52$$42); object_init_ex(&_52$$42, phalcon_mvc_model_query_exceptions_bindvaluerequired_ce); @@ -4835,7 +4835,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getExpression) object_init_ex(&_82$$65, phalcon_mvc_model_query_exceptions_unsafeidentifier_ce); zephir_memory_observe(&_83$$65); zephir_array_fetch_string(&_83$$65, &expr, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2372); - zephir_read_property_cached(&_84$$65, this_ptr, _zephir_prop_1, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_84$$65, this_ptr, _zephir_prop_1, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_82$$65, "__construct", NULL, 0, &_83$$65, &_84$$65); zephir_check_call_status(); zephir_throw_exception_debug(&_82$$65, "phalcon/Mvc/Model/Query.zep", 2372); @@ -5078,7 +5078,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getFunctionCall) if (UNEXPECTED(!zephir_is_true(&_2))) { ZEPHIR_INIT_VAR(&_4$$3); object_init_ex(&_4$$3, phalcon_mvc_model_query_exceptions_unsafeidentifier_ce); - zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$3, this_ptr, _zephir_prop_0, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_4$$3, "__construct", NULL, 0, &name, &_5$$3); zephir_check_call_status(); zephir_throw_exception_debug(&_4$$3, "phalcon/Mvc/Model/Query.zep", 2542); @@ -5461,17 +5461,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, 1088, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1089, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&models, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1089, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1090, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlAliases, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1090, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1091, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlAliasesModels, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1091, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1092, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlModelsAliases, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1092, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1093, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlAliasesModelsInstances, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 1087, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 1088, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&modelsInstances, &_0); ZEPHIR_CPY_WRT(&fromModels, &models); ZEPHIR_INIT_VAR(&sqlJoins); @@ -5486,7 +5486,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, 1082, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 1083, 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", 2682); @@ -5542,7 +5542,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoins) if (UNEXPECTED(zephir_array_isset_value(&joinModels, &alias))) { ZEPHIR_INIT_NVAR(&_6$$9); object_init_ex(&_6$$9, phalcon_mvc_model_query_exceptions_joinaliasalreadyused_ce); - zephir_read_property_cached(&_7$$9, this_ptr, _zephir_prop_7, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$9, this_ptr, _zephir_prop_7, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_6$$9, "__construct", &_8, 0, &alias, &_7$$9); zephir_check_call_status(); zephir_throw_exception_debug(&_6$$9, "phalcon/Mvc/Model/Query.zep", 2725); @@ -5563,7 +5563,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoins) if (UNEXPECTED(zephir_array_isset_value(&joinModels, &realModelName))) { ZEPHIR_INIT_NVAR(&_9$$11); object_init_ex(&_9$$11, phalcon_mvc_model_query_exceptions_joinaliasalreadyused_ce); - zephir_read_property_cached(&_10$$11, this_ptr, _zephir_prop_7, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$11, this_ptr, _zephir_prop_7, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_9$$11, "__construct", &_8, 0, &realModelName, &_10$$11); zephir_check_call_status(); zephir_throw_exception_debug(&_9$$11, "phalcon/Mvc/Model/Query.zep", 2782); @@ -5624,7 +5624,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoins) if (UNEXPECTED(zephir_array_isset_value(&joinModels, &alias))) { ZEPHIR_INIT_NVAR(&_14$$14); object_init_ex(&_14$$14, phalcon_mvc_model_query_exceptions_joinaliasalreadyused_ce); - zephir_read_property_cached(&_15$$14, this_ptr, _zephir_prop_7, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$14, this_ptr, _zephir_prop_7, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_14$$14, "__construct", &_8, 0, &alias, &_15$$14); zephir_check_call_status(); zephir_throw_exception_debug(&_14$$14, "phalcon/Mvc/Model/Query.zep", 2725); @@ -5645,7 +5645,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoins) if (UNEXPECTED(zephir_array_isset_value(&joinModels, &realModelName))) { ZEPHIR_INIT_NVAR(&_16$$16); object_init_ex(&_16$$16, phalcon_mvc_model_query_exceptions_joinaliasalreadyused_ce); - zephir_read_property_cached(&_17$$16, this_ptr, _zephir_prop_7, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$16, this_ptr, _zephir_prop_7, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_16$$16, "__construct", &_8, 0, &realModelName, &_17$$16); zephir_check_call_status(); zephir_throw_exception_debug(&_16$$16, "phalcon/Mvc/Model/Query.zep", 2782); @@ -5666,12 +5666,12 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoins) } } ZEPHIR_INIT_NVAR(&joinItem); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1088, &models); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1089, &sqlAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1090, &sqlAliasesModels); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1091, &sqlModelsAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1092, &sqlAliasesModelsInstances); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1087, &modelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1089, &models); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1090, &sqlAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1091, &sqlAliasesModels); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1092, &sqlModelsAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1093, &sqlAliasesModelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1088, &modelsInstances); zephir_is_iterable(&joinPrepared, 0, "phalcon/Mvc/Model/Query.zep", 2857); ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&joinPrepared), _19, _20, _18) { @@ -5692,7 +5692,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, 1072, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_8, 1073, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { ZEPHIR_INIT_VAR(&_23$$19); zephir_is_iterable(&joinPrepared, 0, "phalcon/Mvc/Model/Query.zep", 2869); @@ -5821,7 +5821,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoins) if (UNEXPECTED(zephir_fast_count_int(&relations) != 1)) { ZEPHIR_INIT_NVAR(&_49$$28); object_init_ex(&_49$$28, phalcon_mvc_model_query_exceptions_ambiguousjoinrelation_ce); - zephir_read_property_cached(&_50$$28, this_ptr, _zephir_prop_7, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_50$$28, this_ptr, _zephir_prop_7, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_49$$28, "__construct", &_51, 0, &fromModelName, &joinModel, &_50$$28); zephir_check_call_status(); zephir_throw_exception_debug(&_49$$28, "phalcon/Mvc/Model/Query.zep", 2927); @@ -5958,7 +5958,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getJoins) if (UNEXPECTED(zephir_fast_count_int(&relations) != 1)) { ZEPHIR_INIT_NVAR(&_71$$43); object_init_ex(&_71$$43, phalcon_mvc_model_query_exceptions_ambiguousjoinrelation_ce); - zephir_read_property_cached(&_72$$43, this_ptr, _zephir_prop_7, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_72$$43, this_ptr, _zephir_prop_7, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_71$$43, "__construct", &_51, 0, &fromModelName, &joinModel, &_72$$43); zephir_check_call_status(); zephir_throw_exception_debug(&_71$$43, "phalcon/Mvc/Model/Query.zep", 2927); @@ -6113,7 +6113,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, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1072, 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", 3035); @@ -6262,7 +6262,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, 1082, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1083, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); ZEPHIR_CALL_METHOD(&intermediateModel, &manager, "load", NULL, 0, &intermediateModelName); zephir_check_call_status(); @@ -6301,7 +6301,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getMultiJoin) if (UNEXPECTED(!(zephir_array_isset_value(&referencedFields, &position)))) { ZEPHIR_INIT_NVAR(&_6$$5); object_init_ex(&_6$$5, phalcon_mvc_model_query_exceptions_joinfieldcountmismatch_ce); - zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_1, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_1, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_6$$5, "__construct", &_8, 0, &modelAlias_zv, &joinAlias_zv, &_7$$5); zephir_check_call_status(); zephir_throw_exception_debug(&_6$$5, "phalcon/Mvc/Model/Query.zep", 3142); @@ -6354,7 +6354,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getMultiJoin) if (UNEXPECTED(!(zephir_array_isset_value(&referencedFields, &position)))) { ZEPHIR_INIT_NVAR(&_15$$7); object_init_ex(&_15$$7, phalcon_mvc_model_query_exceptions_joinfieldcountmismatch_ce); - zephir_read_property_cached(&_16$$7, this_ptr, _zephir_prop_1, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$7, this_ptr, _zephir_prop_1, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_15$$7, "__construct", &_8, 0, &modelAlias_zv, &joinAlias_zv, &_16$$7); zephir_check_call_status(); zephir_throw_exception_debug(&_15$$7, "phalcon/Mvc/Model/Query.zep", 3142); @@ -6717,11 +6717,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", 3301); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1093, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1094, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&nestingLevel, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1094, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1095, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_0, &nestingLevel)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1094, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1095, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2$$3); zephir_array_fetch(&_2$$3, &_1$$3, &nestingLevel, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3309); ZEPHIR_CPY_WRT(&sqlColumnAliases, &_2$$3); @@ -6743,17 +6743,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(&_5, this_ptr, _zephir_prop_2, 1083, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_2, 1084, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&metaData, &_5); zephir_memory_observe(&columnDomain); if (zephir_array_isset_string_fetch(&columnDomain, &expr, SL("domain"), 0)) { - zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_3, 1089, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_3, 1090, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlAliases, &_6$$6); zephir_memory_observe(&source); if (UNEXPECTED(!(zephir_array_isset_fetch(&source, &sqlAliases, &columnDomain, 0)))) { ZEPHIR_INIT_VAR(&_7$$7); object_init_ex(&_7$$7, phalcon_mvc_model_query_exceptions_unknownmodeloralias_ce); - zephir_read_property_cached(&_8$$7, this_ptr, _zephir_prop_4, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$7, this_ptr, _zephir_prop_4, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_9$$7); ZVAL_STRING(&_9$$7, "11"); ZEPHIR_CALL_METHOD(NULL, &_7$$7, "__construct", NULL, 0, &columnDomain, &_9$$7, &_8$$7); @@ -6767,13 +6767,13 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) ZEPHIR_CALL_CE_STATIC(&_10$$6, phalcon_support_settings_ce, "get", NULL, 0, &_11$$6); zephir_check_call_status(); if (zephir_is_true(&_10$$6)) { - zephir_read_property_cached(&_12$$8, this_ptr, _zephir_prop_5, 1092, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$8, this_ptr, _zephir_prop_5, 1093, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlAliasesModelsInstances, &_12$$8); zephir_memory_observe(&model); if (UNEXPECTED(!(zephir_array_isset_fetch(&model, &sqlAliasesModelsInstances, &columnDomain, 0)))) { ZEPHIR_INIT_VAR(&_13$$9); object_init_ex(&_13$$9, phalcon_mvc_model_query_exceptions_nomodelforalias_ce); - zephir_read_property_cached(&_14$$9, this_ptr, _zephir_prop_4, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$9, this_ptr, _zephir_prop_4, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_13$$9, "__construct", NULL, 0, &columnDomain, &_14$$9); zephir_check_call_status(); zephir_throw_exception_debug(&_13$$9, "phalcon/Mvc/Model/Query.zep", 3350); @@ -6791,7 +6791,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) if (UNEXPECTED(!(zephir_array_isset_fetch(&realColumnName, &columnMap, &columnName, 0)))) { ZEPHIR_INIT_VAR(&_15$$12); object_init_ex(&_15$$12, phalcon_mvc_model_query_exceptions_columnnotindomain_ce); - zephir_read_property_cached(&_16$$12, this_ptr, _zephir_prop_4, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$12, this_ptr, _zephir_prop_4, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_15$$12, "__construct", NULL, 0, &columnName, &columnDomain, &_16$$12); zephir_check_call_status(); zephir_throw_exception_debug(&_15$$12, "phalcon/Mvc/Model/Query.zep", 3360); @@ -6805,7 +6805,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) number = 0; ZEPHIR_INIT_VAR(&hasModel); ZVAL_BOOL(&hasModel, 0); - zephir_read_property_cached(&_17$$14, this_ptr, _zephir_prop_6, 1087, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$14, this_ptr, _zephir_prop_6, 1088, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_17$$14) == IS_STRING) { ZEPHIR_INIT_VAR(&_19$$14); zephir_string_to_char_array(&_19$$14, &_17$$14); @@ -6826,7 +6826,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) if (UNEXPECTED(number > 1)) { ZEPHIR_INIT_NVAR(&_23$$17); object_init_ex(&_23$$17, phalcon_mvc_model_query_exceptions_ambiguouscolumn_ce); - zephir_read_property_cached(&_24$$17, this_ptr, _zephir_prop_4, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24$$17, this_ptr, _zephir_prop_4, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_23$$17, "__construct", &_25, 0, &columnName, &_24$$17); zephir_check_call_status(); zephir_throw_exception_debug(&_23$$17, "phalcon/Mvc/Model/Query.zep", 3381); @@ -6861,7 +6861,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) if (UNEXPECTED(number > 1)) { ZEPHIR_INIT_NVAR(&_30$$20); object_init_ex(&_30$$20, phalcon_mvc_model_query_exceptions_ambiguouscolumn_ce); - zephir_read_property_cached(&_31$$20, this_ptr, _zephir_prop_4, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_31$$20, this_ptr, _zephir_prop_4, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_30$$20, "__construct", &_25, 0, &columnName, &_31$$20); zephir_check_call_status(); zephir_throw_exception_debug(&_30$$20, "phalcon/Mvc/Model/Query.zep", 3381); @@ -6876,7 +6876,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) if (UNEXPECTED(ZEPHIR_IS_FALSE_IDENTICAL(&hasModel))) { ZEPHIR_INIT_VAR(&_32$$21); object_init_ex(&_32$$21, phalcon_mvc_model_query_exceptions_columnnotinselectedmodels_ce); - zephir_read_property_cached(&_33$$21, this_ptr, _zephir_prop_4, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_33$$21, this_ptr, _zephir_prop_4, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_34$$21); ZVAL_STRING(&_34$$21, "1"); ZEPHIR_CALL_METHOD(NULL, &_32$$21, "__construct", NULL, 0, &columnName, &_34$$21, &_33$$21); @@ -6885,7 +6885,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_35$$14, this_ptr, _zephir_prop_7, 1088, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_35$$14, this_ptr, _zephir_prop_7, 1089, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&models, &_35$$14); if (UNEXPECTED(Z_TYPE_P(&models) != IS_ARRAY)) { ZEPHIR_INIT_VAR(&_36$$22); @@ -6902,7 +6902,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) if (UNEXPECTED(!(zephir_array_isset_fetch(&source, &models, &className, 0)))) { ZEPHIR_INIT_VAR(&_37$$23); object_init_ex(&_37$$23, phalcon_mvc_model_query_exceptions_modelsourcenotfound_ce); - zephir_read_property_cached(&_38$$23, this_ptr, _zephir_prop_4, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_38$$23, this_ptr, _zephir_prop_4, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_37$$23, "__construct", NULL, 0, &className, &_38$$23); zephir_check_call_status(); zephir_throw_exception_debug(&_37$$23, "phalcon/Mvc/Model/Query.zep", 3411); @@ -6925,7 +6925,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getQualified) if (UNEXPECTED(!(zephir_array_isset_fetch(&realColumnName, &columnMap, &columnName, 0)))) { ZEPHIR_INIT_VAR(&_41$$27); object_init_ex(&_41$$27, phalcon_mvc_model_query_exceptions_columnnotinselectedmodels_ce); - zephir_read_property_cached(&_42$$27, this_ptr, _zephir_prop_4, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_42$$27, this_ptr, _zephir_prop_4, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_43$$27); ZVAL_STRING(&_43$$27, "3"); ZEPHIR_CALL_METHOD(NULL, &_41$$27, "__construct", NULL, 0, &columnName, &_43$$27, &_42$$27); @@ -7006,7 +7006,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, 1086, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1087, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&transaction, &_0); _1 = Z_TYPE_P(&transaction) == IS_OBJECT; if (_1) { @@ -7123,7 +7123,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, 1077, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 1078, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &query, "setDI", NULL, 0, &_5); zephir_check_call_status(); ZVAL_LONG(&_6, 309); @@ -7234,7 +7234,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, 1088, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_0, 1089, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_1$$4) == IS_STRING) { ZEPHIR_INIT_VAR(&_3$$4); zephir_string_to_char_array(&_3$$4, &_1$$4); @@ -7338,7 +7338,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getSelectColumn) return; } if (ZEPHIR_IS_LONG(&columnType, 353)) { - zephir_read_property_cached(&_20$$10, this_ptr, _zephir_prop_1, 1089, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$10, this_ptr, _zephir_prop_1, 1090, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlAliases, &_20$$10); zephir_memory_observe(&columnDomain); zephir_array_fetch_string(&columnDomain, &column, SL("column"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3606); @@ -7346,7 +7346,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getSelectColumn) if (UNEXPECTED(!(zephir_array_isset_fetch(&source, &sqlAliases, &columnDomain, 0)))) { ZEPHIR_INIT_VAR(&_21$$11); object_init_ex(&_21$$11, phalcon_mvc_model_query_exceptions_unknownmodeloralias_ce); - zephir_read_property_cached(&_22$$11, this_ptr, _zephir_prop_2, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$11, this_ptr, _zephir_prop_2, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_23$$11); ZVAL_STRING(&_23$$11, "2"); ZEPHIR_CALL_METHOD(NULL, &_21$$11, "__construct", NULL, 0, &columnDomain, &_23$$11, &_22$$11); @@ -7358,7 +7358,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(&_20$$10, this_ptr, _zephir_prop_3, 1090, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$10, this_ptr, _zephir_prop_3, 1091, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&sqlAliasesModels, &_20$$10); ZEPHIR_OBS_NVAR(&modelName); zephir_array_fetch(&modelName, &sqlAliasesModels, &columnDomain, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3623); @@ -7554,7 +7554,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getSingleJoin) if (UNEXPECTED(!(zephir_array_isset_fetch(&referencedField, &referencedFields, &position, 0)))) { ZEPHIR_INIT_NVAR(&_10$$6); object_init_ex(&_10$$6, phalcon_mvc_model_query_exceptions_joinfieldcountmismatch_ce); - zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_0, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_0, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_10$$6, "__construct", &_12, 0, &modelAlias_zv, &joinAlias_zv, &_11$$6); zephir_check_call_status(); zephir_throw_exception_debug(&_10$$6, "phalcon/Mvc/Model/Query.zep", 3746); @@ -7607,7 +7607,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, getSingleJoin) if (UNEXPECTED(!(zephir_array_isset_fetch(&referencedField, &referencedFields, &position, 0)))) { ZEPHIR_INIT_NVAR(&_19$$8); object_init_ex(&_19$$8, phalcon_mvc_model_query_exceptions_joinfieldcountmismatch_ce); - zephir_read_property_cached(&_20$$8, this_ptr, _zephir_prop_0, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$8, this_ptr, _zephir_prop_0, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_19$$8, "__construct", &_12, 0, &modelAlias_zv, &joinAlias_zv, &_20$$8); zephir_check_call_status(); zephir_throw_exception_debug(&_19$$8, "phalcon/Mvc/Model/Query.zep", 3746); @@ -7762,7 +7762,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, 1086, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1087, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&transaction, &_0); _1 = Z_TYPE_P(&transaction) == IS_OBJECT; if (_1) { @@ -7869,7 +7869,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, 1081, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1082, 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)))) { @@ -7910,7 +7910,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareDelete) } else { ZEPHIR_CPY_WRT(&deleteTables, &tables); } - 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, 1083, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); if (Z_TYPE_P(&deleteTables) == IS_STRING) { ZEPHIR_INIT_VAR(&_4); @@ -8024,10 +8024,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareDelete) } } ZEPHIR_INIT_NVAR(&table); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1088, &models); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1087, &modelsInstances); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1089, &sqlAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1092, &sqlAliasesModelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1089, &models); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1088, &modelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1090, &sqlAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1093, &sqlAliasesModelsInstances); ZEPHIR_INIT_VAR(&sqlDelete); array_init(&sqlDelete); zephir_array_update_string(&sqlDelete, SL("tables"), &sqlTables, PH_COPY | PH_SEPARATE); @@ -8122,7 +8122,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, 1081, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1082, 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); @@ -8153,7 +8153,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareInsert) 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, 1083, 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", 3977); @@ -8242,7 +8242,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, 1083, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1084, 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)) { @@ -8268,7 +8268,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareInsert) if (UNEXPECTED(!zephir_is_true(&_23$$10))) { ZEPHIR_INIT_NVAR(&_25$$11); object_init_ex(&_25$$11, phalcon_mvc_model_query_exceptions_missingmodelattribute_ce); - zephir_read_property_cached(&_26$$11, this_ptr, _zephir_prop_3, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_26$$11, this_ptr, _zephir_prop_3, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_25$$11, "__construct", &_27, 0, &modelName, &name, &_26$$11); zephir_check_call_status(); zephir_throw_exception_debug(&_25$$11, "phalcon/Mvc/Model/Query.zep", 4013); @@ -8302,7 +8302,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareInsert) if (UNEXPECTED(!zephir_is_true(&_30$$12))) { ZEPHIR_INIT_NVAR(&_32$$13); object_init_ex(&_32$$13, phalcon_mvc_model_query_exceptions_missingmodelattribute_ce); - zephir_read_property_cached(&_33$$13, this_ptr, _zephir_prop_3, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_33$$13, this_ptr, _zephir_prop_3, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_32$$13, "__construct", &_27, 0, &modelName, &name, &_33$$13); zephir_check_call_status(); zephir_throw_exception_debug(&_32$$13, "phalcon/Mvc/Model/Query.zep", 4013); @@ -8563,7 +8563,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) ZEPHIR_INIT_VAR(&tempSqlAliases); array_init(&tempSqlAliases); if (ZEPHIR_IS_EMPTY(ast)) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1081, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1082, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(ast, &_0$$3); } zephir_memory_observe(&select); @@ -8623,9 +8623,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) } else { ZEPHIR_CPY_WRT(&selectColumns, &columns); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 1082, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 1083, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1083, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1084, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&metaData, &_3); if (UNEXPECTED(Z_TYPE_P(&manager) != IS_OBJECT)) { ZEPHIR_INIT_VAR(&_4$$11); @@ -8684,7 +8684,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) if (UNEXPECTED(zephir_array_isset_value(&sqlAliases, &alias))) { ZEPHIR_INIT_NVAR(&_10$$17); object_init_ex(&_10$$17, phalcon_mvc_model_query_exceptions_duplicatealias_ce); - zephir_read_property_cached(&_11$$17, this_ptr, _zephir_prop_3, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$17, this_ptr, _zephir_prop_3, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_10$$17, "__construct", &_12, 0, &alias, &_11$$17); zephir_check_call_status(); zephir_throw_exception_debug(&_10$$17, "phalcon/Mvc/Model/Query.zep", 4167); @@ -8760,7 +8760,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) if (UNEXPECTED(Z_TYPE_P(&relations) != IS_ARRAY)) { ZEPHIR_INIT_NVAR(&_22$$27); object_init_ex(&_22$$27, phalcon_mvc_model_query_exceptions_relationshipnotfound_ce); - zephir_read_property_cached(&_23$$27, this_ptr, _zephir_prop_3, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$27, this_ptr, _zephir_prop_3, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_22$$27, "__construct", &_24, 0, &modelName, &relationModel, &_23$$27); zephir_check_call_status(); zephir_throw_exception_debug(&_22$$27, "phalcon/Mvc/Model/Query.zep", 4228); @@ -8770,7 +8770,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) if (UNEXPECTED(zephir_fast_count_int(&relations) != 1)) { ZEPHIR_INIT_NVAR(&_25$$28); object_init_ex(&_25$$28, phalcon_mvc_model_query_exceptions_ambiguousjoinrelation_ce); - zephir_read_property_cached(&_26$$28, this_ptr, _zephir_prop_3, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_26$$28, this_ptr, _zephir_prop_3, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_25$$28, "__construct", &_27, 0, &modelName, &relationModel, &_26$$28); zephir_check_call_status(); zephir_throw_exception_debug(&_25$$28, "phalcon/Mvc/Model/Query.zep", 4235); @@ -8854,7 +8854,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) if (UNEXPECTED(Z_TYPE_P(&relations) != IS_ARRAY)) { ZEPHIR_INIT_NVAR(&_39$$32); object_init_ex(&_39$$32, phalcon_mvc_model_query_exceptions_relationshipnotfound_ce); - zephir_read_property_cached(&_40$$32, this_ptr, _zephir_prop_3, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_40$$32, this_ptr, _zephir_prop_3, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_39$$32, "__construct", &_24, 0, &modelName, &relationModel, &_40$$32); zephir_check_call_status(); zephir_throw_exception_debug(&_39$$32, "phalcon/Mvc/Model/Query.zep", 4228); @@ -8864,7 +8864,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) if (UNEXPECTED(zephir_fast_count_int(&relations) != 1)) { ZEPHIR_INIT_NVAR(&_41$$33); object_init_ex(&_41$$33, phalcon_mvc_model_query_exceptions_ambiguousjoinrelation_ce); - zephir_read_property_cached(&_42$$33, this_ptr, _zephir_prop_3, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_42$$33, this_ptr, _zephir_prop_3, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_41$$33, "__construct", &_27, 0, &modelName, &relationModel, &_42$$33); zephir_check_call_status(); zephir_throw_exception_debug(&_41$$33, "phalcon/Mvc/Model/Query.zep", 4235); @@ -8955,7 +8955,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) if (UNEXPECTED(zephir_array_isset_value(&sqlAliases, &alias))) { ZEPHIR_INIT_NVAR(&_51$$38); object_init_ex(&_51$$38, phalcon_mvc_model_query_exceptions_duplicatealias_ce); - zephir_read_property_cached(&_52$$38, this_ptr, _zephir_prop_3, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_52$$38, this_ptr, _zephir_prop_3, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_51$$38, "__construct", &_12, 0, &alias, &_52$$38); zephir_check_call_status(); zephir_throw_exception_debug(&_51$$38, "phalcon/Mvc/Model/Query.zep", 4167); @@ -9032,7 +9032,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) if (UNEXPECTED(Z_TYPE_P(&relations) != IS_ARRAY)) { ZEPHIR_INIT_NVAR(&_63$$48); object_init_ex(&_63$$48, phalcon_mvc_model_query_exceptions_relationshipnotfound_ce); - zephir_read_property_cached(&_64$$48, this_ptr, _zephir_prop_3, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_64$$48, this_ptr, _zephir_prop_3, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_63$$48, "__construct", &_24, 0, &modelName, &relationModel, &_64$$48); zephir_check_call_status(); zephir_throw_exception_debug(&_63$$48, "phalcon/Mvc/Model/Query.zep", 4228); @@ -9042,7 +9042,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) if (UNEXPECTED(zephir_fast_count_int(&relations) != 1)) { ZEPHIR_INIT_NVAR(&_65$$49); object_init_ex(&_65$$49, phalcon_mvc_model_query_exceptions_ambiguousjoinrelation_ce); - zephir_read_property_cached(&_66$$49, this_ptr, _zephir_prop_3, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_66$$49, this_ptr, _zephir_prop_3, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_65$$49, "__construct", &_27, 0, &modelName, &relationModel, &_66$$49); zephir_check_call_status(); zephir_throw_exception_debug(&_65$$49, "phalcon/Mvc/Model/Query.zep", 4235); @@ -9126,7 +9126,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) if (UNEXPECTED(Z_TYPE_P(&relations) != IS_ARRAY)) { ZEPHIR_INIT_NVAR(&_78$$53); object_init_ex(&_78$$53, phalcon_mvc_model_query_exceptions_relationshipnotfound_ce); - zephir_read_property_cached(&_79$$53, this_ptr, _zephir_prop_3, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_79$$53, this_ptr, _zephir_prop_3, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_78$$53, "__construct", &_24, 0, &modelName, &relationModel, &_79$$53); zephir_check_call_status(); zephir_throw_exception_debug(&_78$$53, "phalcon/Mvc/Model/Query.zep", 4228); @@ -9136,7 +9136,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) if (UNEXPECTED(zephir_fast_count_int(&relations) != 1)) { ZEPHIR_INIT_NVAR(&_80$$54); object_init_ex(&_80$$54, phalcon_mvc_model_query_exceptions_ambiguousjoinrelation_ce); - zephir_read_property_cached(&_81$$54, this_ptr, _zephir_prop_3, 1071, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_81$$54, this_ptr, _zephir_prop_3, 1072, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_80$$54, "__construct", &_27, 0, &modelName, &relationModel, &_81$$54); zephir_check_call_status(); zephir_throw_exception_debug(&_80$$54, "phalcon/Mvc/Model/Query.zep", 4235); @@ -9188,25 +9188,25 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) } ZEPHIR_INIT_NVAR(&selectedModel); if (!(merge)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1088, &models); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1087, &modelsInstances); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1089, &sqlAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1090, &sqlAliasesModels); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1091, &sqlModelsAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1092, &sqlAliasesModelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1089, &models); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1088, &modelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1090, &sqlAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1091, &sqlAliasesModels); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1092, &sqlModelsAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1093, &sqlAliasesModelsInstances); } else { ZEPHIR_OBS_NVAR(&tempModels); - zephir_read_property_cached(&tempModels, this_ptr, _zephir_prop_4, 1088, PH_NOISY_CC); + zephir_read_property_cached(&tempModels, this_ptr, _zephir_prop_4, 1089, PH_NOISY_CC); ZEPHIR_OBS_NVAR(&tempModelsInstances); - zephir_read_property_cached(&tempModelsInstances, this_ptr, _zephir_prop_5, 1087, PH_NOISY_CC); + zephir_read_property_cached(&tempModelsInstances, this_ptr, _zephir_prop_5, 1088, PH_NOISY_CC); ZEPHIR_OBS_NVAR(&tempSqlAliases); - zephir_read_property_cached(&tempSqlAliases, this_ptr, _zephir_prop_6, 1089, PH_NOISY_CC); + zephir_read_property_cached(&tempSqlAliases, this_ptr, _zephir_prop_6, 1090, PH_NOISY_CC); ZEPHIR_OBS_NVAR(&tempSqlAliasesModels); - zephir_read_property_cached(&tempSqlAliasesModels, this_ptr, _zephir_prop_7, 1090, PH_NOISY_CC); + zephir_read_property_cached(&tempSqlAliasesModels, this_ptr, _zephir_prop_7, 1091, PH_NOISY_CC); ZEPHIR_OBS_NVAR(&tempSqlModelsAliases); - zephir_read_property_cached(&tempSqlModelsAliases, this_ptr, _zephir_prop_8, 1091, PH_NOISY_CC); + zephir_read_property_cached(&tempSqlModelsAliases, this_ptr, _zephir_prop_8, 1092, PH_NOISY_CC); ZEPHIR_OBS_NVAR(&tempSqlAliasesModelsInstances); - zephir_read_property_cached(&tempSqlAliasesModelsInstances, this_ptr, _zephir_prop_9, 1092, PH_NOISY_CC); + zephir_read_property_cached(&tempSqlAliasesModelsInstances, this_ptr, _zephir_prop_9, 1093, PH_NOISY_CC); zephir_is_iterable(&models, 0, "phalcon/Mvc/Model/Query.zep", 4302); ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&models), _87$$56, _88$$56, _86$$56) { @@ -9536,7 +9536,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareSelect) } ZEPHIR_INIT_NVAR(&column); zephir_memory_observe(&_135); - zephir_read_property_cached(&_135, this_ptr, _zephir_prop_10, 1093, PH_NOISY_CC); + zephir_read_property_cached(&_135, this_ptr, _zephir_prop_10, 1094, PH_NOISY_CC); zephir_update_property_array(this_ptr, SL("sqlColumnAliases"), &_135, &sqlColumnAliases); ZEPHIR_INIT_VAR(&sqlSelect); zephir_create_array(&sqlSelect, 3, 0); @@ -9584,12 +9584,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, 1088, &tempModels); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1087, &tempModelsInstances); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1089, &tempSqlAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1090, &tempSqlAliasesModels); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1091, &tempSqlModelsAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1092, &tempSqlAliasesModelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1089, &tempModels); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1088, &tempModelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1090, &tempSqlAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1091, &tempSqlAliasesModels); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1092, &tempSqlModelsAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1093, &tempSqlAliasesModelsInstances); } RETURN_ON_FAILURE(zephir_property_decr(this_ptr, SL("nestingLevel"))); RETURN_CCTOR(&sqlSelect); @@ -9708,7 +9708,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, 1081, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1082, 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)))) { @@ -9763,7 +9763,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareUpdate) } else { ZEPHIR_CPY_WRT(&updateTables, &tables); } - 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, 1083, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&manager, &_0); if (Z_TYPE_P(&updateTables) == IS_STRING) { ZEPHIR_INIT_VAR(&_5); @@ -9885,12 +9885,12 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, prepareUpdate) } } ZEPHIR_INIT_NVAR(&table); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1088, &models); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1087, &modelsInstances); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1089, &sqlAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1090, &sqlAliasesModels); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1091, &sqlModelsAliases); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1092, &sqlAliasesModelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1089, &models); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1088, &modelsInstances); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1090, &sqlAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1091, &sqlAliasesModels); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1092, &sqlModelsAliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1093, &sqlAliasesModelsInstances); ZEPHIR_INIT_VAR(&sqlJoins); array_init(&sqlJoins); zephir_memory_observe(&joins); @@ -10077,7 +10077,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, 1082, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1083, 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 8a5d4bf5c9..87654530e6 100644 --- a/ext/phalcon/mvc/model/query/builder.zep.c +++ b/ext/phalcon/mvc/model/query/builder.zep.c @@ -307,11 +307,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, 1095, &conditions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1096, &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, 1095, &conditions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1096, &conditions); } } if (Z_TYPE_P(&conditions) == IS_ARRAY) { @@ -400,33 +400,33 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, __construct) ZEPHIR_INIT_NVAR(&singleConditionArray); ZEPHIR_INIT_VAR(&_9$$7); zephir_fast_join_str(&_9$$7, SL(" AND "), &mergedConditions); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1095, &_9$$7); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1096, &mergedParams); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1097, &mergedTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1096, &_9$$7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1097, &mergedParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1098, &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, 1096, &bind); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1097, &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, 1097, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1098, &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, 1098, &distinct); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1099, &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, 1099, &fromClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1100, &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, 1100, &columns); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1101, &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, 1101, &joinsClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1102, &joinsClause); } zephir_memory_observe(&groupClause); if (zephir_array_isset_string_fetch(&groupClause, params, SL("group"), 0)) { @@ -435,11 +435,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, 1102, &havingClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1103, &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, 1103, &orderClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1104, &orderClause); } zephir_memory_observe(&limitClause); if (zephir_array_isset_string_fetch(&limitClause, params, SL("limit"), 0)) { @@ -447,32 +447,32 @@ 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, 1104, &limit); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1105, &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, 1105, &offset); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 1106, &offset); } } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1104, &limitClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1105, &limitClause); } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1104, &limitClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1105, &limitClause); } } zephir_memory_observe(&offsetClause); if (zephir_array_isset_string_fetch(&offsetClause, params, SL("offset"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 1105, &offsetClause); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 1106, &offsetClause); } zephir_memory_observe(&forUpdate); if (zephir_array_isset_string_fetch(&forUpdate, params, SL("for_update"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 1106, &forUpdate); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 1107, &forUpdate); } zephir_memory_observe(&sharedLock); if (zephir_array_isset_string_fetch(&sharedLock, params, SL("shared_lock"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_12, 1107, &sharedLock); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_12, 1108, &sharedLock); } } else { _10$$38 = Z_TYPE_P(params) == IS_STRING; @@ -480,10 +480,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, __construct) _10$$38 = !ZEPHIR_IS_STRING_IDENTICAL(params, ""); } if (_10$$38) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1095, params); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1096, params); } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 1108, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 1109, container); ZEPHIR_MM_RESTORE(); } @@ -538,7 +538,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, 1099, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1100, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&models, &_0); if (Z_TYPE_P(&models) != IS_ARRAY) { if (Z_TYPE_P(&models) != IS_NULL) { @@ -561,7 +561,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, addFrom) } else { zephir_array_append(&models, &model_zv, PH_SEPARATE, "phalcon/Mvc/Model/Query/Builder.zep", 340); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1099, &models); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1100, &models); RETURN_THIS(); } @@ -624,7 +624,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, 1102, PH_NOISY_CC); + zephir_read_property_cached(¤tConditions, this_ptr, _zephir_prop_0, 1103, PH_NOISY_CC); if (zephir_is_true(¤tConditions)) { ZEPHIR_INIT_VAR(&_0$$3); ZEPHIR_CONCAT_SVSVS(&_0$$3, "(", ¤tConditions, ") AND (", &conditions, ")"); @@ -695,7 +695,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, 1095, PH_NOISY_CC); + zephir_read_property_cached(¤tConditions, this_ptr, _zephir_prop_0, 1096, PH_NOISY_CC); if (zephir_is_true(¤tConditions)) { ZEPHIR_INIT_VAR(&_0$$3); ZEPHIR_CONCAT_SVSVS(&_0$$3, "(", ¤tConditions, ") AND (", &conditions, ")"); @@ -901,7 +901,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, 1100, columns); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1101, columns); RETURN_THISW(); } @@ -928,7 +928,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, 1098, distinct); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1099, distinct); RETURN_THISW(); } @@ -957,9 +957,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, 1106, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1107, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1106, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1107, &__$false); } RETURN_THISW(); } @@ -1004,7 +1004,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, 1099, models); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1100, models); RETURN_THISW(); } @@ -1140,7 +1140,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, 1099, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1100, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&models, &_0); _1 = Z_TYPE_P(&models) == IS_ARRAY; if (_1) { @@ -1395,14 +1395,14 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) ZEPHIR_INIT_VAR(&offset); ZVAL_NULL(&offset); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1108, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1109, 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, 1108, &container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1109, &container); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1099, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1100, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&models, &_0); if (Z_TYPE_P(&models) == IS_ARRAY) { if (UNEXPECTED(ZEPHIR_IS_EMPTY(&models))) { @@ -1425,7 +1425,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) return; } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1095, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1096, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&conditions, &_0); if (zephir_is_numeric(&conditions)) { if (Z_TYPE_P(&models) == IS_ARRAY) { @@ -1507,7 +1507,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) return; } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1098, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1099, 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); @@ -1520,7 +1520,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, 1100, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1101, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&columns, &_0); if (Z_TYPE_P(&columns) != IS_NULL) { if (Z_TYPE_P(&columns) == IS_ARRAY) { @@ -1758,7 +1758,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) ZEPHIR_CONCAT_SV(&_52$$49, " FROM ", &_51$$49); zephir_concat_self(&phql, &_52$$49); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 1101, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_5, 1102, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&joins, &_0); if (Z_TYPE_P(&joins) == IS_ARRAY) { if (Z_TYPE_P(&joins) == IS_STRING) { @@ -1870,7 +1870,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) zephir_concat_self(&phql, &_72$$62); } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 1109, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_6, 1110, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&group, &_0); if (!(ZEPHIR_IS_EMPTY(&group))) { ZEPHIR_INIT_VAR(&groupItems); @@ -1922,7 +1922,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) ZEPHIR_CONCAT_SV(&_81$$63, " GROUP BY ", &_80$$63); zephir_concat_self(&phql, &_81$$63); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_7, 1102, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_7, 1103, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&having, &_0); if (Z_TYPE_P(&having) != IS_NULL) { if (!(ZEPHIR_IS_EMPTY(&having))) { @@ -1931,7 +1931,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) zephir_concat_self(&phql, &_82$$67); } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_8, 1103, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_8, 1104, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&order, &_0); if (Z_TYPE_P(&order) != IS_NULL) { if (Z_TYPE_P(&order) == IS_ARRAY) { @@ -2097,7 +2097,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) zephir_concat_self(&phql, &_118$$82); } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_9, 1104, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_9, 1105, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&limit, &_0); if (Z_TYPE_P(&limit) != IS_NULL) { ZEPHIR_INIT_VAR(&number); @@ -2115,7 +2115,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) } else { if (zephir_is_numeric(&limit)) { ZEPHIR_CPY_WRT(&number, &limit); - zephir_read_property_cached(&_119$$88, this_ptr, _zephir_prop_10, 1105, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_119$$88, this_ptr, _zephir_prop_10, 1106, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&offset, &_119$$88); if (Z_TYPE_P(&offset) != IS_NULL) { if (!(zephir_is_numeric(&offset))) { @@ -2158,7 +2158,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql) } } } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_11, 1106, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_11, 1107, 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)) { @@ -2218,7 +2218,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, 1108, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1109, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (UNEXPECTED(Z_TYPE_P(&container) != IS_OBJECT)) { ZEPHIR_INIT_VAR(&_1$$3); @@ -2238,32 +2238,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, 1096, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1097, 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, 1097, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1098, 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, 1107, PH_NOISY_CC); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_3, 1108, 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, 1107, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_3, 1108, 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, 1110, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1111, 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, 1110, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$7, this_ptr, _zephir_prop_4, 1111, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &query, "setResultsetRowClass", NULL, 0, &_8$$7); zephir_check_call_status(); } @@ -2349,7 +2349,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, groupBy) zephir_fast_explode_str(&_3$$3, SL(","), group, ZEND_LONG_MAX); ZEPHIR_CPY_WRT(group, &_3$$3); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1109, group); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1110, group); RETURN_THIS(); } @@ -2426,24 +2426,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, 1102, &conditions_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1103, &conditions_zv); zephir_memory_observe(¤tBindParams); - zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_1, 1096, PH_NOISY_CC); + zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_1, 1097, 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, 1096, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1097, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1096, &bindParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1097, &bindParams); } zephir_memory_observe(¤tBindTypes); - zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_2, 1097, PH_NOISY_CC); + zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_2, 1098, 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, 1097, &_1$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1098, &_1$$5); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1097, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1098, &bindTypes); } RETURN_THIS(); } @@ -2820,12 +2820,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, 1104, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1105, &_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, 1105, &_3$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1106, &_3$$4); } RETURN_THIS(); } @@ -3057,7 +3057,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, 1105, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1106, &_0); RETURN_THISW(); } @@ -3085,7 +3085,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, 1103, orderBy); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1104, orderBy); RETURN_THISW(); } @@ -3148,7 +3148,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, 1102, PH_NOISY_CC); + zephir_read_property_cached(¤tConditions, this_ptr, _zephir_prop_0, 1103, PH_NOISY_CC); if (zephir_is_true(¤tConditions)) { ZEPHIR_INIT_VAR(&_0$$3); ZEPHIR_CONCAT_SVSVS(&_0$$3, "(", ¤tConditions, ") OR (", &conditions, ")"); @@ -3216,7 +3216,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, 1095, PH_NOISY_CC); + zephir_read_property_cached(¤tConditions, this_ptr, _zephir_prop_0, 1096, PH_NOISY_CC); if (zephir_is_true(¤tConditions)) { ZEPHIR_INIT_VAR(&_0$$3); ZEPHIR_CONCAT_SVSVS(&_0$$3, "(", ¤tConditions, ") OR (", &conditions, ")"); @@ -3322,16 +3322,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, 1096, PH_NOISY_CC); + zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_0, 1097, 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, 1096, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1097, &_0$$4); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1096, &bindParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1097, &bindParams); } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1096, &bindParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1097, &bindParams); } RETURN_THIS(); } @@ -3372,16 +3372,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, 1097, PH_NOISY_CC); + zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_0, 1098, 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, 1097, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1098, &_0$$4); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1097, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1098, &bindTypes); } } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1097, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1098, &bindTypes); } RETURN_THIS(); } @@ -3404,7 +3404,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, 1108, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1109, container); } /** @@ -3429,7 +3429,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, 1110, &resultsetRowClass_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1111, &resultsetRowClass_zv); RETURN_THISW(); } @@ -3506,27 +3506,27 @@ 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, 1095, &conditions_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1096, &conditions_zv); if (!(ZEPHIR_IS_EMPTY(&bindParams))) { zephir_memory_observe(¤tBindParams); - zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_1, 1096, PH_NOISY_CC); + zephir_read_property_cached(¤tBindParams, this_ptr, _zephir_prop_1, 1097, 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, 1096, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1097, &_0$$4); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1096, &bindParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1097, &bindParams); } } if (!(ZEPHIR_IS_EMPTY(&bindTypes))) { zephir_memory_observe(¤tBindTypes); - zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_2, 1097, PH_NOISY_CC); + zephir_read_property_cached(¤tBindTypes, this_ptr, _zephir_prop_2, 1098, PH_NOISY_CC); 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, 1097, &_1$$7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1098, &_1$$7); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1097, &bindTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1098, &bindTypes); } } RETURN_THIS(); @@ -3600,7 +3600,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, 1111, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 1112, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_3); ZVAL_LONG(&_3, 1); ZEPHIR_INIT_VAR(&nextHiddenParam); @@ -3619,7 +3619,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, 1111, &nextHiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1112, &nextHiddenParam); RETURN_THIS(); } @@ -3706,7 +3706,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, 1111, PH_NOISY_CC); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 1112, PH_NOISY_CC); hiddenParam = zephir_get_intval(&_4); ZEPHIR_INIT_VAR(&bindParams); array_init(&bindParams); @@ -3768,7 +3768,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, 1111, &_14); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1112, &_14); RETURN_THIS(); } @@ -3840,7 +3840,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, 1111, PH_NOISY_CC); + zephir_read_property_cached(&hiddenParam, this_ptr, _zephir_prop_0, 1112, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_3); ZVAL_LONG(&_3, 1); ZEPHIR_INIT_VAR(&nextHiddenParam); @@ -3859,7 +3859,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, 1111, &nextHiddenParam); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1112, &nextHiddenParam); RETURN_THIS(); } @@ -3946,7 +3946,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, 1111, PH_NOISY_CC); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 1112, PH_NOISY_CC); hiddenParam = zephir_get_intval(&_4); ZEPHIR_INIT_VAR(&bindParams); array_init(&bindParams); @@ -4008,7 +4008,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, 1111, &_14); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1112, &_14); RETURN_THIS(); } diff --git a/ext/phalcon/mvc/model/query/status.zep.c b/ext/phalcon/mvc/model/query/status.zep.c index 3ff7b285dd..4e1ade09fa 100644 --- a/ext/phalcon/mvc/model/query/status.zep.c +++ b/ext/phalcon/mvc/model/query/status.zep.c @@ -109,11 +109,11 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Status, __construct) model = &__$null; } if (success) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1112, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1113, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1112, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1113, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1113, model); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1114, model); } /** @@ -135,7 +135,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, 1113, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1114, 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 9dc4746018..f38909a5ec 100644 --- a/ext/phalcon/mvc/model/relation.zep.c +++ b/ext/phalcon/mvc/model/relation.zep.c @@ -195,11 +195,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, 1114, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1115, &referencedModel_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1116, fields); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1117, referencedFields); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1118, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1115, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1116, &referencedModel_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1117, fields); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1118, referencedFields); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1119, &options); ZEPHIR_MM_RESTORE(); } @@ -239,7 +239,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, 1118, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1119, 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)) { @@ -312,7 +312,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, 1118, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1119, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&option, &_0, &name_zv, 0))) { RETURN_MM_NULL(); } @@ -354,7 +354,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, 1118, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1119, 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)) { @@ -420,7 +420,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, 1118, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1119, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_string_fetch(&foreignKey, &_0, SL("foreignKey"), 0))) { RETURN_MM_BOOL(0); } @@ -446,7 +446,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, 1118, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1119, 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))) { @@ -474,7 +474,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, 1114, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1115, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&type, &_0); _1 = ZEPHIR_IS_LONG(&type, 3); if (!(_1)) { @@ -520,8 +520,8 @@ 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, 1119, intermediateFields); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1120, &intermediateModel_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1121, intermediateReferencedFields); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1120, intermediateFields); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1121, &intermediateModel_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1122, intermediateReferencedFields); } diff --git a/ext/phalcon/mvc/model/resultset/complex.zep.c b/ext/phalcon/mvc/model/resultset/complex.zep.c index b48418ae98..87953b0445 100644 --- a/ext/phalcon/mvc/model/resultset/complex.zep.c +++ b/ext/phalcon/mvc/model/resultset/complex.zep.c @@ -131,8 +131,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, 1122, columnTypes); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1123, &resultsetRowClass_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1123, columnTypes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1124, &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(); @@ -167,11 +167,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, 1124, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1125, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&cache, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1122, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1123, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&columnTypes, &_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, 1126, 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); @@ -233,22 +233,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, 1126, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1127, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1126, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1127, &__$false); } zephir_array_fetch_string(&_0, &data, SL("rows"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Complex.zep", 112); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1127, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1128, &_0); zephir_array_fetch_string(&_1, &data, SL("rows"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Complex.zep", 113); ZVAL_UNDEF(&_2); ZVAL_LONG(&_2, zephir_fast_count_int(&_1)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1128, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1129, &_2); zephir_array_fetch_string(&_3, &data, SL("cache"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Complex.zep", 114); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1124, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1125, &_3); zephir_array_fetch_string(&_4, &data, SL("columnTypes"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Complex.zep", 115); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1122, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1123, &_4); zephir_array_fetch_string(&_5, &data, SL("hydrateMode"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Complex.zep", 116); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1125, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1126, &_5); ZEPHIR_MM_RESTORE(); } @@ -356,36 +356,36 @@ 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, 1129, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1130, 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, 1130, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1131, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&row, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1126, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1127, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1129, &row); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1130, &row); RETURN_CCTOR(&row); } if (Z_TYPE_P(&row) != IS_ARRAY) { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1129, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1130, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1129, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1130, &__$false); } RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1125, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1126, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&hydrateMode, &_1); if (ZEPHIR_IS_LONG(&hydrateMode, 0)) { goto zephir_switch_0_clause_0; } if (ZEPHIR_IS_LONG(&hydrateMode, 1)) { goto zephir_switch_0_clause_1; } if (ZEPHIR_IS_LONG(&hydrateMode, 2)) { goto zephir_switch_0_clause_2; } goto zephir_switch_0_clause_3; zephir_switch_0_clause_0: ; - zephir_read_property_cached(&_2$$6, this_ptr, _zephir_prop_4, 1123, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$6, this_ptr, _zephir_prop_4, 1124, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_STRING_IDENTICAL(&_2$$6, "")) { - zephir_read_property_cached(&_3$$7, this_ptr, _zephir_prop_4, 1123, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$7, this_ptr, _zephir_prop_4, 1124, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&activeRow); ZEPHIR_LAST_CALL_STATUS = zephir_create_instance(&activeRow, &_3$$7); zephir_check_call_status(); @@ -413,7 +413,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, current) dirtyState = 0; ZEPHIR_INIT_VAR(&lateStateBinding); ZVAL_NULL(&lateStateBinding); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_5, 1122, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_5, 1123, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_1) == IS_STRING) { ZEPHIR_INIT_VAR(&_5); zephir_string_to_char_array(&_5, &_1); @@ -814,7 +814,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, 1129, &activeRow); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1130, &activeRow); RETURN_CCTOR(&activeRow); } @@ -868,16 +868,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, 1124, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1125, 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, 1122, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1123, 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, 1125, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1126, PH_NOISY_CC); zephir_array_update_string(&data, SL("hydrateMode"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_VAR(&_3); ZVAL_STRING(&_3, "serializer"); @@ -1003,9 +1003,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, 1126, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1127, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1126, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1127, &__$false); } ZEPHIR_CALL_CE_STATIC(&container, phalcon_di_di_ce, "getDefault", NULL, 0); zephir_check_call_status(); @@ -1047,21 +1047,21 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, unserialize) } zephir_memory_observe(&_6); zephir_array_fetch_string(&_6, &resultset, SL("rows"), PH_NOISY, "phalcon/Mvc/Model/Resultset/Complex.zep", 445); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1127, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1128, &_6); zephir_memory_observe(&_7); zephir_array_fetch_string(&_7, &resultset, SL("rows"), PH_NOISY, "phalcon/Mvc/Model/Resultset/Complex.zep", 446); ZVAL_UNDEF(&_8); ZVAL_LONG(&_8, zephir_fast_count_int(&_7)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1128, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1129, &_8); zephir_memory_observe(&_9); zephir_array_fetch_string(&_9, &resultset, SL("cache"), PH_NOISY, "phalcon/Mvc/Model/Resultset/Complex.zep", 447); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1124, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1125, &_9); zephir_memory_observe(&_10); zephir_array_fetch_string(&_10, &resultset, SL("columnTypes"), PH_NOISY, "phalcon/Mvc/Model/Resultset/Complex.zep", 448); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1122, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1123, &_10); zephir_memory_observe(&_11); zephir_array_fetch_string(&_11, &resultset, SL("hydrateMode"), PH_NOISY, "phalcon/Mvc/Model/Resultset/Complex.zep", 449); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1125, &_11); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1126, &_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 be0ff2a8de..26e033d498 100644 --- a/ext/phalcon/mvc/model/resultset/simple.zep.c +++ b/ext/phalcon/mvc/model/resultset/simple.zep.c @@ -127,12 +127,12 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, __construct) keepSnapshots = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1131, model); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1132, columnMap); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1132, model); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1133, columnMap); if (keepSnapshots) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1133, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1134, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1133, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1134, &__$false); } ZEPHIR_CALL_PARENT(NULL, phalcon_mvc_model_resultset_simple_ce, getThis(), "__construct", NULL, 0, result, cache); zephir_check_call_status(); @@ -174,23 +174,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, 1131, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1132, 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, 1134, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1135, 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, 1132, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1133, 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, 1135, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1136, 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, 1133, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 1134, PH_NOISY_CC); zephir_array_update_string(return_value, SL("keepSnapshots"), &_0, PH_COPY | PH_SEPARATE); RETURN_MM(); } @@ -251,22 +251,22 @@ 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", 109); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1131, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1132, &_0); zephir_array_fetch_string(&_1, &data, SL("rows"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Simple.zep", 110); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1136, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1137, &_1); zephir_array_fetch_string(&_2, &data, SL("rows"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Simple.zep", 111); ZVAL_UNDEF(&_3); ZVAL_LONG(&_3, zephir_fast_count_int(&_2)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1137, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1138, &_3); zephir_array_fetch_string(&_4, &data, SL("cache"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Simple.zep", 112); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1134, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1135, &_4); zephir_array_fetch_string(&_5, &data, SL("columnMap"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Simple.zep", 113); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1132, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1133, &_5); zephir_array_fetch_string(&_6, &data, SL("hydrateMode"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Resultset/Simple.zep", 114); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1135, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1136, &_6); zephir_memory_observe(&keepSnapshots); if (zephir_array_isset_string_fetch(&keepSnapshots, &data, SL("keepSnapshots"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1133, &keepSnapshots); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1134, &keepSnapshots); } ZEPHIR_MM_RESTORE(); } @@ -337,7 +337,7 @@ 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, 1138, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1139, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&activeRow, &_0); if (Z_TYPE_P(&activeRow) != IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); @@ -349,19 +349,19 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, current) } RETURN_CCTOR(&_1$$3); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1139, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1140, 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, 1138, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1139, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1138, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1139, &__$false); } RETURN_MM_NULL(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1135, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1136, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&hydrateMode, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1132, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 1133, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&columnMap, &_0); if (ZEPHIR_IS_LONG(&hydrateMode, 0)) { goto zephir_switch_0_clause_0; } goto zephir_switch_0_clause_1; @@ -372,31 +372,31 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, current) zephir_check_call_status(); if (zephir_is_true(&_2$$5)) { zephir_memory_observe(&_4$$6); - zephir_read_property_cached(&_4$$6, this_ptr, _zephir_prop_4, 1131, PH_NOISY_CC); + zephir_read_property_cached(&_4$$6, this_ptr, _zephir_prop_4, 1132, PH_NOISY_CC); if (zephir_instance_of_ev(&_4$$6, phalcon_mvc_model_ce)) { - zephir_read_property_cached(&_5$$7, this_ptr, _zephir_prop_4, 1131, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$7, this_ptr, _zephir_prop_4, 1132, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&modelName); zephir_get_class(&modelName, &_5$$7, 0); } else { ZEPHIR_INIT_NVAR(&modelName); ZVAL_STRING(&modelName, "Phalcon\\Mvc\\Model"); } - zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_4, 1131, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_5, 1133, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$6, this_ptr, _zephir_prop_4, 1132, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$6, this_ptr, _zephir_prop_5, 1134, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_8$$6, 0); _9$$6 = zephir_fetch_class(&modelName); ZEPHIR_CALL_CE_STATIC(&activeRow, _9$$6, "cloneResultMap", NULL, 0, &_6$$6, &row, &columnMap, &_8$$6, &_7$$6); zephir_check_call_status(); } else { - zephir_read_property_cached(&_10$$9, this_ptr, _zephir_prop_4, 1131, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_11$$9, this_ptr, _zephir_prop_5, 1133, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$9, this_ptr, _zephir_prop_4, 1132, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$9, this_ptr, _zephir_prop_5, 1134, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_12$$9, 0); ZEPHIR_CALL_CE_STATIC(&activeRow, phalcon_mvc_model_ce, "cloneResultMap", NULL, 0, &_10$$9, &row, &columnMap, &_12$$9, &_11$$9); zephir_check_call_status(); } - zephir_read_property_cached(&_13$$5, this_ptr, _zephir_prop_6, 1140, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$5, this_ptr, _zephir_prop_6, 1141, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_13$$5) != IS_NULL) { - zephir_read_property_cached(&_14$$10, this_ptr, _zephir_prop_6, 1140, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$10, this_ptr, _zephir_prop_6, 1141, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_CE_STATIC(NULL, phalcon_mvc_model_eager_loader_ce, "apply", NULL, 0, &activeRow, &_14$$10); zephir_check_call_status(); } @@ -407,7 +407,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, current) goto zephir_switch_0_end; zephir_switch_0_end: ; - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1138, &activeRow); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1139, &activeRow); RETURN_CCTOR(&activeRow); } @@ -469,23 +469,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, 1131, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1132, 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, 1134, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1135, 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, 1132, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1133, 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, 1135, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1136, 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, 1133, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_4, 1134, PH_NOISY_CC); zephir_array_update_string(&data, SL("keepSnapshots"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_VAR(&_4); ZVAL_STRING(&_4, "serializer"); @@ -538,7 +538,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, setEagerMap) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &eagerMap_param); zephir_get_arrval(&eagerMap, eagerMap_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1140, &eagerMap); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1141, &eagerMap); ZEPHIR_MM_RESTORE(); } @@ -614,7 +614,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, sliceRows) ZEPHIR_INIT_NVAR(&index); ZVAL_COPY(&index, _0); ZEPHIR_OBS_NVAR(&row); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1136, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1137, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&row, &_1$$3, &index, 0)) { zephir_array_append(&sliced, &row, PH_SEPARATE, "phalcon/Mvc/Model/Resultset/Simple.zep", 295); } @@ -638,7 +638,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, sliceRows) ZEPHIR_CALL_METHOD(&index, &indexes, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&row); - zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_0, 1136, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$5, this_ptr, _zephir_prop_0, 1137, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&row, &_4$$5, &index, 0)) { zephir_array_append(&sliced, &row, PH_SEPARATE, "phalcon/Mvc/Model/Resultset/Simple.zep", 295); } @@ -651,15 +651,15 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, sliceRows) ZEPHIR_INIT_VAR(&_7); zephir_create_array(&_7, 5, 0); zephir_memory_observe(&_8); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1132, PH_NOISY_CC); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_1, 1133, PH_NOISY_CC); zephir_array_fast_append(&_7, &_8); ZEPHIR_OBS_NVAR(&_8); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 1131, PH_NOISY_CC); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_2, 1132, PH_NOISY_CC); zephir_array_fast_append(&_7, &_8); zephir_array_fast_append(&_7, &__$false); zephir_array_fast_append(&_7, &__$null); ZEPHIR_OBS_NVAR(&_8); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_3, 1133, PH_NOISY_CC); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_3, 1134, PH_NOISY_CC); zephir_array_fast_append(&_7, &_8); ZEPHIR_LAST_CALL_STATUS = zephir_create_instance_params(&_5, &_6, &_7); zephir_check_call_status(); @@ -742,15 +742,15 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, toArray) ZEPHIR_CALL_METHOD(NULL, this_ptr, "materialize", NULL, 0); zephir_check_call_status(); zephir_memory_observe(&records); - zephir_read_property_cached(&records, this_ptr, _zephir_prop_0, 1136, PH_NOISY_CC); + zephir_read_property_cached(&records, this_ptr, _zephir_prop_0, 1137, PH_NOISY_CC); _0 = renameColumns; if (_0) { zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1131, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1132, PH_NOISY_CC); _0 = !(zephir_instance_of_ev(&_1, phalcon_mvc_model_row_ce)); } if (_0) { - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 1132, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 1133, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&columnMap, &_2$$3); if (Z_TYPE_P(&columnMap) != IS_ARRAY) { RETURN_CCTOR(&records); @@ -1099,27 +1099,27 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, unserialize) } zephir_memory_observe(&_6); zephir_array_fetch_string(&_6, &resultset, SL("model"), PH_NOISY, "phalcon/Mvc/Model/Resultset/Simple.zep", 418); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1131, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1132, &_6); zephir_memory_observe(&_7); zephir_array_fetch_string(&_7, &resultset, SL("rows"), PH_NOISY, "phalcon/Mvc/Model/Resultset/Simple.zep", 419); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1136, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1137, &_7); zephir_memory_observe(&_8); zephir_array_fetch_string(&_8, &resultset, SL("rows"), PH_NOISY, "phalcon/Mvc/Model/Resultset/Simple.zep", 420); ZVAL_UNDEF(&_9); ZVAL_LONG(&_9, zephir_fast_count_int(&_8)); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1137, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1138, &_9); zephir_memory_observe(&_10); zephir_array_fetch_string(&_10, &resultset, SL("cache"), PH_NOISY, "phalcon/Mvc/Model/Resultset/Simple.zep", 421); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1134, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1135, &_10); zephir_memory_observe(&_11); zephir_array_fetch_string(&_11, &resultset, SL("columnMap"), PH_NOISY, "phalcon/Mvc/Model/Resultset/Simple.zep", 422); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1132, &_11); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1133, &_11); zephir_memory_observe(&_12); zephir_array_fetch_string(&_12, &resultset, SL("hydrateMode"), PH_NOISY, "phalcon/Mvc/Model/Resultset/Simple.zep", 423); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1135, &_12); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1136, &_12); zephir_memory_observe(&keepSnapshots); if (zephir_array_isset_string_fetch(&keepSnapshots, &resultset, SL("keepSnapshots"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1133, &keepSnapshots); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1134, &keepSnapshots); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/mvc/model/transaction.zep.c b/ext/phalcon/mvc/model/transaction.zep.c index b55146ff42..47edf89a89 100644 --- a/ext/phalcon/mvc/model/transaction.zep.c +++ b/ext/phalcon/mvc/model/transaction.zep.c @@ -172,7 +172,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, 1141, &connection); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1142, &connection); if (autoBegin) { ZEPHIR_CALL_METHOD(NULL, &connection, "begin", NULL, 0); zephir_check_call_status(); @@ -198,7 +198,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, 1141, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1142, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "begin", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -227,13 +227,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, 1142, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1143, 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, 1141, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1142, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "commit", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -259,7 +259,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, 1143, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1144, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_FUNCTION(&_1$$3, "connection_aborted", NULL, 0); zephir_check_call_status(); @@ -302,7 +302,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, 1142, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1143, PH_NOISY_CC); RETURN_MM_BOOL(Z_TYPE_P(&_0) == IS_OBJECT); } @@ -324,7 +324,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, 1141, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1142, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "isUnderTransaction", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -386,13 +386,13 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction, rollback) rollbackRecord = &rollbackRecord_sub; rollbackRecord = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1142, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1143, 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, 1141, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1142, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&connection, &_0); ZEPHIR_CALL_METHOD(&_1, &connection, "rollback", NULL, 0); zephir_check_call_status(); @@ -402,13 +402,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, 1144, rollbackRecord); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1145, rollbackRecord); } - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 1145, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 1146, 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, 1144, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$7, this_ptr, _zephir_prop_2, 1145, 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", 192); @@ -440,9 +440,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, 1146, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1147, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1146, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1147, &__$false); } } @@ -464,7 +464,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, 1144, record); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1145, record); } /** @@ -488,9 +488,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, 1143, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1144, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1143, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1144, &__$false); } } @@ -512,7 +512,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, 1142, manager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1143, manager); } /** @@ -536,9 +536,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, 1145, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1146, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1145, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1146, &__$false); } RETURN_THISW(); } diff --git a/ext/phalcon/mvc/model/transaction/failed.zep.c b/ext/phalcon/mvc/model/transaction/failed.zep.c index 4ba806b587..0137238c5b 100644 --- a/ext/phalcon/mvc/model/transaction/failed.zep.c +++ b/ext/phalcon/mvc/model/transaction/failed.zep.c @@ -80,7 +80,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Failed, __construct) record = &record_sub; record = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1147, record); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1148, record); ZEPHIR_CALL_PARENT(NULL, phalcon_mvc_model_transaction_failed_ce, getThis(), "__construct", NULL, 0, &message_zv); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -116,7 +116,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, 1147, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1148, 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 af1d9ba906..7d5a9106ce 100644 --- a/ext/phalcon/mvc/model/transaction/manager.zep.c +++ b/ext/phalcon/mvc/model/transaction/manager.zep.c @@ -160,7 +160,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, 1148, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1149, 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); @@ -197,7 +197,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, 1149, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1150, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&transactions, &_0); if (Z_TYPE_P(&transactions) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); @@ -239,7 +239,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, collectTransactions) ZEPHIR_INIT_NVAR(&_3); ZEPHIR_INIT_VAR(&_7); array_init(&_7); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1149, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1150, &_7); ZEPHIR_MM_RESTORE(); } @@ -270,7 +270,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, 1149, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1150, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&transactions, &_0); if (Z_TYPE_P(&transactions) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); @@ -370,9 +370,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, get) autoBegin = 1; } 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, 1151, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1151, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1152, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_1$$3)) { ZEPHIR_INIT_VAR(&_2$$4); zephir_create_array(&_2$$4, 2, 0); @@ -384,9 +384,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, 1150, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1151, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1150, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1151, &__$false); } } if (autoBegin) { @@ -470,7 +470,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, getOrCreateTransaction) autoBegin = 1; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1148, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1149, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (UNEXPECTED(Z_TYPE_P(&container) != IS_OBJECT)) { ZEPHIR_INIT_VAR(&_1$$3); @@ -481,9 +481,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, getOrCreateTransaction) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1152, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1153, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 1149, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_2, 1150, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&transactions, &_2$$4); if (Z_TYPE_P(&transactions) == IS_STRING) { ZEPHIR_INIT_VAR(&_4$$4); @@ -535,7 +535,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(&_10, this_ptr, _zephir_prop_3, 1153, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_3, 1154, PH_NOISY_CC | PH_READONLY); if (autoBegin) { ZVAL_BOOL(&_11, 1); } else { @@ -573,7 +573,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, 1152, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1153, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(ZEPHIR_GT_LONG(&_0, 0)); } @@ -658,7 +658,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, rollback) collect = 1; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1149, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1150, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&transactions, &_0); if (Z_TYPE_P(&transactions) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); @@ -761,7 +761,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, 1153, &service_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1154, &service_zv); RETURN_THISW(); } @@ -783,7 +783,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, 1148, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1149, container); } /** @@ -808,9 +808,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, 1151, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1152, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1151, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1152, &__$false); } RETURN_THISW(); } @@ -846,7 +846,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, 1149, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1150, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); @@ -892,7 +892,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, collectTransaction) } } ZEPHIR_INIT_NVAR(&managedTransaction); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1149, &newTransactions); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1150, &newTransactions); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/mvc/model/validationfailed.zep.c b/ext/phalcon/mvc/model/validationfailed.zep.c index 7ab11ef190..da1355b2f4 100644 --- a/ext/phalcon/mvc/model/validationfailed.zep.c +++ b/ext/phalcon/mvc/model/validationfailed.zep.c @@ -98,8 +98,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, 1154, model); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1155, &validationMessages); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1155, model); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1156, &validationMessages); ZEPHIR_CALL_PARENT(NULL, phalcon_mvc_model_validationfailed_ce, getThis(), "__construct", NULL, 0, &messageStr); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/mvc/router.zep.c b/ext/phalcon/mvc/router.zep.c index 5ed0b23738..8d0850b548 100644 --- a/ext/phalcon/mvc/router.zep.c +++ b/ext/phalcon/mvc/router.zep.c @@ -1251,9 +1251,9 @@ PHP_METHOD(Phalcon_Mvc_Router, attach) ZEPHIR_INIT_VAR(&_1$$4); zephir_create_array(&_1$$4, 1, 0); zephir_array_fast_append(&_1$$4, route); - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); zephir_fast_array_merge(&_0$$4, &_1$$4, &_2$$4); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 288, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 289, &_0$$4); goto zephir_switch_0_end; zephir_switch_0_clause_2: ; ZEPHIR_INIT_VAR(&_3$$5); @@ -1266,9 +1266,9 @@ PHP_METHOD(Phalcon_Mvc_Router, attach) zephir_switch_0_end: ; if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 289, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 290, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 289, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 290, &__$false); } RETURN_THIS(); } @@ -1464,7 +1464,7 @@ PHP_METHOD(Phalcon_Mvc_Router, buildDispatcherDump) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 290, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "rebuildMethodIndex", NULL, 0); zephir_check_call_status(); @@ -1473,7 +1473,7 @@ PHP_METHOD(Phalcon_Mvc_Router, buildDispatcherDump) array_init(&dumpedRoutes); ZEPHIR_INIT_VAR(&routeToIdx); array_init(&routeToIdx); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 289, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_1) == IS_STRING) { ZEPHIR_INIT_VAR(&_3); zephir_string_to_char_array(&_3, &_1); @@ -1764,7 +1764,7 @@ PHP_METHOD(Phalcon_Mvc_Router, buildDispatcherDump) ZEPHIR_INIT_NVAR(&scalarIdx); ZEPHIR_INIT_VAR(&methodRoutesScalar); array_init(&methodRoutesScalar); - zephir_read_property_cached(&_57, this_ptr, _zephir_prop_2, 290, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_57, this_ptr, _zephir_prop_2, 291, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_57) == IS_STRING) { ZEPHIR_INIT_VAR(&_59); zephir_string_to_char_array(&_59, &_57); @@ -1903,7 +1903,7 @@ PHP_METHOD(Phalcon_Mvc_Router, buildDispatcherDump) ZEPHIR_INIT_NVAR(&innerKey); ZEPHIR_INIT_VAR(&candidatesScalar); array_init(&candidatesScalar); - zephir_read_property_cached(&_83, this_ptr, _zephir_prop_3, 291, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_83, this_ptr, _zephir_prop_3, 292, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_83) == IS_STRING) { ZEPHIR_INIT_VAR(&_85); zephir_string_to_char_array(&_85, &_83); @@ -2042,7 +2042,7 @@ PHP_METHOD(Phalcon_Mvc_Router, buildDispatcherDump) ZEPHIR_INIT_NVAR(&innerKey); ZEPHIR_INIT_VAR(&staticScalar); array_init(&staticScalar); - zephir_read_property_cached(&_109, this_ptr, _zephir_prop_4, 292, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_109, this_ptr, _zephir_prop_4, 293, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_109) == IS_STRING) { ZEPHIR_INIT_VAR(&_111); zephir_string_to_char_array(&_111, &_109); @@ -2372,25 +2372,25 @@ PHP_METHOD(Phalcon_Mvc_Router, buildDispatcherDump) zephir_array_update_string(return_value, SL("candidatesByMethod"), &candidatesScalar, PH_COPY | PH_SEPARATE); zephir_array_update_string(return_value, SL("staticByMethod"), &staticScalar, PH_COPY | PH_SEPARATE); zephir_memory_observe(&_169); - zephir_read_property_cached(&_169, this_ptr, _zephir_prop_5, 293, PH_NOISY_CC); + zephir_read_property_cached(&_169, this_ptr, _zephir_prop_5, 294, PH_NOISY_CC); zephir_array_update_string(return_value, SL("staticShadowedByMethod"), &_169, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_169); - zephir_read_property_cached(&_169, this_ptr, _zephir_prop_6, 294, PH_NOISY_CC); + zephir_read_property_cached(&_169, this_ptr, _zephir_prop_6, 295, PH_NOISY_CC); zephir_array_update_string(return_value, SL("hostnameByMethod"), &_169, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_169); - zephir_read_property_cached(&_169, this_ptr, _zephir_prop_7, 295, PH_NOISY_CC); + zephir_read_property_cached(&_169, this_ptr, _zephir_prop_7, 296, PH_NOISY_CC); zephir_array_update_string(return_value, SL("hostnameLessByMethod"), &_169, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_169); - zephir_read_property_cached(&_169, this_ptr, _zephir_prop_8, 296, PH_NOISY_CC); + zephir_read_property_cached(&_169, this_ptr, _zephir_prop_8, 297, PH_NOISY_CC); zephir_array_update_string(return_value, SL("combinedRegexByMethod"), &_169, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_169); - zephir_read_property_cached(&_169, this_ptr, _zephir_prop_9, 297, PH_NOISY_CC); + zephir_read_property_cached(&_169, this_ptr, _zephir_prop_9, 298, PH_NOISY_CC); zephir_array_update_string(return_value, SL("combinedRegexDisabled"), &_169, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_169); - zephir_read_property_cached(&_169, this_ptr, _zephir_prop_10, 298, PH_NOISY_CC); + zephir_read_property_cached(&_169, this_ptr, _zephir_prop_10, 299, PH_NOISY_CC); zephir_array_update_string(return_value, SL("combinedRegexMarkMap"), &_169, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_169); - zephir_read_property_cached(&_169, this_ptr, _zephir_prop_11, 299, PH_NOISY_CC); + zephir_read_property_cached(&_169, this_ptr, _zephir_prop_11, 300, PH_NOISY_CC); zephir_array_update_string(return_value, SL("routeMeta"), &_169, PH_COPY | PH_SEPARATE); RETURN_MM(); } @@ -2470,41 +2470,41 @@ PHP_METHOD(Phalcon_Mvc_Router, clear) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 288, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 289, &_0); ZEPHIR_INIT_VAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 290, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 291, &_1); ZEPHIR_INIT_VAR(&_2); array_init(&_2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 291, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 292, &_2); ZEPHIR_INIT_VAR(&_3); array_init(&_3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 299, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 300, &_3); ZEPHIR_INIT_VAR(&_4); array_init(&_4); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 292, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 293, &_4); ZEPHIR_INIT_VAR(&_5); array_init(&_5); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 293, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 294, &_5); ZEPHIR_INIT_VAR(&_6); array_init(&_6); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 294, &_6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 295, &_6); ZEPHIR_INIT_VAR(&_7); array_init(&_7); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 295, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 296, &_7); ZEPHIR_INIT_VAR(&_8); array_init(&_8); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 296, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 297, &_8); ZEPHIR_INIT_VAR(&_9); array_init(&_9); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 297, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 298, &_9); ZEPHIR_INIT_VAR(&_10); array_init(&_10); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 298, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 299, &_10); if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 289, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 290, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 289, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 290, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -2645,19 +2645,19 @@ PHP_METHOD(Phalcon_Mvc_Router, getDefaults) zephir_create_array(return_value, 5, 0); zephir_memory_observe(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 300, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 301, PH_NOISY_CC); zephir_array_update_string(return_value, SL("namespace"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 301, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 302, PH_NOISY_CC); zephir_array_update_string(return_value, SL("module"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 302, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 303, PH_NOISY_CC); zephir_array_update_string(return_value, SL("controller"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 303, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_3, 304, PH_NOISY_CC); zephir_array_update_string(return_value, SL("action"), &_0, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 304, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_4, 305, PH_NOISY_CC); zephir_array_update_string(return_value, SL("params"), &_0, PH_COPY | PH_SEPARATE); RETURN_MM(); } @@ -2730,7 +2730,7 @@ PHP_METHOD(Phalcon_Mvc_Router, getMethodRoutes) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 290, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "rebuildMethodIndex", NULL, 0); zephir_check_call_status(); @@ -2791,7 +2791,7 @@ PHP_METHOD(Phalcon_Mvc_Router, getRewriteUri) zephir_get_global(&_SERVER, SL("_SERVER")); zephir_get_global(&_GET, SL("_GET")); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 305, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 306, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_LONG_IDENTICAL(&_0, 0)) { zephir_memory_observe(&url); if (zephir_array_isset_string_fetch(&url, &_GET, SL("_url"), 0)) { @@ -2857,14 +2857,14 @@ PHP_METHOD(Phalcon_Mvc_Router, getRouteById) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &routeId); zephir_memory_observe(&key); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 306, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 307, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&key, &_0, routeId, 0)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 289, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2$$3); zephir_array_fetch(&_2$$3, &_1$$3, &key, PH_NOISY, "phalcon/Mvc/Router.zep", 969); RETURN_CCTOR(&_2$$3); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 289, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_3) == IS_STRING) { ZEPHIR_INIT_VAR(&_5); zephir_string_to_char_array(&_5, &_3); @@ -2964,14 +2964,14 @@ PHP_METHOD(Phalcon_Mvc_Router, getRouteByName) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); zephir_memory_observe(&key); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 307, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 308, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_fetch(&key, &_0, &name_zv, 0)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 289, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2$$3); zephir_array_fetch(&_2$$3, &_1$$3, &key, PH_NOISY, "phalcon/Mvc/Router.zep", 992); RETURN_CCTOR(&_2$$3); } - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 289, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_3) == IS_STRING) { ZEPHIR_INIT_VAR(&_5); zephir_string_to_char_array(&_5, &_3); @@ -3374,7 +3374,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZEPHIR_CALL_METHOD(&realUri, this_ptr, "extractRealUri", NULL, 0, &uri_zv); zephir_check_call_status(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 308, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 309, PH_NOISY_CC | PH_READONLY); _1 = zephir_is_true(&_0); if (_1) { _1 = !ZEPHIR_IS_STRING_IDENTICAL(&realUri, "/"); @@ -3405,14 +3405,14 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) array_init(&vetoedRoutes); ZEPHIR_INIT_VAR(&_3); array_init(&_3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 309, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 310, &_3); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 310, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 311, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 310, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 311, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 311, &__$null); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_4, 312, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 312, &__$null); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_4, 313, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_4); if (Z_TYPE_P(&eventsManager) != IS_NULL) { ZEPHIR_INIT_VAR(&_5$$8); @@ -3420,7 +3420,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZEPHIR_CALL_METHOD(NULL, &eventsManager, "fire", NULL, 0, &_5$$8, this_ptr); zephir_check_call_status(); } - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_5, 313, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_5, 314, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_4); if (Z_TYPE_P(&container) == IS_NULL) { ZEPHIR_INIT_VAR(&_6$$9); @@ -3436,7 +3436,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZEPHIR_CALL_METHOD(&_7, &container, "get", NULL, 0, &_8); zephir_check_call_status(); ZEPHIR_CPY_WRT(&request, &_7); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_6, 289, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_6, 290, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_4)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "rebuildMethodIndex", NULL, 0); zephir_check_call_status(); @@ -3447,32 +3447,32 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZEPHIR_INIT_VAR(&candidateRoutes); array_init(&candidateRoutes); ZEPHIR_OBS_NVAR(&candidateRoutes); - zephir_read_property_cached(&_9, this_ptr, _zephir_prop_7, 291, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_7, 292, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&candidateRoutes, &_9, &requestMethod, 0))) { ZEPHIR_INIT_NVAR(&candidateMethod); ZVAL_STRING(&candidateMethod, "*"); ZEPHIR_OBS_NVAR(&candidateRoutes); - zephir_read_property_cached(&_10$$11, this_ptr, _zephir_prop_7, 291, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10$$11, this_ptr, _zephir_prop_7, 292, PH_NOISY_CC | PH_READONLY); zephir_array_isset_string_fetch(&candidateRoutes, &_10$$11, SL("*"), 0); } if (Z_TYPE_P(&candidateRoutes) != IS_ARRAY) { ZEPHIR_INIT_NVAR(&candidateRoutes); array_init(&candidateRoutes); } - zephir_read_property_cached(&_11, this_ptr, _zephir_prop_8, 294, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11, this_ptr, _zephir_prop_8, 295, PH_NOISY_CC | PH_READONLY); _12 = zephir_array_isset_value(&_11, &requestMethod); if (_12) { - zephir_read_property_cached(&_13, this_ptr, _zephir_prop_8, 294, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13, this_ptr, _zephir_prop_8, 295, PH_NOISY_CC | PH_READONLY); _12 = !(zephir_isempty_dim(&_13, &requestMethod)); } if (_12) { ZEPHIR_CALL_METHOD(¤tHostName, &request, "getHttpHost", NULL, 0); zephir_check_call_status(); } else { - zephir_read_property_cached(&_14, this_ptr, _zephir_prop_8, 294, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14, this_ptr, _zephir_prop_8, 295, PH_NOISY_CC | PH_READONLY); _15 = zephir_array_isset_value_string(&_14, SL("*")); if (_15) { - zephir_read_property_cached(&_16, this_ptr, _zephir_prop_8, 294, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16, this_ptr, _zephir_prop_8, 295, PH_NOISY_CC | PH_READONLY); _15 = !(zephir_isempty_dim_string(&_16, SL("*"))); } if (_15) { @@ -3483,12 +3483,12 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (Z_TYPE_P(&eventsManager) == IS_NULL) { ZEPHIR_INIT_VAR(&staticBucketMethod); ZVAL_NULL(&staticBucketMethod); - zephir_read_property_cached(&_17$$15, this_ptr, _zephir_prop_9, 292, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_17$$15, this_ptr, _zephir_prop_9, 293, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_18$$15); zephir_array_fetch(&_18$$15, &_17$$15, &requestMethod, 0, "phalcon/Mvc/Router.zep", 1140); _19$$15 = zephir_array_isset_value(&_18$$15, &handledUri); if (_19$$15) { - zephir_read_property_cached(&_20$$15, this_ptr, _zephir_prop_10, 293, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_20$$15, this_ptr, _zephir_prop_10, 294, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_21$$15); zephir_array_fetch(&_21$$15, &_20$$15, &requestMethod, 0, "phalcon/Mvc/Router.zep", 1141); _19$$15 = !(zephir_array_isset_value(&_21$$15, &handledUri)); @@ -3496,17 +3496,17 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (_19$$15) { ZEPHIR_CPY_WRT(&staticBucketMethod, &requestMethod); } else { - zephir_read_property_cached(&_22$$15, this_ptr, _zephir_prop_7, 291, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$15, this_ptr, _zephir_prop_7, 292, PH_NOISY_CC | PH_READONLY); _23$$15 = !(zephir_array_isset_value(&_22$$15, &requestMethod)); if (_23$$15) { - zephir_read_property_cached(&_24$$15, this_ptr, _zephir_prop_9, 292, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24$$15, this_ptr, _zephir_prop_9, 293, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_25$$15); zephir_array_fetch_string(&_25$$15, &_24$$15, SL("*"), 0, "phalcon/Mvc/Router.zep", 1144); _23$$15 = zephir_array_isset_value(&_25$$15, &handledUri); } _26$$15 = _23$$15; if (_26$$15) { - zephir_read_property_cached(&_27$$15, this_ptr, _zephir_prop_10, 293, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_27$$15, this_ptr, _zephir_prop_10, 294, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_28$$15); zephir_array_fetch_string(&_28$$15, &_27$$15, SL("*"), 0, "phalcon/Mvc/Router.zep", 1145); _26$$15 = !(zephir_array_isset_value(&_28$$15, &handledUri)); @@ -3517,7 +3517,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) } } if (Z_TYPE_P(&staticBucketMethod) != IS_NULL) { - zephir_read_property_cached(&_29$$18, this_ptr, _zephir_prop_9, 292, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$18, this_ptr, _zephir_prop_9, 293, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_30$$18); zephir_array_fetch(&_30$$18, &_29$$18, &staticBucketMethod, PH_NOISY, "phalcon/Mvc/Router.zep", 1155); zephir_memory_observe(&staticBucket); @@ -3586,7 +3586,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZVAL_NULL(&matches); ZEPHIR_CALL_METHOD(&parts, &staticRoute, "getPaths", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 311, &staticRoute); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 312, &staticRoute); break; } ZEND_HASH_FOREACH_END(); } else { @@ -3658,7 +3658,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZVAL_NULL(&matches); ZEPHIR_CALL_METHOD(&parts, &staticRoute, "getPaths", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 311, &staticRoute); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 312, &staticRoute); break; } } @@ -3671,17 +3671,17 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) } _46 = _45; if (_46) { - zephir_read_property_cached(&_47, this_ptr, _zephir_prop_11, 297, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_47, this_ptr, _zephir_prop_11, 298, PH_NOISY_CC | PH_READONLY); _46 = !(zephir_array_isset_value(&_47, &candidateMethod)); } _48 = _46; if (_48) { zephir_memory_observe(&combinedChunks); - zephir_read_property_cached(&_49, this_ptr, _zephir_prop_12, 296, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_49, this_ptr, _zephir_prop_12, 297, PH_NOISY_CC | PH_READONLY); _48 = zephir_array_isset_fetch(&combinedChunks, &_49, &candidateMethod, 0); } if (_48) { - zephir_read_property_cached(&_50$$39, this_ptr, _zephir_prop_13, 298, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_50$$39, this_ptr, _zephir_prop_13, 299, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&combinedMarkMaps); zephir_array_fetch(&combinedMarkMaps, &_50$$39, &candidateMethod, PH_NOISY, "phalcon/Mvc/Router.zep", 1229); if (Z_TYPE_P(&combinedChunks) == IS_STRING) { @@ -3721,7 +3721,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) } ZEPHIR_OBS_NVAR(&combinedRoute); zephir_array_fetch(&combinedRoute, &candidateRoutes, &combinedRouteIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1250); - zephir_read_property_cached(&_58$$40, this_ptr, _zephir_prop_14, 299, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_58$$40, this_ptr, _zephir_prop_14, 300, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&combinedRouteMeta); ZEPHIR_CALL_METHOD(&_59$$40, &combinedRoute, "getRouteId", NULL, 0); zephir_check_call_status(); @@ -3753,8 +3753,8 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZEPHIR_CPY_WRT(&matches, &combinedMatchesLocal); ZEPHIR_CALL_METHOD(&combinedConverters, &combinedRoute, "getConverters", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 309, &combinedMatchesLocal); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 311, &combinedRoute); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 310, &combinedMatchesLocal); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 312, &combinedRoute); ZEPHIR_INIT_NVAR(&routeFound); ZVAL_BOOL(&routeFound, 1); if (Z_TYPE_P(&combinedPaths) == IS_STRING) { @@ -3929,7 +3929,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) } ZEPHIR_OBS_NVAR(&combinedRoute); zephir_array_fetch(&combinedRoute, &candidateRoutes, &combinedRouteIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1250); - zephir_read_property_cached(&_87$$62, this_ptr, _zephir_prop_14, 299, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_87$$62, this_ptr, _zephir_prop_14, 300, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&combinedRouteMeta); ZEPHIR_CALL_METHOD(&_88$$62, &combinedRoute, "getRouteId", NULL, 0); zephir_check_call_status(); @@ -3961,8 +3961,8 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZEPHIR_CPY_WRT(&matches, &combinedMatchesLocal); ZEPHIR_CALL_METHOD(&combinedConverters, &combinedRoute, "getConverters", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 309, &combinedMatchesLocal); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 311, &combinedRoute); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 310, &combinedMatchesLocal); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 312, &combinedRoute); ZEPHIR_INIT_NVAR(&routeFound); ZVAL_BOOL(&routeFound, 1); if (Z_TYPE_P(&combinedPaths) == IS_STRING) { @@ -4130,7 +4130,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (zephir_array_isset_value(&vetoedRoutes, &routeId)) { continue; } - zephir_read_property_cached(&_117$$85, this_ptr, _zephir_prop_14, 299, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_117$$85, this_ptr, _zephir_prop_14, 300, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_118$$85); zephir_array_fetch(&_118$$85, &_117$$85, &routeId, PH_NOISY, "phalcon/Mvc/Router.zep", 1325); ZEPHIR_CPY_WRT(&routeMeta, &_118$$85); @@ -4344,9 +4344,9 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) } ZEPHIR_INIT_NVAR(&position); ZEPHIR_INIT_NVAR(&part); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 309, &matches); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 310, &matches); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 311, &route); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 312, &route); break; } } ZEND_HASH_FOREACH_END(); @@ -4375,7 +4375,7 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (zephir_array_isset_value(&vetoedRoutes, &routeId)) { continue; } - zephir_read_property_cached(&_147$$122, this_ptr, _zephir_prop_14, 299, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_147$$122, this_ptr, _zephir_prop_14, 300, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_148$$122); zephir_array_fetch(&_148$$122, &_147$$122, &routeId, PH_NOISY, "phalcon/Mvc/Router.zep", 1325); ZEPHIR_CPY_WRT(&routeMeta, &_148$$122); @@ -4589,9 +4589,9 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) } ZEPHIR_INIT_NVAR(&position); ZEPHIR_INIT_NVAR(&part); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 309, &matches); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 310, &matches); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 311, &route); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 312, &route); break; } } @@ -4601,19 +4601,19 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) } if (zephir_is_true(&routeFound)) { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 310, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 311, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 310, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 311, &__$false); } } else { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 310, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 311, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 310, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 311, &__$false); } } if (!(zephir_is_true(&routeFound))) { - zephir_read_property_cached(&_175$$161, this_ptr, _zephir_prop_15, 314, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_175$$161, this_ptr, _zephir_prop_15, 315, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(¬FoundPaths, &_175$$161); if (Z_TYPE_P(¬FoundPaths) != IS_NULL) { ZEPHIR_CALL_CE_STATIC(&parts, phalcon_mvc_router_route_ce, "getRoutePaths", NULL, 0, ¬FoundPaths); @@ -4622,35 +4622,35 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZVAL_BOOL(&routeFound, 1); } } - zephir_read_property_cached(&_176, this_ptr, _zephir_prop_16, 300, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 315, &_176); - zephir_read_property_cached(&_177, this_ptr, _zephir_prop_18, 301, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 316, &_177); - zephir_read_property_cached(&_178, this_ptr, _zephir_prop_20, 302, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_21, 317, &_178); - zephir_read_property_cached(&_179, this_ptr, _zephir_prop_22, 303, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_23, 318, &_179); - zephir_read_property_cached(&_180, this_ptr, _zephir_prop_24, 304, PH_NOISY_CC | PH_READONLY); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_25, 319, &_180); + zephir_read_property_cached(&_176, this_ptr, _zephir_prop_16, 301, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 316, &_176); + zephir_read_property_cached(&_177, this_ptr, _zephir_prop_18, 302, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 317, &_177); + zephir_read_property_cached(&_178, this_ptr, _zephir_prop_20, 303, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_21, 318, &_178); + zephir_read_property_cached(&_179, this_ptr, _zephir_prop_22, 304, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_23, 319, &_179); + zephir_read_property_cached(&_180, this_ptr, _zephir_prop_24, 305, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_25, 320, &_180); if (zephir_is_true(&routeFound)) { zephir_memory_observe(&vnamespace); if (zephir_array_isset_string_fetch(&vnamespace, &parts, SL("namespace"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 315, &vnamespace); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_17, 316, &vnamespace); zephir_array_unset_string(&parts, SL("namespace"), PH_SEPARATE); } zephir_memory_observe(&module); if (zephir_array_isset_string_fetch(&module, &parts, SL("module"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 316, &module); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_19, 317, &module); zephir_array_unset_string(&parts, SL("module"), PH_SEPARATE); } zephir_memory_observe(&controller); if (zephir_array_isset_string_fetch(&controller, &parts, SL("controller"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_21, 317, &controller); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_21, 318, &controller); zephir_array_unset_string(&parts, SL("controller"), PH_SEPARATE); } zephir_memory_observe(&action); if (zephir_array_isset_string_fetch(&action, &parts, SL("action"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_23, 318, &action); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_23, 319, &action); zephir_array_unset_string(&parts, SL("action"), PH_SEPARATE); } zephir_memory_observe(¶msStr); @@ -4670,9 +4670,9 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) if (!(ZEPHIR_IS_EMPTY(¶ms))) { ZEPHIR_INIT_VAR(&_182$$171); zephir_fast_array_merge(&_182$$171, ¶ms, &parts); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_25, 319, &_182$$171); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_25, 320, &_182$$171); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_25, 319, &parts); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_25, 320, &parts); } } if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { @@ -4681,19 +4681,19 @@ PHP_METHOD(Phalcon_Mvc_Router, handle) ZEPHIR_CALL_METHOD(NULL, &eventsManager, "fire", NULL, 0, &_183$$173, this_ptr); zephir_check_call_status(); } - zephir_read_property_cached(&_184, this_ptr, _zephir_prop_26, 320, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_184, this_ptr, _zephir_prop_26, 321, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_184) != IS_NULL) { - zephir_read_property_cached(&_185$$174, this_ptr, _zephir_prop_26, 320, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_186$$174, this_ptr, _zephir_prop_27, 321, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_185$$174, this_ptr, _zephir_prop_26, 321, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_186$$174, this_ptr, _zephir_prop_27, 322, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_187$$174, this_ptr, "buildDispatcherDump", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_185$$174, "set", NULL, 0, &_186$$174, &_187$$174); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_26, 320, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_26, 321, &__$null); ZEPHIR_INIT_VAR(&_188$$174); ZEPHIR_INIT_NVAR(&_188$$174); ZVAL_STRING(&_188$$174, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_27, 321, &_188$$174); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_27, 322, &_188$$174); } ZEPHIR_MM_RESTORE(); } @@ -5246,7 +5246,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } } ZEPHIR_INIT_NVAR(&routeData); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 288, &rebuiltRoutes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 289, &rebuiltRoutes); ZEPHIR_INIT_VAR(&methodRoutesRehydrated); array_init(&methodRoutesRehydrated); zephir_array_fetch_string(&_48, &dump, SL("methodRoutes"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 1679); @@ -5284,7 +5284,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) { ZEPHIR_INIT_NVAR(&scalarIdx); ZVAL_COPY(&scalarIdx, _56$$20); - zephir_read_property_cached(&_57$$21, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_57$$21, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_58$$21); zephir_array_fetch(&_58$$21, &_57$$21, &scalarIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1682); zephir_array_append(&mostInnerArr, &_58$$21, PH_SEPARATE, "phalcon/Mvc/Router.zep", 1682); @@ -5307,7 +5307,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_CALL_METHOD(&scalarIdx, _54$$20, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_61$$22, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_61$$22, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_62$$22); zephir_array_fetch(&_62$$22, &_61$$22, &scalarIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1682); zephir_array_append(&mostInnerArr, &_62$$22, PH_SEPARATE, "phalcon/Mvc/Router.zep", 1682); @@ -5351,7 +5351,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) { ZEPHIR_INIT_NVAR(&scalarIdx); ZVAL_COPY(&scalarIdx, _67$$23); - zephir_read_property_cached(&_68$$24, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_68$$24, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_69$$24); zephir_array_fetch(&_69$$24, &_68$$24, &scalarIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1682); zephir_array_append(&mostInnerArr, &_69$$24, PH_SEPARATE, "phalcon/Mvc/Router.zep", 1682); @@ -5374,7 +5374,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_CALL_METHOD(&scalarIdx, _65$$23, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_72$$25, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_72$$25, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_73$$25); zephir_array_fetch(&_73$$25, &_72$$25, &scalarIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1682); zephir_array_append(&mostInnerArr, &_73$$25, PH_SEPARATE, "phalcon/Mvc/Router.zep", 1682); @@ -5423,7 +5423,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) { ZEPHIR_INIT_NVAR(&scalarIdx); ZVAL_COPY(&scalarIdx, _82$$26); - zephir_read_property_cached(&_83$$27, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_83$$27, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_84$$27); zephir_array_fetch(&_84$$27, &_83$$27, &scalarIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1691); zephir_array_append(&mostInnerArr, &_84$$27, PH_SEPARATE, "phalcon/Mvc/Router.zep", 1691); @@ -5446,7 +5446,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_CALL_METHOD(&scalarIdx, _80$$26, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_87$$28, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_87$$28, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_88$$28); zephir_array_fetch(&_88$$28, &_87$$28, &scalarIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1691); zephir_array_append(&mostInnerArr, &_88$$28, PH_SEPARATE, "phalcon/Mvc/Router.zep", 1691); @@ -5490,7 +5490,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) { ZEPHIR_INIT_NVAR(&scalarIdx); ZVAL_COPY(&scalarIdx, _93$$29); - zephir_read_property_cached(&_94$$30, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_94$$30, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_95$$30); zephir_array_fetch(&_95$$30, &_94$$30, &scalarIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1691); zephir_array_append(&mostInnerArr, &_95$$30, PH_SEPARATE, "phalcon/Mvc/Router.zep", 1691); @@ -5513,7 +5513,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_CALL_METHOD(&scalarIdx, _91$$29, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_98$$31, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_98$$31, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_99$$31); zephir_array_fetch(&_99$$31, &_98$$31, &scalarIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1691); zephir_array_append(&mostInnerArr, &_99$$31, PH_SEPARATE, "phalcon/Mvc/Router.zep", 1691); @@ -5584,7 +5584,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) { ZEPHIR_INIT_NVAR(&scalarIdx); ZVAL_COPY(&scalarIdx, _114$$33); - zephir_read_property_cached(&_115$$34, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_115$$34, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_116$$34); zephir_array_fetch(&_116$$34, &_115$$34, &scalarIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1702); zephir_array_append(&mostInnerArr, &_116$$34, PH_SEPARATE, "phalcon/Mvc/Router.zep", 1702); @@ -5607,7 +5607,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_CALL_METHOD(&scalarIdx, _112$$33, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_119$$35, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_119$$35, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_120$$35); zephir_array_fetch(&_120$$35, &_119$$35, &scalarIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1702); zephir_array_append(&mostInnerArr, &_120$$35, PH_SEPARATE, "phalcon/Mvc/Router.zep", 1702); @@ -5651,7 +5651,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) { ZEPHIR_INIT_NVAR(&scalarIdx); ZVAL_COPY(&scalarIdx, _125$$36); - zephir_read_property_cached(&_126$$37, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_126$$37, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_127$$37); zephir_array_fetch(&_127$$37, &_126$$37, &scalarIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1702); zephir_array_append(&mostInnerArr, &_127$$37, PH_SEPARATE, "phalcon/Mvc/Router.zep", 1702); @@ -5674,7 +5674,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_CALL_METHOD(&scalarIdx, _123$$36, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_130$$38, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_130$$38, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_131$$38); zephir_array_fetch(&_131$$38, &_130$$38, &scalarIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1702); zephir_array_append(&mostInnerArr, &_131$$38, PH_SEPARATE, "phalcon/Mvc/Router.zep", 1702); @@ -5744,7 +5744,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) { ZEPHIR_INIT_NVAR(&scalarIdx); ZVAL_COPY(&scalarIdx, _142$$40); - zephir_read_property_cached(&_143$$41, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_143$$41, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_144$$41); zephir_array_fetch(&_144$$41, &_143$$41, &scalarIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1702); zephir_array_append(&mostInnerArr, &_144$$41, PH_SEPARATE, "phalcon/Mvc/Router.zep", 1702); @@ -5767,7 +5767,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_CALL_METHOD(&scalarIdx, _140$$40, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_147$$42, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_147$$42, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_148$$42); zephir_array_fetch(&_148$$42, &_147$$42, &scalarIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1702); zephir_array_append(&mostInnerArr, &_148$$42, PH_SEPARATE, "phalcon/Mvc/Router.zep", 1702); @@ -5811,7 +5811,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) { ZEPHIR_INIT_NVAR(&scalarIdx); ZVAL_COPY(&scalarIdx, _153$$43); - zephir_read_property_cached(&_154$$44, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_154$$44, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_155$$44); zephir_array_fetch(&_155$$44, &_154$$44, &scalarIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1702); zephir_array_append(&mostInnerArr, &_155$$44, PH_SEPARATE, "phalcon/Mvc/Router.zep", 1702); @@ -5834,7 +5834,7 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_CALL_METHOD(&scalarIdx, _151$$43, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_158$$45, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_158$$45, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_159$$45); zephir_array_fetch(&_159$$45, &_158$$45, &scalarIdx, PH_NOISY, "phalcon/Mvc/Router.zep", 1702); zephir_array_append(&mostInnerArr, &_159$$45, PH_SEPARATE, "phalcon/Mvc/Router.zep", 1702); @@ -5850,33 +5850,33 @@ PHP_METHOD(Phalcon_Mvc_Router, loadDispatcherFromArray) } ZEPHIR_INIT_NVAR(&innerVal); ZEPHIR_INIT_NVAR(&innerKey); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 290, &methodRoutesRehydrated); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 291, &candidatesRehydrated); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 292, &staticRehydrated); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 291, &methodRoutesRehydrated); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 292, &candidatesRehydrated); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 293, &staticRehydrated); zephir_array_fetch_string(&_160, &dump, SL("staticShadowedByMethod"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 1711); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 293, &_160); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 294, &_160); zephir_array_fetch_string(&_161, &dump, SL("hostnameByMethod"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 1712); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 294, &_161); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 295, &_161); zephir_array_fetch_string(&_162, &dump, SL("hostnameLessByMethod"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 1713); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 295, &_162); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 296, &_162); zephir_array_fetch_string(&_163, &dump, SL("combinedRegexByMethod"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 1714); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 296, &_163); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 297, &_163); zephir_array_fetch_string(&_164, &dump, SL("combinedRegexDisabled"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 1715); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 297, &_164); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 298, &_164); zephir_array_fetch_string(&_165, &dump, SL("combinedRegexMarkMap"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 1716); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 298, &_165); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 299, &_165); zephir_array_fetch_string(&_166, &dump, SL("routeMeta"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Router.zep", 1717); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 299, &_166); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 300, &_166); ZEPHIR_INIT_VAR(&_167); array_init(&_167); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 306, &_167); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 307, &_167); ZEPHIR_INIT_VAR(&_168); array_init(&_168); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_12, 307, &_168); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_12, 308, &_168); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 289, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 290, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 289, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_13, 290, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -6120,7 +6120,7 @@ PHP_METHOD(Phalcon_Mvc_Router, mount) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &group); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 312, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 313, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_0); if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_1$$3); @@ -6311,7 +6311,7 @@ PHP_METHOD(Phalcon_Mvc_Router, notFound) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 314, paths); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 315, paths); RETURN_THIS(); } @@ -6342,9 +6342,9 @@ PHP_METHOD(Phalcon_Mvc_Router, removeExtraSlashes) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &remove_param); if (remove) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 308, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 309, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 308, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 309, &__$false); } RETURN_THISW(); } @@ -6374,7 +6374,7 @@ PHP_METHOD(Phalcon_Mvc_Router, setDefaultAction) Z_PARAM_STR(actionName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&actionName_zv, actionName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 303, &actionName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 304, &actionName_zv); RETURN_THISW(); } @@ -6403,7 +6403,7 @@ PHP_METHOD(Phalcon_Mvc_Router, setDefaultController) Z_PARAM_STR(controllerName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&controllerName_zv, controllerName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 302, &controllerName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 303, &controllerName_zv); RETURN_THISW(); } @@ -6432,7 +6432,7 @@ PHP_METHOD(Phalcon_Mvc_Router, setDefaultModule) Z_PARAM_STR(moduleName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&moduleName_zv, moduleName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 301, &moduleName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 302, &moduleName_zv); RETURN_THISW(); } @@ -6461,7 +6461,7 @@ PHP_METHOD(Phalcon_Mvc_Router, setDefaultNamespace) Z_PARAM_STR(namespaceName) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&namespaceName_zv, namespaceName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 300, &namespaceName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 301, &namespaceName_zv); RETURN_THISW(); } @@ -6535,26 +6535,26 @@ PHP_METHOD(Phalcon_Mvc_Router, setDefaults) zephir_memory_observe(&namespaceName); if (zephir_array_isset_string_fetch(&namespaceName, &defaults, SL("namespace"), 0)) { zephir_cast_to_string(&_0$$3, &namespaceName); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 300, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 301, &_0$$3); } zephir_memory_observe(&module); if (zephir_array_isset_string_fetch(&module, &defaults, SL("module"), 0)) { zephir_cast_to_string(&_1$$4, &module); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 301, &_1$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 302, &_1$$4); } zephir_memory_observe(&controller); if (zephir_array_isset_string_fetch(&controller, &defaults, SL("controller"), 0)) { zephir_cast_to_string(&_2$$5, &controller); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 302, &_2$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 303, &_2$$5); } zephir_memory_observe(&action); if (zephir_array_isset_string_fetch(&action, &defaults, SL("action"), 0)) { zephir_cast_to_string(&_3$$6, &action); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 303, &_3$$6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 304, &_3$$6); } zephir_memory_observe(¶ms); if (zephir_array_isset_string_fetch(¶ms, &defaults, SL("params"), 0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 304, ¶ms); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 305, ¶ms); } RETURN_THIS(); } @@ -6581,7 +6581,7 @@ PHP_METHOD(Phalcon_Mvc_Router, setEventsManager) Z_PARAM_OBJECT_OF_CLASS(eventsManager, phalcon_events_managerinterface_ce) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &eventsManager); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 312, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 313, eventsManager); } /** @@ -6612,7 +6612,7 @@ PHP_METHOD(Phalcon_Mvc_Router, setKeyRouteIds) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &routeIds_param); zephir_get_arrval(&routeIds, routeIds_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 306, &routeIds); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 307, &routeIds); RETURN_THIS(); } @@ -6644,7 +6644,7 @@ PHP_METHOD(Phalcon_Mvc_Router, setKeyRouteNames) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_fetch_params(1, 1, 0, &routeNames_param); zephir_get_arrval(&routeNames, routeNames_param); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 307, &routeNames); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 308, &routeNames); RETURN_THIS(); } @@ -6675,7 +6675,7 @@ PHP_METHOD(Phalcon_Mvc_Router, setUriSource) zephir_fetch_params_without_memory_grow(1, 0, &uriSource_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, uriSource); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 305, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 306, &_0); RETURN_THISW(); } @@ -6747,8 +6747,8 @@ PHP_METHOD(Phalcon_Mvc_Router, useCache) zephir_check_call_status(); RETURN_MM_NULL(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 320, cache); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 321, &key_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 321, cache); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 322, &key_zv); ZEPHIR_MM_RESTORE(); } @@ -7409,7 +7409,7 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) array_init(&routePatterns); ZEPHIR_INIT_VAR(&routeHosts); array_init(&routeHosts); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); @@ -7656,7 +7656,7 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) array_init(&bucket); ZEPHIR_INIT_NVAR(&positions); array_init(&positions); - zephir_read_property_cached(&_29$$24, this_ptr, _zephir_prop_0, 288, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_29$$24, this_ptr, _zephir_prop_0, 289, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_29$$24) == IS_STRING) { ZEPHIR_INIT_NVAR(&_31$$24); zephir_string_to_char_array(&_31$$24, &_29$$24); @@ -8380,20 +8380,20 @@ PHP_METHOD(Phalcon_Mvc_Router, rebuildMethodIndex) } ZEND_HASH_FOREACH_END(); ZEPHIR_INIT_NVAR(&positions); ZEPHIR_INIT_NVAR(&method); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 290, &methodRoutes); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 291, &candidatesByMethod); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 299, &routeMeta); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 292, &staticByMethod); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 293, &staticShadowedByMethod); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 294, &hostnameByMethod); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 295, &hostnameLessByMethod); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 296, &combinedRegexByMethod); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 298, &combinedRegexMarkMap); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 297, &combinedRegexDisabled); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 291, &methodRoutes); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 292, &candidatesByMethod); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 300, &routeMeta); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 293, &staticByMethod); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 294, &staticShadowedByMethod); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 295, &hostnameByMethod); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 296, &hostnameLessByMethod); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 297, &combinedRegexByMethod); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 299, &combinedRegexMarkMap); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 298, &combinedRegexDisabled); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 289, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 290, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 289, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_11, 290, &__$false); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/mvc/router/annotations.zep.c b/ext/phalcon/mvc/router/annotations.zep.c index 348d758b33..7dded5e39c 100644 --- a/ext/phalcon/mvc/router/annotations.zep.c +++ b/ext/phalcon/mvc/router/annotations.zep.c @@ -290,7 +290,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, 1156, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1157, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_0); if (UNEXPECTED(Z_TYPE_P(&container) != IS_OBJECT)) { ZEPHIR_INIT_VAR(&_1$$3); @@ -301,9 +301,9 @@ PHP_METHOD(Phalcon_Mvc_Router_Annotations, handle) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1157, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1158, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&handlers, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1158, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1159, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&controllerSuffix, &_0); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "annotations"); @@ -370,7 +370,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, 1159, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1160, &__$null); ZEPHIR_OBS_NVAR(&moduleName); zephir_array_isset_long_fetch(&moduleName, &scope, 2, 0); ZEPHIR_INIT_NVAR(&_15$$4); @@ -646,7 +646,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, 1159, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1160, &__$null); ZEPHIR_OBS_NVAR(&moduleName); zephir_array_isset_long_fetch(&moduleName, &scope, 2, 0); ZEPHIR_INIT_NVAR(&_54$$28); @@ -978,16 +978,16 @@ PHP_METHOD(Phalcon_Mvc_Router_Annotations, processActionAnnotation) if (!(isRoute)) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1160, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1161, 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, 1159, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1160, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&routePrefix, &_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1161, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1162, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_2) != IS_NULL) { - zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_2, 1161, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$6, this_ptr, _zephir_prop_2, 1162, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_4$$6, "call_user_func", NULL, 81, &_3$$6, &proxyActionName); zephir_check_call_status(); ZEPHIR_CPY_WRT(&proxyActionName, &_4$$6); @@ -1213,7 +1213,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Annotations, processControllerAnnotation) ZVAL_STRING(&_2$$3, "prefix"); ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "resolveArgument", NULL, 0, annotation, &_2$$3); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1159, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1160, &_1$$3); } ZEPHIR_MM_RESTORE(); } @@ -1239,7 +1239,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, 1160, &actionSuffix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1161, &actionSuffix_zv); RETURN_THISW(); } @@ -1303,12 +1303,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, 1161, callback); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1162, 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_94__closure_ce, SL("__invoke")); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1161, &_0$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1162, &_0$$4); } else { ZEPHIR_INIT_VAR(&_1$$5); object_init_ex(&_1$$5, phalcon_mvc_router_exceptions_invalidcallbackparameter_ce); @@ -1351,7 +1351,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, 1158, &controllerSuffix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1159, &controllerSuffix_zv); RETURN_THISW(); } diff --git a/ext/phalcon/mvc/router/group.zep.c b/ext/phalcon/mvc/router/group.zep.c index c682c1fe0b..54ed8e3ce4 100644 --- a/ext/phalcon/mvc/router/group.zep.c +++ b/ext/phalcon/mvc/router/group.zep.c @@ -152,7 +152,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, 1162, paths); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1163, paths); } if ((zephir_method_exists_ex(this_ptr, ZEND_STRL("initialize")) == SUCCESS)) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0, paths); @@ -723,7 +723,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, 1163, beforeMatch); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1164, beforeMatch); RETURN_THISW(); } @@ -746,7 +746,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, 1164, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1165, &_0); ZEPHIR_MM_RESTORE(); } @@ -818,7 +818,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, 1165, &hostname_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1166, &hostname_zv); RETURN_THISW(); } @@ -844,7 +844,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, 1162, paths); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1163, paths); RETURN_THISW(); } @@ -867,7 +867,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, 1166, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1167, &prefix_zv); RETURN_THISW(); } @@ -936,7 +936,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Group, addRoute) httpMethods = &__$null; } zephir_memory_observe(&defaultPaths); - zephir_read_property_cached(&defaultPaths, this_ptr, _zephir_prop_0, 1162, PH_NOISY_CC); + zephir_read_property_cached(&defaultPaths, this_ptr, _zephir_prop_0, 1163, 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); @@ -955,7 +955,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, 1166, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1167, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZEPHIR_CONCAT_VV(&_1, &_0, &pattern_zv); ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 267, &_1, &mergedPaths, httpMethods); diff --git a/ext/phalcon/mvc/router/route.zep.c b/ext/phalcon/mvc/router/route.zep.c index 3899c4c85e..a1dd66233c 100644 --- a/ext/phalcon/mvc/router/route.zep.c +++ b/ext/phalcon/mvc/router/route.zep.c @@ -172,12 +172,12 @@ PHP_METHOD(Phalcon_Mvc_Router_Route, __construct) } ZEPHIR_CALL_METHOD(NULL, this_ptr, "reConfigure", NULL, 0, &pattern_zv, paths); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1167, httpMethods); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1168, httpMethods); zephir_memory_observe(&_0); 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_1, 1168, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1169, &_1); ZEPHIR_INIT_VAR(&_2); ZVAL_LONG(&_2, 1); ZEPHIR_INIT_VAR(&_3); @@ -346,7 +346,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, 1169, callback); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1170, callback); RETURN_THISW(); } @@ -785,18 +785,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, 1170, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1171, 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, 1171, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1172, 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, 1170, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1171, &__$null); RETURN_MM_NULL(); } if (!(zephir_memnstr_str(&hostname, SL("("), "phalcon/Mvc/Router/Route.zep", 517))) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1170, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1171, &__$null); RETURN_MM_NULL(); } if (!(zephir_memnstr_str(&hostname, SL("#"), "phalcon/Mvc/Router/Route.zep", 522))) { @@ -809,7 +809,7 @@ PHP_METHOD(Phalcon_Mvc_Router_Route, getCompiledHostName) } else { ZEPHIR_CPY_WRT(®exHostName, &hostname); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1170, ®exHostName); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1171, ®exHostName); RETURN_CCTOR(®exHostName); } @@ -904,27 +904,27 @@ PHP_METHOD(Phalcon_Mvc_Router_Route, getIndexData) ZEPHIR_INIT_VAR(&compiledHostName); ZVAL_NULL(&compiledHostName); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1171, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1172, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { ZEPHIR_CALL_METHOD(&compiledHostName, this_ptr, "getCompiledHostName", NULL, 0); zephir_check_call_status(); } zephir_create_array(return_value, 6, 0); zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1167, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1168, PH_NOISY_CC); zephir_array_fast_append(return_value, &_1); ZEPHIR_OBS_NVAR(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1172, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_2, 1173, PH_NOISY_CC); zephir_array_fast_append(return_value, &_1); ZEPHIR_OBS_NVAR(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1171, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1172, PH_NOISY_CC); zephir_array_fast_append(return_value, &_1); zephir_array_fast_append(return_value, &compiledHostName); ZEPHIR_OBS_NVAR(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1169, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1170, PH_NOISY_CC); zephir_array_fast_append(return_value, &_1); ZEPHIR_OBS_NVAR(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_4, 1168, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_4, 1169, PH_NOISY_CC); zephir_array_fast_append(return_value, &_1); RETURN_MM(); } @@ -987,7 +987,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, 1173, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1174, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_FUNCTION("array_flip", NULL, 266, &_0); zephir_check_call_status(); RETURN_MM(); @@ -1031,7 +1031,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, 1174, callback); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1175, callback); RETURN_THISW(); } @@ -1106,9 +1106,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, 1175, &pattern_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1172, &compiledPattern); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1173, &routePaths); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1176, &pattern_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1173, &compiledPattern); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1174, &routePaths); ZEPHIR_MM_RESTORE(); } @@ -1130,7 +1130,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, 1176, group); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1177, group); RETURN_THISW(); } @@ -1163,11 +1163,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, 1171, &hostname_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1172, &hostname_zv); if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1170, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1171, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1170, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1171, &__$false); } RETURN_THISW(); } @@ -1233,7 +1233,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, 1177, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1178, &name_zv); RETURN_THISW(); } @@ -1258,7 +1258,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, 1168, &routeId_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1169, &routeId_zv); RETURN_THISW(); } @@ -1291,7 +1291,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, 1167, httpMethods); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1168, httpMethods); RETURN_THISW(); } diff --git a/ext/phalcon/mvc/url.zep.c b/ext/phalcon/mvc/url.zep.c index 618ff30ff0..1a54fbae4c 100644 --- a/ext/phalcon/mvc/url.zep.c +++ b/ext/phalcon/mvc/url.zep.c @@ -99,7 +99,7 @@ PHP_METHOD(Phalcon_Mvc_Url, __construct) router = &router_sub; router = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1178, router); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1179, router); } /** @@ -299,10 +299,10 @@ PHP_METHOD(Phalcon_Mvc_Url, get) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_7$$9, this_ptr, _zephir_prop_0, 1178, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$9, this_ptr, _zephir_prop_0, 1179, 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, 1179, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$11, this_ptr, _zephir_prop_1, 1180, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_8$$11); if (UNEXPECTED(Z_TYPE_P(&container) != IS_OBJECT)) { ZEPHIR_INIT_VAR(&_9$$12); @@ -331,7 +331,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, 1178, &router); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1179, &router); } ZEPHIR_CALL_METHOD(&_14$$9, &router, "getRouteByName", NULL, 0, &routeName); zephir_check_call_status(); @@ -478,7 +478,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, 1180, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1181, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&baseUri, &_0); if (Z_TYPE_P(&baseUri) == IS_NULL) { zephir_memory_observe(&phpSelf); @@ -495,7 +495,7 @@ PHP_METHOD(Phalcon_Mvc_Url, getBaseUri) } else { ZEPHIR_CONCAT_SVS(&baseUri, "/", &uri, "/"); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1180, &baseUri); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1181, &baseUri); } RETURN_CCTOR(&baseUri); } @@ -570,7 +570,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, 1181, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1182, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { RETURN_MM_MEMBER_TYPED(getThis(), "staticBaseUri", IS_STRING); } @@ -609,7 +609,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, 1182, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1183, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_VV(return_value, &_0, &path_zv); RETURN_MM(); } @@ -637,7 +637,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, 1182, &basePath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1183, &basePath_zv); RETURN_THISW(); } @@ -671,10 +671,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, 1180, &baseUri_zv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1181, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1181, &baseUri_zv); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1182, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1181, &baseUri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1182, &baseUri_zv); } RETURN_THISW(); } @@ -702,7 +702,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, 1181, &staticBaseUri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1182, &staticBaseUri_zv); RETURN_THISW(); } diff --git a/ext/phalcon/mvc/view.zep.c b/ext/phalcon/mvc/view.zep.c index 03603a7303..ca1f7f820d 100644 --- a/ext/phalcon/mvc/view.zep.c +++ b/ext/phalcon/mvc/view.zep.c @@ -298,13 +298,13 @@ PHP_METHOD(Phalcon_Mvc_View, __construct) } else { zephir_get_arrval(&options, options_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1183, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1184, &options); ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1184, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1185, &_0); ZEPHIR_INIT_VAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1185, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1186, &_1); ZEPHIR_MM_RESTORE(); } @@ -360,7 +360,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, 1185, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1186, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &key_zv)); } @@ -414,7 +414,7 @@ PHP_METHOD(Phalcon_Mvc_View, cleanTemplateAfter) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1186, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1187, &_0); RETURN_THIS(); } @@ -437,7 +437,7 @@ PHP_METHOD(Phalcon_Mvc_View, cleanTemplateBefore) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1187, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1188, &_0); RETURN_THIS(); } @@ -456,9 +456,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, 1188, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1189, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1188, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1189, &__$false); } RETURN_THISW(); } @@ -492,7 +492,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, 1189, level); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1190, level); } else { zephir_update_property_array(this_ptr, SL("disabledLevels"), level, &__$true); } @@ -514,9 +514,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, 1188, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1189, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1188, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1189, &__$false); } RETURN_THISW(); } @@ -592,7 +592,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, 1190, PH_NOISY_CC); + zephir_read_property_cached(&activeRenderPath, this_ptr, _zephir_prop_0, 1191, PH_NOISY_CC); if (Z_TYPE_P(&activeRenderPath) == IS_ARRAY) { if (zephir_fast_count_int(&activeRenderPath) == 1) { zephir_memory_observe(&_0$$4); @@ -899,10 +899,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, 1191, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1192, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&basePath, &_0); zephir_memory_observe(&engines); - zephir_read_property_cached(&engines, this_ptr, _zephir_prop_1, 1184, PH_NOISY_CC); + zephir_read_property_cached(&engines, this_ptr, _zephir_prop_1, 1185, PH_NOISY_CC); if (ZEPHIR_IS_EMPTY(&engines)) { ZEPHIR_INIT_VAR(&_1$$3); zephir_create_array(&_1$$3, 1, 0); @@ -1152,11 +1152,11 @@ PHP_METHOD(Phalcon_Mvc_View, partial) ZEPHIR_INIT_VAR(&viewParams); array_init(&viewParams); if (Z_TYPE_P(params) == IS_ARRAY) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1185, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1186, 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, 1185, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1186, &_1$$3); ZEPHIR_INIT_VAR(&_2$$3); ZEPHIR_CREATE_SYMBOL_TABLE(); @@ -1214,7 +1214,7 @@ PHP_METHOD(Phalcon_Mvc_View, partial) } ZEPHIR_CALL_METHOD(&_14, this_ptr, "loadTemplateEngines", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_15, this_ptr, _zephir_prop_1, 1192, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15, this_ptr, _zephir_prop_1, 1193, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_16); ZEPHIR_CONCAT_VV(&_16, &_15, &partialPath); ZVAL_BOOL(&_17, 0); @@ -1222,7 +1222,7 @@ PHP_METHOD(Phalcon_Mvc_View, partial) ZEPHIR_CALL_METHOD(NULL, this_ptr, "engineRender", NULL, 0, &_14, &_16, &_17, &_18); zephir_check_call_status(); if (Z_TYPE_P(params) == IS_ARRAY) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1185, &viewParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1186, &viewParams); } ZEPHIR_MM_RESTORE(); } @@ -1286,7 +1286,7 @@ PHP_METHOD(Phalcon_Mvc_View, pick) zephir_array_append(&pickView, &layout, PH_SEPARATE, "phalcon/Mvc/View.zep", 689); } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1193, &pickView); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1194, &pickView); RETURN_THIS(); } @@ -1440,25 +1440,25 @@ PHP_METHOD(Phalcon_Mvc_View, processRender) } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1194, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1188, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1195, &_0); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1189, 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, 1195, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1196, &_1$$3); RETURN_MM_BOOL(0); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1196, &controllerName_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1197, &actionName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1197, &controllerName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1198, &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, 1198, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_5, 1199, 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, 1199, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_6, 1200, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&layout, &_2); if (zephir_is_true(&layout)) { ZEPHIR_CPY_WRT(&layoutName, &layout); @@ -1467,7 +1467,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, 1193, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_7, 1194, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&pickView, &_2); if (Z_TYPE_P(&pickView) == IS_NULL) { ZEPHIR_INIT_VAR(&_3$$7); @@ -1483,7 +1483,7 @@ PHP_METHOD(Phalcon_Mvc_View, processRender) } } } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_8, 1200, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_8, 1201, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_2); ZEPHIR_INIT_VAR(&_4); ZEPHIR_CREATE_SYMBOL_TABLE(); @@ -1503,19 +1503,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, 1195, &_8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1196, &_8); silence = 1; - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_9, 1189, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_9, 1190, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&disabledLevels, &_2); zephir_memory_observe(&_9); - zephir_read_property_cached(&_9, this_ptr, _zephir_prop_10, 1201, PH_NOISY_CC); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_10, 1202, 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, 1194, &_10$$15); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1195, &_10$$15); if (silence) { ZVAL_BOOL(&_10$$15, 1); } else { @@ -1529,8 +1529,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, 1194, &_11$$17); - zephir_read_property_cached(&_11$$17, this_ptr, _zephir_prop_11, 1187, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1195, &_11$$17); + zephir_read_property_cached(&_11$$17, this_ptr, _zephir_prop_11, 1188, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&templatesBefore, &_11$$17); silence = 0; if (Z_TYPE_P(&templatesBefore) == IS_STRING) { @@ -1593,7 +1593,7 @@ PHP_METHOD(Phalcon_Mvc_View, processRender) if (!(zephir_array_isset_value_long(&disabledLevels, 3))) { ZVAL_UNDEF(&_21$$21); ZVAL_LONG(&_21$$21, 3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1194, &_21$$21); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1195, &_21$$21); ZEPHIR_INIT_VAR(&_22$$21); ZEPHIR_CONCAT_VV(&_22$$21, &layoutsDir, &layoutName); if (silence) { @@ -1609,8 +1609,8 @@ PHP_METHOD(Phalcon_Mvc_View, processRender) if (!(zephir_array_isset_value_long(&disabledLevels, 4))) { ZVAL_UNDEF(&_23$$23); ZVAL_LONG(&_23$$23, 4); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1194, &_23$$23); - zephir_read_property_cached(&_23$$23, this_ptr, _zephir_prop_12, 1186, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1195, &_23$$23); + zephir_read_property_cached(&_23$$23, this_ptr, _zephir_prop_12, 1187, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&templatesAfter, &_23$$23); silence = 0; if (Z_TYPE_P(&templatesAfter) == IS_STRING) { @@ -1673,8 +1673,8 @@ PHP_METHOD(Phalcon_Mvc_View, processRender) if (!(zephir_array_isset_value_long(&disabledLevels, 5))) { ZVAL_UNDEF(&_33$$27); ZVAL_LONG(&_33$$27, 5); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1194, &_33$$27); - zephir_read_property_cached(&_33$$27, this_ptr, _zephir_prop_13, 1202, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1195, &_33$$27); + zephir_read_property_cached(&_33$$27, this_ptr, _zephir_prop_13, 1203, PH_NOISY_CC | PH_READONLY); if (silence) { ZVAL_BOOL(&_34$$27, 1); } else { @@ -1686,7 +1686,7 @@ PHP_METHOD(Phalcon_Mvc_View, processRender) } ZVAL_UNDEF(&_35$$13); ZVAL_LONG(&_35$$13, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1194, &_35$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1195, &_35$$13); } _36 = fireEvents; if (_36) { @@ -1736,7 +1736,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, 1184, &engines); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1185, &engines); RETURN_THIS(); } @@ -1834,28 +1834,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, 1188, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1189, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1188, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1189, &__$false); } if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1203, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1204, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1203, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1204, &__$false); } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 5); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1201, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1202, &_0); ZEPHIR_INIT_VAR(&_1); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1195, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1196, &_1); ZEPHIR_INIT_NVAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1187, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1188, &_1); ZEPHIR_INIT_VAR(&_2); array_init(&_2); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1186, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1187, &_2); RETURN_THIS(); } @@ -1883,7 +1883,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, 1191, &basePath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1192, &basePath_zv); RETURN_THISW(); } @@ -1905,7 +1905,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, 1200, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1201, eventsManager); } /** @@ -1932,7 +1932,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, 1199, &layout_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1200, &layout_zv); RETURN_THISW(); } @@ -1961,7 +1961,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, 1198, &layoutsDir_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1199, &layoutsDir_zv); RETURN_THISW(); } @@ -1990,7 +1990,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, 1202, &viewPath_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1203, &viewPath_zv); RETURN_THISW(); } @@ -2046,7 +2046,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, 1192, &partialsDir_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1193, &partialsDir_zv); RETURN_THISW(); } @@ -2078,7 +2078,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, 1201, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1202, &_0); RETURN_THISW(); } @@ -2109,9 +2109,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, 1186, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1187, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1186, templateAfter); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1187, templateAfter); } RETURN_THIS(); } @@ -2143,9 +2143,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, 1187, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1188, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1187, templateBefore); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1188, templateBefore); } RETURN_THIS(); } @@ -2194,11 +2194,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, 1185, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1186, PH_NOISY_CC | PH_READONLY); zephir_fast_array_merge(&_0$$3, &_1$$3, ¶ms); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1185, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1186, &_0$$3); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1185, ¶ms); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1186, ¶ms); } RETURN_THIS(); } @@ -2257,7 +2257,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, 1204, &_2$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1205, &_2$$4); } else { ZEPHIR_INIT_VAR(&newViewsDir); array_init(&newViewsDir); @@ -2329,7 +2329,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, 1204, &newViewsDir); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1205, &newViewsDir); } RETURN_THIS(); } @@ -2357,7 +2357,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, 1195, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1196, &_0); RETURN_THIS(); } @@ -2520,11 +2520,11 @@ PHP_METHOD(Phalcon_Mvc_View, engineRender) ZVAL_STRING(&viewEnginePath, ""); ZEPHIR_INIT_VAR(&viewEnginePaths); array_init(&viewEnginePaths); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1191, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1192, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&basePath, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1185, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1186, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&viewParams, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1200, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1201, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_0); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getViewsDirs", NULL, 0); zephir_check_call_status(); @@ -2570,7 +2570,7 @@ PHP_METHOD(Phalcon_Mvc_View, engineRender) ZEPHIR_INIT_NVAR(&_12$$8); zephir_create_array(&_12$$8, 1, 0); zephir_array_fast_append(&_12$$8, &viewEnginePath); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1190, &_12$$8); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1191, &_12$$8); ZEPHIR_INIT_NVAR(&_14$$8); ZVAL_STRING(&_14$$8, "view:beforeRenderView"); ZEPHIR_CALL_METHOD(&_13$$8, &eventsManager, "fire", &_15, 0, &_14$$8, this_ptr, &viewEnginePath); @@ -2625,7 +2625,7 @@ PHP_METHOD(Phalcon_Mvc_View, engineRender) ZEPHIR_INIT_NVAR(&_22$$13); zephir_create_array(&_22$$13, 1, 0); zephir_array_fast_append(&_22$$13, &viewEnginePath); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1190, &_22$$13); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1191, &_22$$13); ZEPHIR_INIT_NVAR(&_24$$13); ZVAL_STRING(&_24$$13, "view:beforeRenderView"); ZEPHIR_CALL_METHOD(&_23$$13, &eventsManager, "fire", &_25, 0, &_24$$13, this_ptr, &viewEnginePath); @@ -2702,7 +2702,7 @@ PHP_METHOD(Phalcon_Mvc_View, engineRender) ZEPHIR_INIT_NVAR(&_36$$21); zephir_create_array(&_36$$21, 1, 0); zephir_array_fast_append(&_36$$21, &viewEnginePath); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1190, &_36$$21); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1191, &_36$$21); ZEPHIR_INIT_NVAR(&_38$$21); ZVAL_STRING(&_38$$21, "view:beforeRenderView"); ZEPHIR_CALL_METHOD(&_37$$21, &eventsManager, "fire", &_39, 0, &_38$$21, this_ptr, &viewEnginePath); @@ -2757,7 +2757,7 @@ PHP_METHOD(Phalcon_Mvc_View, engineRender) ZEPHIR_INIT_NVAR(&_46$$26); zephir_create_array(&_46$$26, 1, 0); zephir_array_fast_append(&_46$$26, &viewEnginePath); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1190, &_46$$26); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1191, &_46$$26); ZEPHIR_INIT_NVAR(&_48$$26); ZVAL_STRING(&_48$$26, "view:beforeRenderView"); ZEPHIR_CALL_METHOD(&_47$$26, &eventsManager, "fire", &_49, 0, &_48$$26, this_ptr, &viewEnginePath); @@ -2790,7 +2790,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, 1190, &viewEnginePaths); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1191, &viewEnginePaths); ZEPHIR_INIT_VAR(&_53$$29); ZVAL_STRING(&_53$$29, "view:notFoundView"); ZEPHIR_CALL_METHOD(NULL, &eventsManager, "fire", NULL, 0, &_53$$29, this_ptr, &viewEnginePath); @@ -2829,11 +2829,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, 1204, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1205, 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, 1204, PH_NOISY_CC); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1205, PH_NOISY_CC); zephir_array_fast_append(return_value, &_1$$3); RETURN_MM(); } @@ -2942,14 +2942,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, 1203, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1204, 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, 1205, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1206, 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, 1184, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 1185, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(®isteredEngines, &_1$$3); if (ZEPHIR_IS_EMPTY(®isteredEngines)) { ZEPHIR_INIT_VAR(&_2$$4); @@ -3070,7 +3070,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, 1203, &engines); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1204, &engines); } RETURN_CCTOR(&engines); } @@ -3673,7 +3673,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, 1185, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1186, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } @@ -3700,7 +3700,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, 1184, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1185, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } @@ -3733,7 +3733,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, 1185, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1186, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&value, &_0, &key_zv, 0))) { RETURN_MM_NULL(); } @@ -3765,7 +3765,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, 1195, &content_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1196, &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 4ffe1da438..2a3b809d4e 100644 --- a/ext/phalcon/mvc/view/engine/php.zep.c +++ b/ext/phalcon/mvc/view/engine/php.zep.c @@ -146,7 +146,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Php, render) RETURN_MM_NULL(); } if (mustClean) { - zephir_read_property_cached(&_9$$7, this_ptr, _zephir_prop_0, 1206, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9$$7, this_ptr, _zephir_prop_0, 1207, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_10$$7, "ob_get_contents", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_9$$7, "setContent", NULL, 0, &_10$$7); diff --git a/ext/phalcon/mvc/view/engine/volt.zep.c b/ext/phalcon/mvc/view/engine/volt.zep.c index 30946aa9f7..8ce23e69d0 100644 --- a/ext/phalcon/mvc/view/engine/volt.zep.c +++ b/ext/phalcon/mvc/view/engine/volt.zep.c @@ -118,7 +118,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, 1207, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1208, 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); @@ -218,27 +218,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, 1208, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1209, 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, 1209, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1210, 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, 1210, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_2, 1211, 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, 1211, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_3, 1212, 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, 1208, &compiler); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1209, &compiler); } RETURN_CCTOR(&compiler); } @@ -436,7 +436,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, 1210, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1211, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&container, &_1); _2 = Z_TYPE_P(&container) != IS_NULL; if (_2) { @@ -562,7 +562,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, 1212, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1213, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&eventsManager, &_0); if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_2$$4); @@ -644,7 +644,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, render) RETURN_MM_NULL(); } if (mustClean) { - zephir_read_property_cached(&_14$$11, this_ptr, _zephir_prop_1, 1209, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$11, this_ptr, _zephir_prop_1, 1210, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&_15$$11, "ob_get_contents", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_14$$11, "setContent", NULL, 0, &_15$$11); @@ -675,7 +675,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, 1212, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1213, eventsManager); } /** @@ -705,7 +705,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, 1211, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1212, &options); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/mvc/view/engine/volt/compiler.zep.c b/ext/phalcon/mvc/view/engine/volt/compiler.zep.c index 56b73f19ab..e77d8123ef 100644 --- a/ext/phalcon/mvc/view/engine/volt/compiler.zep.c +++ b/ext/phalcon/mvc/view/engine/volt/compiler.zep.c @@ -236,7 +236,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, 1213, view); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1214, view); } /** @@ -395,7 +395,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", 245); if (ZEPHIR_IS_STRING(&variable, "loop")) { zephir_memory_observe(&level); - zephir_read_property_cached(&level, this_ptr, _zephir_prop_0, 1214, PH_NOISY_CC); + zephir_read_property_cached(&level, this_ptr, _zephir_prop_0, 1215, PH_NOISY_CC); ZEPHIR_CALL_METHOD(&_1$$4, this_ptr, "getUniquePrefix", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_2$$4); @@ -403,10 +403,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, 1215, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_1, 1216, 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, 1215, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_1, 1216, 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); @@ -559,7 +559,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compile) ZVAL_STRING(&compiledTemplatePath, ""); ZEPHIR_INIT_VAR(&compilation); ZVAL_NULL(&compilation); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1216, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1217, 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))) { @@ -682,7 +682,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compile) if (Z_TYPE_P(&compiledPath) == IS_STRING) { if (!(ZEPHIR_IS_EMPTY(&compiledPath))) { zephir_memory_observe(&templateSepPath); - zephir_read_property_cached(&_22$$22, this_ptr, _zephir_prop_1, 1217, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$22, this_ptr, _zephir_prop_1, 1218, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&templateSepPath, &_22$$22, &templatePath_zv, 0))) { ZEPHIR_CALL_FUNCTION(&realTemplatePath, "realpath", NULL, 158, &templatePath_zv); zephir_check_call_status(); @@ -799,7 +799,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compile) } } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1218, &compiledTemplatePath); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1219, &compiledTemplatePath); RETURN_CCTOR(&compilation); } @@ -853,8 +853,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, 1219, PH_NOISY_CC); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1219, &autoescape); + zephir_read_property_cached(&oldAutoescape, this_ptr, _zephir_prop_0, 1220, PH_NOISY_CC); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1220, &autoescape); zephir_array_fetch_string(&_1, &statement, SL("block_statements"), PH_NOISY | PH_READONLY, "phalcon/Mvc/View/Engine/Volt/Compiler.zep", 550); if (extendsMode) { ZVAL_BOOL(&_2, 1); @@ -863,7 +863,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, 1219, &oldAutoescape); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1220, &oldAutoescape); RETURN_CCTOR(&compilation); } @@ -1084,7 +1084,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileEcho) } } } - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 1219, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 1220, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_6)) { ZEPHIR_CONCAT_SVS(return_value, "escaper->html(", &exprCode, ") ?>"); RETURN_MM(); @@ -1230,7 +1230,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileFile) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1220, &path_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1221, &path_zv); if (extendsMode) { ZVAL_BOOL(&_4, 1); } else { @@ -1361,7 +1361,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, 1214, PH_NOISY_CC); + zephir_read_property_cached(&level, this_ptr, _zephir_prop_0, 1215, PH_NOISY_CC); ZEPHIR_INIT_VAR(&prefixLevel); ZEPHIR_CONCAT_VV(&prefixLevel, &prefix, &level); zephir_memory_observe(&expr); @@ -1441,7 +1441,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileForeach) ZEPHIR_CALL_METHOD(&code, this_ptr, "statementList", NULL, 0, &blockStatements, &_8); zephir_check_call_status(); zephir_memory_observe(&loopContext); - zephir_read_property_cached(&loopContext, this_ptr, _zephir_prop_1, 1221, PH_NOISY_CC); + zephir_read_property_cached(&loopContext, this_ptr, _zephir_prop_1, 1222, PH_NOISY_CC); if (zephir_array_isset_value(&loopContext, &level)) { ZEPHIR_INIT_VAR(&_9$$11); ZEPHIR_CONCAT_SVSVS(&_9$$11, ""); RETURN_MM(); @@ -1837,7 +1837,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileMacro) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1223, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1224, 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); @@ -2309,7 +2309,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, 1220, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1221, &_0); if (extendsMode) { ZVAL_BOOL(&_1, 1); } else { @@ -2498,7 +2498,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, expression) ZEPHIR_INIT_VAR(&rightCode); ZVAL_STRING(&rightCode, ""); RETURN_ON_FAILURE(zephir_property_incr(this_ptr, SL("exprLevel"))); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1224, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1225, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extensions, &_0); while (1) { if (!(ZEPHIR_IS_EMPTY(&extensions))) { @@ -3042,7 +3042,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, 1224, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1225, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extensions, &_0); if (Z_TYPE_P(&extensions) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); @@ -3249,7 +3249,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", 1857); - zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_0, 1224, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_0, 1225, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extensions, &_1$$5); if (!(ZEPHIR_IS_EMPTY(&extensions))) { ZEPHIR_INIT_VAR(&_2$$6); @@ -3265,7 +3265,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, functionCall) RETURN_CCTOR(&code); } } - zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_1, 1225, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_1, 1226, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&functions, &_1$$5); if (Z_TYPE_P(&functions) == IS_ARRAY) { zephir_memory_observe(&definition); @@ -3313,10 +3313,10 @@ 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, 1226, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_12$$15, this_ptr, _zephir_prop_2, 1227, 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, 1227, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$16, this_ptr, _zephir_prop_3, 1228, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(¤tBlock, &_13$$16); _14$$16 = Z_TYPE_P(¤tBlock) != IS_NULL; if (_14$$16) { @@ -3324,7 +3324,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, functionCall) _14$$16 = zephir_array_isset_fetch(&block, &extendedBlocks, ¤tBlock, 0); } if (_14$$16) { - zephir_read_property_cached(&_15$$17, this_ptr, _zephir_prop_4, 1228, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_15$$17, this_ptr, _zephir_prop_4, 1229, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&exprLevel, &_15$$17); if (Z_TYPE_P(&block) == IS_ARRAY) { ZEPHIR_CALL_METHOD(&code, this_ptr, "statementListOrExtends", NULL, 0, &block); @@ -3388,10 +3388,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, 1215, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$5, this_ptr, _zephir_prop_5, 1216, PH_NOISY_CC | PH_READONLY); _18$$5 = Z_TYPE_P(&_1$$5) != IS_NULL; if (_18$$5) { - zephir_read_property_cached(&_19$$5, this_ptr, _zephir_prop_5, 1215, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19$$5, this_ptr, _zephir_prop_5, 1216, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_21$$5); ZVAL_STRING(&_21$$5, "tag"); ZEPHIR_CALL_METHOD(&_20$$5, &_19$$5, "has", NULL, 0, &_21$$5); @@ -3399,7 +3399,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, functionCall) _18$$5 = ZEPHIR_IS_TRUE_IDENTICAL(&_20$$5); } if (_18$$5) { - zephir_read_property_cached(&_22$$28, this_ptr, _zephir_prop_5, 1215, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$28, this_ptr, _zephir_prop_5, 1216, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_23$$28); ZVAL_STRING(&_23$$28, "tag"); ZEPHIR_CALL_METHOD(&tagService, &_22$$28, "get", NULL, 0, &_23$$28); @@ -3544,7 +3544,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, 1216, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1217, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&value, &_0, &option_zv, 0))) { RETURN_MM_NULL(); } @@ -3606,31 +3606,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, 1229, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1230, 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, 1220, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 1221, PH_NOISY_CC | PH_READONLY); zephir_unique_path_key(&_1$$3, &_2$$3); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1229, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1230, &_1$$3); } zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1229, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1230, 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, 1229, PH_NOISY_CC); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_0, 1230, 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, 1229, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$5, this_ptr, _zephir_prop_0, 1230, 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, 1229, &_5$$5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1230, &_5$$5); } } zephir_memory_observe(&_8); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 1229, PH_NOISY_CC); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 1230, 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); @@ -3806,7 +3806,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, 1215, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1216, container); } /** @@ -3841,7 +3841,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, setOption) zephir_update_property_array(this_ptr, SL("options"), &option_zv, value); ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1217, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1218, &_0); RETURN_THIS(); } @@ -3875,10 +3875,10 @@ 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, 1216, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1217, &options); ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1217, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1218, &_0); RETURN_THIS(); } @@ -3901,7 +3901,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, 1229, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1230, &prefix_zv); RETURN_THISW(); } @@ -4009,31 +4009,31 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileSource) } else { } if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1230, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1231, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1230, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1231, &__$false); } if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1226, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1227, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1226, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1227, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1231, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1232, &__$null); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1232, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1233, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1214, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1215, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1233, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1234, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, 0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1228, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_7, 1220, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1229, &_0); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_7, 1221, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(¤tPath, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_8, 1216, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_8, 1217, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); if (Z_TYPE_P(&options) == IS_ARRAY) { zephir_memory_observe(&autoescape); @@ -4051,7 +4051,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileSource) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1219, &autoescape); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1220, &autoescape); } } ZEPHIR_INIT_VAR(&intermediate); @@ -4073,7 +4073,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_0, 1230, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 1231, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extended, &_5); if (ZEPHIR_IS_TRUE_IDENTICAL(&extended)) { ZEPHIR_INIT_VAR(&finalCompilation); @@ -4082,9 +4082,9 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileSource) } else { ZVAL_NULL(&finalCompilation); } - zephir_read_property_cached(&_6$$7, this_ptr, _zephir_prop_2, 1231, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$7, this_ptr, _zephir_prop_2, 1232, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&blocks, &_6$$7); - zephir_read_property_cached(&_6$$7, this_ptr, _zephir_prop_1, 1226, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$7, this_ptr, _zephir_prop_1, 1227, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extendedBlocks, &_6$$7); if (Z_TYPE_P(&blocks) != IS_ARRAY) { ZEPHIR_INIT_NVAR(&blocks); @@ -4113,7 +4113,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", 2415); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 1227, &name); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 1228, &name); if (Z_TYPE_P(&localBlock) == IS_NULL) { ZEPHIR_INIT_NVAR(&localBlock); array_init(&localBlock); @@ -4165,7 +4165,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", 2415); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 1227, &name); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_10, 1228, &name); if (Z_TYPE_P(&localBlock) == IS_NULL) { ZEPHIR_INIT_NVAR(&localBlock); array_init(&localBlock); @@ -4199,7 +4199,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, compileSource) RETURN_CCTOR(&finalCompilation); } if (extendsMode) { - zephir_read_property_cached(&_14$$35, this_ptr, _zephir_prop_2, 1231, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$35, this_ptr, _zephir_prop_2, 1232, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&blocks, &_14$$35); if (Z_TYPE_P(&blocks) != IS_ARRAY) { ZEPHIR_INIT_NVAR(&blocks); @@ -4267,13 +4267,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, 1220, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 1221, 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, 1213, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1214, 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); @@ -4490,7 +4490,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, 1224, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 1225, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extensions, &_7); if (!(ZEPHIR_IS_EMPTY(&extensions))) { ZEPHIR_INIT_VAR(&_8$$9); @@ -4506,7 +4506,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, resolveFilter) RETURN_CCTOR(&code); } } - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 1234, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_1, 1235, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&filters, &_7); zephir_memory_observe(&definition); if (zephir_array_isset_fetch(&definition, &filters, &name, 0)) { @@ -4630,10 +4630,10 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, resolveFilter) RETURN_MM(); zephir_switch_0_clause_16: ; zephir_switch_0_clause_17: ; - zephir_read_property_cached(&_23$$30, this_ptr, _zephir_prop_2, 1215, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_23$$30, this_ptr, _zephir_prop_2, 1216, 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, 1215, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_25$$30, this_ptr, _zephir_prop_2, 1216, 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); @@ -4673,10 +4673,10 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, resolveFilter) RETURN_MM(); zephir_switch_0_clause_26: ; zephir_switch_0_clause_27: ; - zephir_read_property_cached(&_28$$41, this_ptr, _zephir_prop_2, 1215, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_28$$41, this_ptr, _zephir_prop_2, 1216, 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, 1215, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_30$$41, this_ptr, _zephir_prop_2, 1216, 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); @@ -4871,7 +4871,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, statementList) if (ZEPHIR_IS_EMPTY(&statements)) { RETURN_MM_STRING(""); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1230, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1231, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extended, &_0); _1 = zephir_is_true(&extended); if (!(_1)) { @@ -4915,7 +4915,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, statementList) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_1, 1224, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_1, 1225, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extensions, &_11$$5); if (!(ZEPHIR_IS_EMPTY(&extensions))) { ZEPHIR_INIT_NVAR(&_12$$8); @@ -5022,7 +5022,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", 2847); ZEPHIR_OBS_NVAR(&blockStatements); zephir_array_isset_string_fetch(&blockStatements, &statement, SL("block_statements"), 0); - zephir_read_property_cached(&_35$$20, this_ptr, _zephir_prop_2, 1231, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_35$$20, this_ptr, _zephir_prop_2, 1232, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&blocks, &_35$$20); if (zephir_is_true(&blockMode)) { if (Z_TYPE_P(&blocks) != IS_ARRAY) { @@ -5035,7 +5035,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, 1231, &blocks); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1232, &blocks); } else { if (Z_TYPE_P(&blockStatements) == IS_ARRAY) { if (extendsMode) { @@ -5071,11 +5071,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, 1230, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1231, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1230, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1231, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1226, &tempCompilation); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1227, &tempCompilation); ZEPHIR_CPY_WRT(&blockMode, &extended); goto zephir_switch_0_end; zephir_switch_0_clause_11: ; @@ -5196,7 +5196,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, statementList) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_75$$39, this_ptr, _zephir_prop_1, 1224, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_75$$39, this_ptr, _zephir_prop_1, 1225, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&extensions, &_75$$39); if (!(ZEPHIR_IS_EMPTY(&extensions))) { ZEPHIR_INIT_NVAR(&_76$$42); @@ -5303,7 +5303,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", 2847); ZEPHIR_OBS_NVAR(&blockStatements); zephir_array_isset_string_fetch(&blockStatements, &statement, SL("block_statements"), 0); - zephir_read_property_cached(&_91$$54, this_ptr, _zephir_prop_2, 1231, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_91$$54, this_ptr, _zephir_prop_2, 1232, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&blocks, &_91$$54); if (zephir_is_true(&blockMode)) { if (Z_TYPE_P(&blocks) != IS_ARRAY) { @@ -5316,7 +5316,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, 1231, &blocks); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1232, &blocks); } else { if (Z_TYPE_P(&blockStatements) == IS_ARRAY) { if (extendsMode) { @@ -5352,11 +5352,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, 1230, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1231, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1230, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1231, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1226, &tempCompilation); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1227, &tempCompilation); ZEPHIR_CPY_WRT(&blockMode, &extended); goto zephir_switch_1_end; zephir_switch_1_clause_11: ; @@ -5438,7 +5438,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, 1233, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&level, this_ptr, _zephir_prop_4, 1234, 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 5980c34ac0..aa532d04a8 100644 --- a/ext/phalcon/mvc/view/simple.zep.c +++ b/ext/phalcon/mvc/view/simple.zep.c @@ -156,13 +156,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, 1235, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1236, &options); ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1236, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1237, &_0); ZEPHIR_INIT_VAR(&_1); array_init(&_1); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1237, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1238, &_1); ZEPHIR_MM_RESTORE(); } @@ -198,7 +198,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, 1237, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1238, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&value, &_0, &key_zv, 0))) { RETURN_MM_NULL(); } @@ -331,7 +331,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, 1237, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1238, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&viewParams, &_0$$3); ZEPHIR_INIT_VAR(&mergedParams); zephir_fast_array_merge(&mergedParams, &viewParams, params); @@ -344,11 +344,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, 1237, &viewParams); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1238, &viewParams); } ZEPHIR_CALL_FUNCTION(NULL, "ob_end_clean", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1238, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1239, PH_NOISY_CC | PH_READONLY); zend_print_zval(&_2, 0); ZEPHIR_MM_RESTORE(); } @@ -390,7 +390,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, 1236, &engines); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1237, &engines); ZEPHIR_MM_RESTORE(); } @@ -444,7 +444,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, 1237, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1238, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&viewParams, &_1); ZEPHIR_INIT_VAR(&mergedParams); zephir_fast_array_merge(&mergedParams, &viewParams, ¶ms); @@ -475,7 +475,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, 1239, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1240, eventsManager); } /** @@ -559,11 +559,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, 1237, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1238, 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, 1237, ¶ms); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1238, ¶ms); RETURN_THIS(); } @@ -596,7 +596,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, 1240, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1241, &_0); ZEPHIR_MM_RESTORE(); } @@ -657,14 +657,14 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, loadTemplateEngines) ZEPHIR_INIT_VAR(&engineObject); ZVAL_NULL(&engineObject); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1241, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1242, 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, 1242, PH_NOISY_CC); + zephir_read_property_cached(&di, this_ptr, _zephir_prop_1, 1243, PH_NOISY_CC); ZEPHIR_INIT_NVAR(&engines); array_init(&engines); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 1236, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 1237, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(®isteredEngines, &_1$$3); if (ZEPHIR_IS_EMPTY(®isteredEngines)) { ZEPHIR_INIT_VAR(&_2$$4); @@ -781,9 +781,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, 1241, &engines); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1242, &engines); } else { - zephir_read_property_cached(&_22$$19, this_ptr, _zephir_prop_0, 1241, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_22$$19, this_ptr, _zephir_prop_0, 1242, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&engines, &_22$$19); } RETURN_CCTOR(&engines); @@ -876,10 +876,10 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, internalRender) zephir_get_strval(&path, path_param); ZEPHIR_INIT_VAR(&viewEnginePath); ZVAL_STRING(&viewEnginePath, ""); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1239, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1240, 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, 1243, &path); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1244, &path); } if (Z_TYPE_P(&eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_2$$4); @@ -937,7 +937,7 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, internalRender) ZEPHIR_INIT_NVAR(&segment); ZEPHIR_INIT_NVAR(&path); zephir_fast_join_str(&path, SL("/"), &segments); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1240, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_2, 1241, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_13); ZEPHIR_CONCAT_VV(&_13, &_0, &path); zephir_get_strval(&viewsDirPath, &_13); @@ -1699,7 +1699,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, 1237, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1238, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } @@ -1726,7 +1726,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, 1236, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1237, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } @@ -1759,7 +1759,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, 1237, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1238, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&value, &_0, &key_zv, 0))) { RETURN_MM_NULL(); } @@ -1791,7 +1791,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, 1238, &content_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1239, &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 9b425ace42..a993fc5a07 100644 --- a/ext/phalcon/mvc/view/traits/viewparamstrait.zep.c +++ b/ext/phalcon/mvc/view/traits/viewparamstrait.zep.c @@ -93,7 +93,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, 1244, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1245, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } @@ -120,7 +120,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, 1245, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1246, PH_NOISY_CC); zephir_get_arrval(&_1, &_0); RETURN_CTOR(&_1); } @@ -153,7 +153,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, 1244, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1245, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&value, &_0, &key_zv, 0))) { RETURN_MM_NULL(); } @@ -185,7 +185,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, 1246, &content_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1247, &content_zv); RETURN_THISW(); } diff --git a/ext/phalcon/paginator/adapter/model.zep.c b/ext/phalcon/paginator/adapter/model.zep.c index fea3cc6e4a..60918b88af 100644 --- a/ext/phalcon/paginator/adapter/model.zep.c +++ b/ext/phalcon/paginator/adapter/model.zep.c @@ -188,12 +188,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, 1247, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1248, PH_NOISY_CC); limit = zephir_get_intval(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1248, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1249, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&config, &_1); zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1249, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1250, PH_NOISY_CC); pageNumber = zephir_get_intval(&_2); zephir_memory_observe(&_3); zephir_array_fetch_string(&_3, &config, SL("model"), PH_NOISY, "phalcon/Paginator/Adapter/Model.zep", 117); @@ -272,7 +272,7 @@ PHP_METHOD(Phalcon_Paginator_Adapter_Model, paginate) ZVAL_LONG(&_7, rowcount); zephir_array_update_string(&_18, SL("total_items"), &_7, PH_COPY | PH_SEPARATE); ZEPHIR_OBS_NVAR(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1247, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1248, PH_NOISY_CC); zephir_array_update_string(&_18, SL("limit"), &_3, PH_COPY | PH_SEPARATE); add_assoc_long_ex(&_18, SL("first"), 1); ZEPHIR_INIT_NVAR(&_7); diff --git a/ext/phalcon/paginator/adapter/nativearray.zep.c b/ext/phalcon/paginator/adapter/nativearray.zep.c index 5a12340945..b2d19a12ef 100644 --- a/ext/phalcon/paginator/adapter/nativearray.zep.c +++ b/ext/phalcon/paginator/adapter/nativearray.zep.c @@ -95,7 +95,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, 1250, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1251, 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", 49); @@ -109,10 +109,10 @@ PHP_METHOD(Phalcon_Paginator_Adapter_NativeArray, paginate) return; } zephir_memory_observe(&_2); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1251, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1252, PH_NOISY_CC); show = zephir_get_intval(&_2); zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1252, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1253, 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, 1251, PH_NOISY_CC); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1252, 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 c74fffd12a..5120e86fdf 100644 --- a/ext/phalcon/paginator/adapter/querybuilder.zep.c +++ b/ext/phalcon/paginator/adapter/querybuilder.zep.c @@ -140,7 +140,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, 1253, &columns); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1254, &columns); } ZEPHIR_CALL_PARENT(NULL, phalcon_paginator_adapter_querybuilder_ce, getThis(), "__construct", NULL, 0, &config); zephir_check_call_status(); @@ -270,8 +270,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, 1254, PH_NOISY_CC); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1253, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&originalBuilder, this_ptr, _zephir_prop_0, 1255, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1254, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&columns, &_0); hasMultipleGroups = 0; ZEPHIR_INIT_VAR(&builder); @@ -283,9 +283,9 @@ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilder, paginate) RETURN_MM(); } zephir_memory_observe(&limit); - zephir_read_property_cached(&limit, this_ptr, _zephir_prop_2, 1255, PH_NOISY_CC); + zephir_read_property_cached(&limit, this_ptr, _zephir_prop_2, 1256, PH_NOISY_CC); zephir_memory_observe(&_1); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1256, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_3, 1257, PH_NOISY_CC); numberPage = zephir_get_intval(&_1); if (!(numberPage)) { numberPage = 1; @@ -518,7 +518,7 @@ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilder, paginate) zephir_array_update_string(&_44, SL("items"), &items, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_44, SL("total_items"), &rowcount, PH_COPY | PH_SEPARATE); zephir_memory_observe(&_45); - zephir_read_property_cached(&_45, this_ptr, _zephir_prop_2, 1255, PH_NOISY_CC); + zephir_read_property_cached(&_45, this_ptr, _zephir_prop_2, 1256, PH_NOISY_CC); zephir_array_update_string(&_44, SL("limit"), &_45, PH_COPY | PH_SEPARATE); add_assoc_long_ex(&_44, SL("first"), 1); ZEPHIR_INIT_VAR(&_46); @@ -552,7 +552,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, 1254, builder); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1255, builder); RETURN_THISW(); } diff --git a/ext/phalcon/paginator/adapter/querybuildercursor.zep.c b/ext/phalcon/paginator/adapter/querybuildercursor.zep.c index 35c68c7f0b..bb587bce28 100644 --- a/ext/phalcon/paginator/adapter/querybuildercursor.zep.c +++ b/ext/phalcon/paginator/adapter/querybuildercursor.zep.c @@ -181,10 +181,10 @@ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilderCursor, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1257, &cursorColumn); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1258, &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, 1258, &cursor); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1259, &cursor); } ZEPHIR_CALL_PARENT(NULL, phalcon_paginator_adapter_querybuildercursor_ce, getThis(), "__construct", NULL, 0, &config); zephir_check_call_status(); @@ -214,12 +214,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, 1258, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1259, 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, 1258, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1259, PH_NOISY_CC); RETURN_MM_LONG(zephir_get_intval(&_1)); } @@ -305,24 +305,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, 1259, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1260, 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, 1260, PH_NOISY_CC); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1261, PH_NOISY_CC); limit = zephir_get_intval(&_2); zephir_memory_observe(¤tCursor); - zephir_read_property_cached(¤tCursor, this_ptr, _zephir_prop_2, 1258, PH_NOISY_CC); + zephir_read_property_cached(¤tCursor, this_ptr, _zephir_prop_2, 1259, 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, 1257, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$5, this_ptr, _zephir_prop_3, 1258, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_4$$5); ZEPHIR_CONCAT_SVS(&_4$$5, "[", &_3$$5, "] > :cursor:"); ZEPHIR_INIT_VAR(&_5$$5); @@ -349,7 +349,7 @@ PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilderCursor, paginate) zephir_array_fetch_long(&lastItem, &items, (zephir_fast_count_int(&items) - 1), PH_NOISY, "phalcon/Paginator/Adapter/QueryBuilderCursor.zep", 217); zephir_memory_observe(&_7$$6); zephir_memory_observe(&_8$$6); - zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_3, 1257, PH_NOISY_CC); + zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_3, 1258, PH_NOISY_CC); zephir_array_fetch(&_7$$6, &lastItem, &_8$$6, PH_NOISY, "phalcon/Paginator/Adapter/QueryBuilderCursor.zep", 223); if (UNEXPECTED(!(zephir_is_numeric(&_7$$6)))) { ZEPHIR_INIT_VAR(&_9$$7); @@ -362,7 +362,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, 1257, PH_NOISY_CC); + zephir_read_property_cached(&_11$$6, this_ptr, _zephir_prop_3, 1258, PH_NOISY_CC); zephir_array_fetch(&_10$$6, &lastItem, &_11$$6, PH_NOISY, "phalcon/Paginator/Adapter/QueryBuilderCursor.zep", 227); nextCursor = zephir_get_intval(&_10$$6); } else { @@ -373,7 +373,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, 1260, PH_NOISY_CC); + zephir_read_property_cached(&_13, this_ptr, _zephir_prop_1, 1261, 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); @@ -410,7 +410,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, 1258, cursor); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1259, cursor); RETURN_THISW(); } @@ -432,7 +432,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, 1259, builder); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1260, builder); RETURN_THISW(); } diff --git a/ext/phalcon/paginator/exceptions/missingrequiredparameter.zep.c b/ext/phalcon/paginator/exceptions/missingrequiredparameter.zep.c index 28b0eaa37a..1b3ef910e4 100644 --- a/ext/phalcon/paginator/exceptions/missingrequiredparameter.zep.c +++ b/ext/phalcon/paginator/exceptions/missingrequiredparameter.zep.c @@ -62,7 +62,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, 1261, ¶meter_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1262, ¶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 22b5bd1aa5..f744011a08 100644 --- a/ext/phalcon/paginator/repository.zep.c +++ b/ext/phalcon/paginator/repository.zep.c @@ -305,7 +305,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, 1262, &aliases); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1263, &aliases); RETURN_THIS(); } @@ -332,7 +332,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, 1263, &properties); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1264, &properties); RETURN_THIS(); } @@ -380,7 +380,7 @@ PHP_METHOD(Phalcon_Paginator_Repository, getProperty) defaultValue = &__$null; } zephir_memory_observe(&value); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1263, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1264, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&value, &_0, &property_zv, 0))) { ZEPHIR_CPY_WRT(&value, defaultValue); } @@ -413,7 +413,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, 1262, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1263, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_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 bd5f62f144..5be8244468 100644 --- a/ext/phalcon/queue/adapter/beanstalk/beanstalkconnection.zep.c +++ b/ext/phalcon/queue/adapter/beanstalk/beanstalkconnection.zep.c @@ -163,19 +163,19 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, __construct) persistent = 0; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1264, &host_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1265, &host_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, port); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1265, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1266, &_0); if (persistent) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1266, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1267, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1266, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1267, &__$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, 1267, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1268, &_1); ZEPHIR_MM_RESTORE(); } @@ -260,7 +260,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, 1268, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1269, 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); @@ -269,10 +269,10 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, connect) ZVAL_LONG(&_0, 0); ZEPHIR_CALL_FUNCTION(&errorLevel, "error_reporting", NULL, 308, &_0); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1266, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1267, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_0)) { - zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_2, 1264, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 1265, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_2, 1265, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_3, 1266, PH_NOISY_CC | PH_READONLY); ZVAL_NULL(&_3$$4); ZVAL_NULL(&_4$$4); ZEPHIR_MAKE_REF(&_3$$4); @@ -282,8 +282,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, 1264, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6$$5, this_ptr, _zephir_prop_3, 1265, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_2, 1265, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$5, this_ptr, _zephir_prop_3, 1266, PH_NOISY_CC | PH_READONLY); ZVAL_NULL(&_7$$5); ZVAL_NULL(&_8$$5); ZEPHIR_MAKE_REF(&_7$$5); @@ -303,7 +303,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, 1268, &connection); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1269, &connection); ZEPHIR_CALL_METHOD(NULL, this_ptr, "restoreSession", NULL, 0); zephir_check_call_status(); RETURN_CCTOR(&connection); @@ -363,14 +363,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, 1268, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1269, 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, 1268, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1269, &__$null); RETURN_MM_BOOL(1); } @@ -520,7 +520,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, read) length = 0; } else { } - 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, 1269, 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); @@ -847,7 +847,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, useTube) zephir_array_fetch_long(&_2, &_1, 0, PH_NOISY, "phalcon/Queue/Adapter/Beanstalk/BeanstalkConnection.zep", 348); result = ZEPHIR_IS_STRING(&_2, "USING"); if (result) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1269, &tube_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1270, &tube_zv); } RETURN_MM_BOOL(result); } @@ -923,7 +923,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, 1268, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1269, 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); @@ -1106,9 +1106,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, 1269, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1270, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_STRING(&_0, "default")) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1269, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1270, 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); @@ -1117,7 +1117,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, 1267, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1268, PH_NOISY_CC | PH_READONLY); zephir_array_keys(&_3, &_4); if (Z_TYPE_P(&_3) == IS_STRING) { ZEPHIR_INIT_VAR(&_6); @@ -1141,7 +1141,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConnection, restoreSession) } } ZEND_HASH_FOREACH_END(); ZEPHIR_INIT_NVAR(&tube); - zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1267, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_1, 1268, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_value_string(&_9, SL("default")))) { ZEPHIR_INIT_VAR(&_10$$6); ZVAL_STRING(&_10$$6, "ignore default"); diff --git a/ext/phalcon/queue/adapter/beanstalk/beanstalkconnectionfactory.zep.c b/ext/phalcon/queue/adapter/beanstalk/beanstalkconnectionfactory.zep.c index b0e3786f16..68d3590920 100644 --- a/ext/phalcon/queue/adapter/beanstalk/beanstalkconnectionfactory.zep.c +++ b/ext/phalcon/queue/adapter/beanstalk/beanstalkconnectionfactory.zep.c @@ -94,7 +94,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, 1270, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1271, &options); ZEPHIR_MM_RESTORE(); } @@ -122,7 +122,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, 1270, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1271, 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 be86934fda..51c0885609 100644 --- a/ext/phalcon/queue/adapter/beanstalk/beanstalkconsumer.zep.c +++ b/ext/phalcon/queue/adapter/beanstalk/beanstalkconsumer.zep.c @@ -91,8 +91,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, 1271, connection); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1272, queue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1272, connection); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1273, queue); ZEPHIR_CALL_METHOD(&tube, queue, "getQueueName", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, connection, "watchTube", NULL, 0, &tube); @@ -127,7 +127,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, 1271, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1272, 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); @@ -170,7 +170,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkConsumer, receive) zephir_div_long_long(&_0$$4, ((timeout + 999)), 1000); ZVAL_LONG(&seconds, zephir_get_intval(&_0$$4)); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1271, 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, "reserve", NULL, 0, &seconds); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "buildMessage", NULL, 0, &_2); @@ -195,7 +195,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, 1271, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1272, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2, 0); ZEPHIR_CALL_METHOD(&_1, &_0, "reserve", NULL, 0, &_2); zephir_check_call_status(); @@ -239,13 +239,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, 1271, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1272, 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, 1271, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 1272, 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(); @@ -277,7 +277,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, 1271, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1272, 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 fac116f390..4a14a42cd8 100644 --- a/ext/phalcon/queue/adapter/beanstalk/beanstalkcontext.zep.c +++ b/ext/phalcon/queue/adapter/beanstalk/beanstalkcontext.zep.c @@ -154,21 +154,21 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkContext, __construct) pollInterval = 200; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1273, &host_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1274, &host_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, port); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1274, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1275, &_0); if (persistent) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1275, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1276, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1275, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1276, &__$false); } ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, ttr); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1276, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1277, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1277, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1278, &_0); } PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkContext, close) @@ -188,12 +188,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, 1278, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1279, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1278, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1279, 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, 1278, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1279, &__$null); } ZEPHIR_MM_RESTORE(); } @@ -307,7 +307,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, 1277, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1278, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, this_ptr, &_0); zephir_check_call_status(); RETURN_MM(); @@ -489,11 +489,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, 1278, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1279, 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, 1278, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1279, &_1$$3); } RETURN_MM_MEMBER(getThis(), "connection"); } @@ -529,9 +529,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, 1273, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1274, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1275, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1274, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1275, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1276, 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 e7c32e6ea0..7eee20be16 100644 --- a/ext/phalcon/queue/adapter/beanstalk/beanstalkmessage.zep.c +++ b/ext/phalcon/queue/adapter/beanstalk/beanstalkmessage.zep.c @@ -75,6 +75,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, 1279, &jobId_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1280, &jobId_zv); } diff --git a/ext/phalcon/queue/adapter/beanstalk/beanstalkproducer.zep.c b/ext/phalcon/queue/adapter/beanstalk/beanstalkproducer.zep.c index c38f704313..e825104687 100644 --- a/ext/phalcon/queue/adapter/beanstalk/beanstalkproducer.zep.c +++ b/ext/phalcon/queue/adapter/beanstalk/beanstalkproducer.zep.c @@ -94,7 +94,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, 1280, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1281, context); } PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkProducer, getDeliveryDelay) @@ -159,34 +159,34 @@ 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, 1281, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1282, 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, 1281, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1282, PH_NOISY_CC); ZEPHIR_INIT_NVAR(&_1); ZVAL_LONG(&_1, zephir_get_intval(&_3)); } priority = zephir_get_intval(&_1); ZEPHIR_INIT_VAR(&_4); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 1282, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 1283, 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, 1282, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 1283, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_7); zephir_div_zval_long(&_7, &_6, 1000); ZEPHIR_INIT_NVAR(&_4); ZVAL_LONG(&_4, zephir_get_intval(&_7)); } delay = zephir_get_intval(&_4); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 1280, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_2, 1281, 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, 1280, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_2, 1281, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_10, &_9, "getTtr", NULL, 0); zephir_check_call_status(); ZVAL_LONG(&_11, priority); @@ -230,7 +230,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, 1282, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1283, &_0); RETURN_THIS(); } @@ -268,7 +268,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, 1281, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1282, &_0); RETURN_THIS(); } diff --git a/ext/phalcon/queue/adapter/beanstalk/beanstalksubscriptionconsumer.zep.c b/ext/phalcon/queue/adapter/beanstalk/beanstalksubscriptionconsumer.zep.c index 02f1649f6c..69e63b63cd 100644 --- a/ext/phalcon/queue/adapter/beanstalk/beanstalksubscriptionconsumer.zep.c +++ b/ext/phalcon/queue/adapter/beanstalk/beanstalksubscriptionconsumer.zep.c @@ -82,9 +82,9 @@ PHP_METHOD(Phalcon_Queue_Adapter_Beanstalk_BeanstalkSubscriptionConsumer, __cons pollInterval = 200; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1283, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1284, context); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1284, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1285, &_0); } diff --git a/ext/phalcon/queue/adapter/genericqueue.zep.c b/ext/phalcon/queue/adapter/genericqueue.zep.c index 7318c60fc3..174d0c4876 100644 --- a/ext/phalcon/queue/adapter/genericqueue.zep.c +++ b/ext/phalcon/queue/adapter/genericqueue.zep.c @@ -70,7 +70,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, 1285, &queueName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1286, &queueName_zv); } /** diff --git a/ext/phalcon/queue/adapter/generictopic.zep.c b/ext/phalcon/queue/adapter/generictopic.zep.c index 72f4b901cb..80153ad998 100644 --- a/ext/phalcon/queue/adapter/generictopic.zep.c +++ b/ext/phalcon/queue/adapter/generictopic.zep.c @@ -70,7 +70,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, 1286, &topicName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1287, &topicName_zv); } /** diff --git a/ext/phalcon/queue/adapter/memory/memoryconnectionfactory.zep.c b/ext/phalcon/queue/adapter/memory/memoryconnectionfactory.zep.c index 384d83e635..da0afa2bfc 100644 --- a/ext/phalcon/queue/adapter/memory/memoryconnectionfactory.zep.c +++ b/ext/phalcon/queue/adapter/memory/memoryconnectionfactory.zep.c @@ -88,7 +88,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, 1287, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1288, &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 ffa8ee0299..05427b9b97 100644 --- a/ext/phalcon/queue/adapter/memory/memoryconsumer.zep.c +++ b/ext/phalcon/queue/adapter/memory/memoryconsumer.zep.c @@ -76,8 +76,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, 1288, context); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1289, queue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1289, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1290, queue); } /** @@ -118,8 +118,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, 1288, 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, 1289, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1290, 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); @@ -164,8 +164,8 @@ PHP_METHOD(Phalcon_Queue_Adapter_Memory_MemoryConsumer, reject) } else { } if (requeue) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1288, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1289, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1289, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1290, 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 282d9eb764..c35d79f272 100644 --- a/ext/phalcon/queue/adapter/memory/memorycontext.zep.c +++ b/ext/phalcon/queue/adapter/memory/memorycontext.zep.c @@ -78,7 +78,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, 1290, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1291, &_0); ZEPHIR_MM_RESTORE(); } @@ -227,7 +227,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, 1290, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1291, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&messages, &_0, &queueName_zv, 0))) { RETURN_MM_NULL(); } @@ -299,7 +299,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, 1290, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1291, 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 d13b1041ce..4ab214a868 100644 --- a/ext/phalcon/queue/adapter/memory/memoryproducer.zep.c +++ b/ext/phalcon/queue/adapter/memory/memoryproducer.zep.c @@ -67,7 +67,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, 1291, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1292, context); } PHP_METHOD(Phalcon_Queue_Adapter_Memory_MemoryProducer, send) @@ -98,7 +98,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, 1291, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1292, 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 a7f1b8cc5d..444e5c0368 100644 --- a/ext/phalcon/queue/adapter/memory/memorysubscriptionconsumer.zep.c +++ b/ext/phalcon/queue/adapter/memory/memorysubscriptionconsumer.zep.c @@ -69,6 +69,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, 1292, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1293, context); } diff --git a/ext/phalcon/queue/adapter/redis/redisconnectionfactory.zep.c b/ext/phalcon/queue/adapter/redis/redisconnectionfactory.zep.c index 02ed0b2fa2..c5313dee2f 100644 --- a/ext/phalcon/queue/adapter/redis/redisconnectionfactory.zep.c +++ b/ext/phalcon/queue/adapter/redis/redisconnectionfactory.zep.c @@ -102,7 +102,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, 1293, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1294, &options); ZEPHIR_MM_RESTORE(); } @@ -137,7 +137,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, 1293, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1294, 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 6217e8f91d..f97b6bcfec 100644 --- a/ext/phalcon/queue/adapter/redis/redisconsumer.zep.c +++ b/ext/phalcon/queue/adapter/redis/redisconsumer.zep.c @@ -75,8 +75,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, 1294, context); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1295, queue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1295, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1296, queue); } /** @@ -133,7 +133,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisConsumer, receive) timeout = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1295, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1296, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&queueName, &_0, "getQueueName", NULL, 0); zephir_check_call_status(); deadline = 0; @@ -147,7 +147,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisConsumer, receive) deadline = (zephir_get_intval(&_3$$3) + timeout); } while (1) { - zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_1, 1294, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_1, 1295, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_5$$4, 1); ZEPHIR_CALL_METHOD(&message, &_4$$4, "blockingPop", NULL, 0, &queueName, &_5$$4); zephir_check_call_status(); @@ -192,8 +192,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, 1294, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1295, 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, 1296, 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); @@ -235,8 +235,8 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisConsumer, reject) } else { } if (requeue) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1294, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1295, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1295, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1296, 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 cd44e7f3b6..0a387da602 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, 1296, redis); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1297, &prefix_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1297, redis); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1298, &prefix_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1298, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1299, &_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, 1296, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1297, 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); @@ -299,7 +299,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, 1298, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1299, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, this_ptr, &_0); zephir_check_call_status(); RETURN_MM(); @@ -337,7 +337,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, 1296, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1297, 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); @@ -380,12 +380,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, 1296, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1297, 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, 1296, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1297, 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); @@ -459,7 +459,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, pushMessage) zephir_check_call_status(); ZEPHIR_INIT_VAR(&member); ZEPHIR_CONCAT_VSV(&member, &_0$$3, "|", &payload); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 1296, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 1297, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5$$3, this_ptr, "delayedKey", NULL, 0, &queueName_zv); zephir_check_call_status(); ZVAL_LONG(&_6$$3, score); @@ -467,7 +467,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, pushMessage) zephir_check_call_status(); RETURN_MM_NULL(); } - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 1296, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_0, 1297, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_8, this_ptr, "listKey", NULL, 0, &queueName_zv); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_7, "lPush", NULL, 0, &_8, &payload); @@ -528,7 +528,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, 1297, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1298, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_VVS(return_value, &_0, &queueName_zv, ":delayed"); return; } @@ -550,7 +550,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, 1297, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1298, PH_NOISY_CC | PH_READONLY); ZEPHIR_CONCAT_VV(return_value, &_0, &queueName_zv); return; } @@ -630,7 +630,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, 1296, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1297, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "now", NULL, 0); zephir_check_call_status(); ZVAL_LONG(&_2, 0); @@ -652,7 +652,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, promote) { ZEPHIR_INIT_NVAR(&member); ZVAL_COPY(&member, _5); - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_0, 1296, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_0, 1297, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_7$$4, &_6$$4, "zRem", NULL, 0, &delayedKey, &member); zephir_check_call_status(); if (ZEPHIR_GT_LONG(&_7$$4, 0)) { @@ -666,7 +666,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, promote) zephir_add_function(&_10$$5, &position, &_9$$5); ZEPHIR_INIT_NVAR(&payload); zephir_substr(&payload, &member, zephir_get_intval(&_10$$5), 0, ZEPHIR_SUBSTR_NO_LENGTH); - zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_0, 1296, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$5, this_ptr, _zephir_prop_0, 1297, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_11$$5, "lPush", NULL, 0, &listKey, &payload); zephir_check_call_status(); } @@ -689,7 +689,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, promote) } ZEPHIR_CALL_METHOD(&member, _3, "current", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_14$$6, this_ptr, _zephir_prop_0, 1296, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$6, this_ptr, _zephir_prop_0, 1297, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_15$$6, &_14$$6, "zRem", NULL, 0, &delayedKey, &member); zephir_check_call_status(); if (ZEPHIR_GT_LONG(&_15$$6, 0)) { @@ -703,7 +703,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisContext, promote) zephir_add_function(&_18$$7, &position, &_17$$7); ZEPHIR_INIT_NVAR(&payload); zephir_substr(&payload, &member, zephir_get_intval(&_18$$7), 0, ZEPHIR_SUBSTR_NO_LENGTH); - zephir_read_property_cached(&_19$$7, this_ptr, _zephir_prop_0, 1296, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_19$$7, this_ptr, _zephir_prop_0, 1297, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_19$$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 2297176bdb..ed6164ec53 100644 --- a/ext/phalcon/queue/adapter/redis/redisproducer.zep.c +++ b/ext/phalcon/queue/adapter/redis/redisproducer.zep.c @@ -77,7 +77,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, 1299, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1300, context); } PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisProducer, getDeliveryDelay) @@ -123,18 +123,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, 1300, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1301, 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, 1300, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1301, PH_NOISY_CC); ZEPHIR_INIT_NVAR(&_1); ZVAL_LONG(&_1, zephir_get_intval(&_3)); } delay = zephir_get_intval(&_1); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1299, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_1, 1300, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5, destination, "getQueueName", NULL, 0); zephir_check_call_status(); ZVAL_LONG(&_6, delay); @@ -177,7 +177,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, 1300, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1301, &_0); RETURN_THIS(); } diff --git a/ext/phalcon/queue/adapter/redis/redissubscriptionconsumer.zep.c b/ext/phalcon/queue/adapter/redis/redissubscriptionconsumer.zep.c index 72c31fec02..fa0bbb9098 100644 --- a/ext/phalcon/queue/adapter/redis/redissubscriptionconsumer.zep.c +++ b/ext/phalcon/queue/adapter/redis/redissubscriptionconsumer.zep.c @@ -82,9 +82,9 @@ PHP_METHOD(Phalcon_Queue_Adapter_Redis_RedisSubscriptionConsumer, __construct) pollInterval = 200; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1301, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1302, context); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1302, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1303, &_0); } diff --git a/ext/phalcon/queue/adapter/stream/streamconnectionfactory.zep.c b/ext/phalcon/queue/adapter/stream/streamconnectionfactory.zep.c index 901fde583a..450d14ee11 100644 --- a/ext/phalcon/queue/adapter/stream/streamconnectionfactory.zep.c +++ b/ext/phalcon/queue/adapter/stream/streamconnectionfactory.zep.c @@ -92,7 +92,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, 1303, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1304, &options); ZEPHIR_MM_RESTORE(); } @@ -119,16 +119,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, 1303, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1304, 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, 1303, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1304, 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", 58); } pollInterval = 200; - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1303, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1304, 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, 1303, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 1304, 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", 64); 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 cc65dfa561..7fc5ebce74 100644 --- a/ext/phalcon/queue/adapter/stream/streamconsumer.zep.c +++ b/ext/phalcon/queue/adapter/stream/streamconsumer.zep.c @@ -85,11 +85,11 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamConsumer, __construct) pollInterval = 200; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1304, context); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1305, queue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1305, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1306, queue); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1306, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1307, &_0); } /** @@ -127,8 +127,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, 1304, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1305, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1305, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1306, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "getQueueName", NULL, 0); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(&_0, "popMessage", NULL, 0, &_2); @@ -170,8 +170,8 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamConsumer, reject) } else { } if (requeue) { - zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1304, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1305, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0$$3, this_ptr, _zephir_prop_0, 1305, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 1306, 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 cfbb5377fa..1df9c5d71d 100644 --- a/ext/phalcon/queue/adapter/stream/streamcontext.zep.c +++ b/ext/phalcon/queue/adapter/stream/streamcontext.zep.c @@ -114,10 +114,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, 1307, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1308, &_2); ZVAL_UNDEF(&_3); ZVAL_LONG(&_3, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1308, &_3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1309, &_3); ZEPHIR_MM_RESTORE(); } @@ -152,7 +152,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, 1308, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1309, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, this_ptr, destination, &_1); zephir_check_call_status(); RETURN_MM(); @@ -239,7 +239,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, 1308, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1309, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0, this_ptr, &_0); zephir_check_call_status(); RETURN_MM(); @@ -467,14 +467,14 @@ 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(&_1, this_ptr, _zephir_prop_0, 1307, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1308, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_0, this_ptr, "phpIsDir", NULL, 0, &_1); zephir_check_call_status(); if (!(zephir_is_true(&_0))) { ZVAL_LONG(&_2$$3, 0); ZEPHIR_CALL_FUNCTION(&errorLevel, "error_reporting", NULL, 308, &_2$$3); zephir_check_call_status(); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 1307, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 1308, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_3$$3, 0777); ZVAL_BOOL(&_4$$3, 1); ZEPHIR_CALL_METHOD(NULL, this_ptr, "phpMkdir", NULL, 0, &_2$$3, &_3$$3, &_4$$3); @@ -512,7 +512,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, 1307, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1308, 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 52ea3842f6..5e7cd8e319 100644 --- a/ext/phalcon/queue/adapter/stream/streamproducer.zep.c +++ b/ext/phalcon/queue/adapter/stream/streamproducer.zep.c @@ -70,7 +70,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, 1309, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1310, context); } PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamProducer, send) @@ -101,7 +101,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, 1309, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1310, 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 d653ae2b7e..eab374c9aa 100644 --- a/ext/phalcon/queue/adapter/stream/streamsubscriptionconsumer.zep.c +++ b/ext/phalcon/queue/adapter/stream/streamsubscriptionconsumer.zep.c @@ -82,9 +82,9 @@ PHP_METHOD(Phalcon_Queue_Adapter_Stream_StreamSubscriptionConsumer, __construct) pollInterval = 200; } else { } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1310, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1311, context); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, pollInterval); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1311, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1312, &_0); } diff --git a/ext/phalcon/queue/adapter/traits/messagetrait.zep.c b/ext/phalcon/queue/adapter/traits/messagetrait.zep.c index b82bed1ae2..099b539bc7 100644 --- a/ext/phalcon/queue/adapter/traits/messagetrait.zep.c +++ b/ext/phalcon/queue/adapter/traits/messagetrait.zep.c @@ -148,9 +148,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, 1312, &body_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1313, &properties); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1314, &headers); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1313, &body_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1314, &properties); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1315, &headers); ZEPHIR_MM_RESTORE(); } @@ -222,9 +222,9 @@ PHP_METHOD(Phalcon_Queue_Adapter_Traits_MessageTrait, getHeader) defaultValue = &defaultValue_sub; defaultValue = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1314, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1315, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_0, &name_zv)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1314, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1315, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2$$3); zephir_array_fetch(&_2$$3, &_1$$3, &name_zv, PH_NOISY, "phalcon/Queue/Adapter/Traits/MessageTrait.zep", 83); RETURN_CCTOR(&_2$$3); @@ -314,9 +314,9 @@ PHP_METHOD(Phalcon_Queue_Adapter_Traits_MessageTrait, getProperty) defaultValue = &defaultValue_sub; defaultValue = &__$null; } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1313, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1314, PH_NOISY_CC | PH_READONLY); if (zephir_array_key_exists(&_0, &name_zv)) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1313, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 1314, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_2$$3); zephir_array_fetch(&_2$$3, &_1$$3, &name_zv, PH_NOISY, "phalcon/Queue/Adapter/Traits/MessageTrait.zep", 123); RETURN_CCTOR(&_2$$3); @@ -399,7 +399,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, 1312, &body_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1313, &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, 1314, &headers); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1315, &headers); ZEPHIR_MM_RESTORE(); } @@ -530,7 +530,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, 1313, &properties); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1314, &properties); ZEPHIR_MM_RESTORE(); } @@ -575,9 +575,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, 1315, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1316, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1315, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1316, &__$false); } } diff --git a/ext/phalcon/queue/adapter/traits/subscriptionconsumertrait.zep.c b/ext/phalcon/queue/adapter/traits/subscriptionconsumertrait.zep.c index 712e03e6a0..4286bd1713 100644 --- a/ext/phalcon/queue/adapter/traits/subscriptionconsumertrait.zep.c +++ b/ext/phalcon/queue/adapter/traits/subscriptionconsumertrait.zep.c @@ -127,11 +127,11 @@ PHP_METHOD(Phalcon_Queue_Adapter_Traits_SubscriptionConsumerTrait, consume) timeout = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1316, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1317, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_EMPTY(&_0)) { RETURN_MM_NULL(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1317, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1318, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); ZVAL_LONG(&_2, 1000); ZEPHIR_INIT_VAR(&_3); @@ -146,7 +146,7 @@ PHP_METHOD(Phalcon_Queue_Adapter_Traits_SubscriptionConsumerTrait, consume) startTime = zephir_get_intval(&_5); while (1) { ZEPHIR_OBS_NVAR(&_6$$4); - zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_0, 1316, PH_NOISY_CC); + zephir_read_property_cached(&_6$$4, this_ptr, _zephir_prop_0, 1317, PH_NOISY_CC); zephir_get_arrval(&_7$$4, &_6$$4); zephir_is_iterable(&_7$$4, 0, "phalcon/Queue/Adapter/Traits/SubscriptionConsumerTrait.zep", 78); if (Z_TYPE_P(&_7$$4) == IS_ARRAY) { @@ -296,7 +296,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, 1316, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1317, &_0); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/queue/consumer/boundprocessor.zep.c b/ext/phalcon/queue/consumer/boundprocessor.zep.c index b1422517ba..c1af5bbb87 100644 --- a/ext/phalcon/queue/consumer/boundprocessor.zep.c +++ b/ext/phalcon/queue/consumer/boundprocessor.zep.c @@ -88,9 +88,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, 1318, queue); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1319, processor); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1320, consumer); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1319, queue); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1320, processor); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1321, 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 44fa69c259..2efe9f042a 100644 --- a/ext/phalcon/queue/consumer/queueconsumer.zep.c +++ b/ext/phalcon/queue/consumer/queueconsumer.zep.c @@ -100,7 +100,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, 1321, context); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1322, context); } /** @@ -133,7 +133,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, 1321, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1322, 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); @@ -197,7 +197,7 @@ PHP_METHOD(Phalcon_Queue_Consumer_QueueConsumer, consume) while (1) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "consumeOnce", &_4, 0); zephir_check_call_status(); - zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 1322, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_0, 1323, PH_NOISY_CC | PH_READONLY); if (zephir_is_true(&_5$$4)) { break; } @@ -267,7 +267,7 @@ PHP_METHOD(Phalcon_Queue_Consumer_QueueConsumer, consumeOnce) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); processed = 0; - 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, 1324, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_STRING) { ZEPHIR_INIT_VAR(&_2); zephir_string_to_char_array(&_2, &_0); @@ -301,9 +301,9 @@ PHP_METHOD(Phalcon_Queue_Consumer_QueueConsumer, consumeOnce) zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&_7$$3)) { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1322, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1323, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1322, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1323, &__$false); } RETURN_MM_LONG(processed); } @@ -349,9 +349,9 @@ PHP_METHOD(Phalcon_Queue_Consumer_QueueConsumer, consumeOnce) zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&_13$$7)) { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1322, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1323, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1322, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1323, &__$false); } RETURN_MM_LONG(processed); } @@ -362,7 +362,7 @@ PHP_METHOD(Phalcon_Queue_Consumer_QueueConsumer, consumeOnce) } ZEPHIR_INIT_NVAR(&binding); if (processed == 0) { - zephir_read_property_cached(&_14$$11, this_ptr, _zephir_prop_2, 1324, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$11, this_ptr, _zephir_prop_2, 1325, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_15$$11); ZVAL_LONG(&_15$$11, 1000); ZEPHIR_INIT_VAR(&_16$$11); @@ -429,7 +429,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, 1324, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1325, &_0); } /** @@ -455,9 +455,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, 1322, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1323, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1322, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1323, &__$false); } ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "queue:beforeStart"); @@ -481,9 +481,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, 1322, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1323, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1322, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1323, &__$false); } } @@ -580,7 +580,7 @@ PHP_METHOD(Phalcon_Queue_Consumer_QueueConsumer, process) /* try_start_1: */ - zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 1321, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$4, this_ptr, _zephir_prop_0, 1322, 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 04980e21a0..4d7d715e5a 100644 --- a/ext/phalcon/queue/consumer/worker.zep.c +++ b/ext/phalcon/queue/consumer/worker.zep.c @@ -103,8 +103,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, 1325, consumer); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1326, options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1326, consumer); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1327, options); ZEPHIR_MM_RESTORE(); } @@ -130,7 +130,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, 1325, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1326, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "stop", NULL, 0); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -183,7 +183,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, 1326, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1327, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_0); processed = 0; ZEPHIR_CALL_METHOD(&_1, &options, "getMaxMessages", NULL, 0); @@ -198,7 +198,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, 1325, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 1326, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_5, &_0, "start", NULL, 0); zephir_check_call_status(); if (!(zephir_is_true(&_5))) { @@ -228,13 +228,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(&_14$$6, this_ptr, _zephir_prop_1, 1325, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_14$$6, this_ptr, _zephir_prop_1, 1326, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_15$$6, &_14$$6, "isStopRequested", NULL, 0); zephir_check_call_status(); if (zephir_is_true(&_15$$6)) { break; } - zephir_read_property_cached(&_16$$6, this_ptr, _zephir_prop_1, 1325, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_16$$6, this_ptr, _zephir_prop_1, 1326, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_17$$6, &_16$$6, "consumeOnce", NULL, 0); zephir_check_call_status(); processed += zephir_get_numberval(&_17$$6); @@ -264,7 +264,7 @@ PHP_METHOD(Phalcon_Queue_Consumer_Worker, run) break; } } - zephir_read_property_cached(&_24, this_ptr, _zephir_prop_1, 1325, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_24, this_ptr, _zephir_prop_1, 1326, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_24, "end", NULL, 0); zephir_check_call_status(); RETURN_MM_LONG(processed); diff --git a/ext/phalcon/queue/consumer/workeroptions.zep.c b/ext/phalcon/queue/consumer/workeroptions.zep.c index a9815d2d98..a8c3445861 100644 --- a/ext/phalcon/queue/consumer/workeroptions.zep.c +++ b/ext/phalcon/queue/consumer/workeroptions.zep.c @@ -132,16 +132,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, 1327, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1328, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, maxSeconds); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1328, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1329, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, maxMemory); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1329, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1330, &_0); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, jitter); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1330, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1331, &_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 065702f466..c7fcd276db 100644 --- a/ext/phalcon/queue/queuefactory.zep.c +++ b/ext/phalcon/queue/queuefactory.zep.c @@ -93,7 +93,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, 1331, factory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1332, factory); ZEPHIR_MM_RESTORE(); } @@ -185,7 +185,7 @@ PHP_METHOD(Phalcon_Queue_QueueFactory, newInstance) } else { zephir_get_arrval(&options, options_param); } - 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, 1332, 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 03498be362..89743c86f0 100644 --- a/ext/phalcon/session/adapter/libmemcached.zep.c +++ b/ext/phalcon/session/adapter/libmemcached.zep.c @@ -115,7 +115,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, 1332, &_5); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1333, &_5); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/session/adapter/redis.zep.c b/ext/phalcon/session/adapter/redis.zep.c index aff4c3a3d7..ce049ec722 100644 --- a/ext/phalcon/session/adapter/redis.zep.c +++ b/ext/phalcon/session/adapter/redis.zep.c @@ -202,16 +202,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, 1333, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1334, &_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, 1334, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1335, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1334, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1335, &__$false); } ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "lockRetries"); @@ -220,7 +220,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, 1335, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1336, &_4); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "lockWaitTime"); ZVAL_LONG(&_4, 50000); @@ -228,16 +228,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, 1336, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1337, &_4); zephir_memory_observe(&_8); zephir_array_fetch_string(&_8, &options, SL("prefix"), PH_NOISY, "phalcon/Session/Adapter/Redis.zep", 77); zephir_cast_to_string(&_9, &_8); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1337, &_9); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1338, &_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, 1338, &_10); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1339, &_10); ZEPHIR_MM_RESTORE(); } @@ -318,7 +318,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Redis, read) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&id_zv); ZVAL_STR_COPY(&id_zv, id); - 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, 1335, PH_NOISY_CC | PH_READONLY); _1 = ZEPHIR_IS_TRUE_IDENTICAL(&_0); if (_1) { ZEPHIR_CALL_METHOD(&_2, this_ptr, "acquireLock", NULL, 0, &id_zv); @@ -328,7 +328,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, 1339, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_1, 1340, 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, 7, &_5$$3); @@ -415,20 +415,20 @@ PHP_METHOD(Phalcon_Session_Adapter_Redis, acquireLock) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&id_zv); ZVAL_STR_COPY(&id_zv, id); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1337, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1338, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&lockKey); ZEPHIR_CONCAT_VVS(&lockKey, &_0, &id_zv, "-lock"); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1340, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1341, PH_NOISY_CC | PH_READONLY); _2 = ZEPHIR_IS_TRUE_IDENTICAL(&_1); if (_2) { - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1339, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1340, 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, 1339, &lockKey); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 1338, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1340, &lockKey); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 1339, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&client, &_4, "getAdapter", NULL, 0); zephir_check_call_status(); ZVAL_LONG(&_5, 16); @@ -438,12 +438,12 @@ PHP_METHOD(Phalcon_Session_Adapter_Redis, acquireLock) zephir_check_call_status(); attempt = 0; while (1) { - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_4, 1335, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_4, 1336, PH_NOISY_CC | PH_READONLY); if (!(ZEPHIR_GT_LONG(&_5, attempt))) { break; } - zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_2, 1339, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_5, 1333, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_2, 1340, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$4, this_ptr, _zephir_prop_5, 1334, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_9$$4); ZVAL_STRING(&_9$$4, "SET"); ZEPHIR_INIT_NVAR(&_10$$4); @@ -454,14 +454,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, 1340, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1341, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1340, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1341, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1341, &token); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1342, &token); RETURN_MM_BOOL(1); } - zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_7, 1336, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_13$$4, this_ptr, _zephir_prop_7, 1337, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(NULL, "usleep", &_14, 73, &_13$$4); zephir_check_call_status(); attempt++; @@ -509,30 +509,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, 1340, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1341, 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, 1338, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1339, 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, 1339, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 1341, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1340, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_3, 1342, 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, 1340, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1341, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1340, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1341, &__$false); } ZEPHIR_INIT_NVAR(&_4); ZVAL_STRING(&_4, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1341, &_4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1342, &_4); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/session/adapter/stream.zep.c b/ext/phalcon/session/adapter/stream.zep.c index e3a2bb9428..fc56cf146c 100644 --- a/ext/phalcon/session/adapter/stream.zep.c +++ b/ext/phalcon/session/adapter/stream.zep.c @@ -152,8 +152,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, 1342, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1343, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1343, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1344, &options); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "session.save_path"); ZEPHIR_CALL_METHOD(&_3, this_ptr, "phpIniGet", NULL, 0, &_1); @@ -184,7 +184,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, 1344, &_7); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1345, &_7); ZEPHIR_MM_RESTORE(); } @@ -215,7 +215,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, destroy) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&id_zv); ZVAL_STR_COPY(&id_zv, id); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1344, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1345, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getPrefixedName", NULL, 0, &id_zv); zephir_check_call_status(); ZEPHIR_INIT_VAR(&file); @@ -286,8 +286,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, 1344, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1342, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1345, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1343, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&pattern); ZEPHIR_CONCAT_VVS(&pattern, &_0, &_1, "*"); ZEPHIR_INIT_VAR(&_2); @@ -445,7 +445,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, read) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&id_zv); ZVAL_STR_COPY(&id_zv, id); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1344, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1345, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getPrefixedName", NULL, 0, &id_zv); zephir_check_call_status(); ZEPHIR_INIT_VAR(&name); @@ -506,7 +506,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, updateTimestamp) ZVAL_STR_COPY(&id_zv, id); zephir_memory_observe(&data_zv); ZVAL_STR_COPY(&data_zv, data); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1344, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1345, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getPrefixedName", NULL, 0, &id_zv); zephir_check_call_status(); ZEPHIR_INIT_VAR(&name); @@ -543,7 +543,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, validateId) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&id_zv); ZVAL_STR_COPY(&id_zv, id); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1344, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1345, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getPrefixedName", NULL, 0, &id_zv); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_2); @@ -583,7 +583,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, write) ZVAL_STR_COPY(&id_zv, id); zephir_memory_observe(&data_zv); ZVAL_STR_COPY(&data_zv, data); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1344, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1345, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getPrefixedName", NULL, 0, &id_zv); zephir_check_call_status(); ZEPHIR_INIT_VAR(&name); @@ -666,7 +666,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, 1342, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1343, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_2); ZEPHIR_INIT_VAR(&_3); zephir_create_array(&_3, 3, 0); diff --git a/ext/phalcon/session/bag.zep.c b/ext/phalcon/session/bag.zep.c index 3385693645..5f2b894923 100644 --- a/ext/phalcon/session/bag.zep.c +++ b/ext/phalcon/session/bag.zep.c @@ -110,14 +110,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, 1345, session); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1346, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1346, session); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1347, &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, 1347, &_0$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1348, &_0$$3); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1346, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1347, 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) { @@ -154,8 +154,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, 1345, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1346, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1346, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1347, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "remove", NULL, 0, &_1); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -210,8 +210,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, 1345, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1346, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1346, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1347, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &_1, &data); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -254,9 +254,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, 1345, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1346, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1348, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1346, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1347, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1349, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &_1, &_2); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -302,9 +302,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, 1345, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1346, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1348, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1346, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1347, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_2, 1349, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &_1, &_2); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -328,6 +328,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, 1347, container); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1348, container); } diff --git a/ext/phalcon/session/manager.zep.c b/ext/phalcon/session/manager.zep.c index 79d995b369..d7aedb15d5 100644 --- a/ext/phalcon/session/manager.zep.c +++ b/ext/phalcon/session/manager.zep.c @@ -376,13 +376,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, 1349, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1350, 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, 1349, &_2$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1350, &_2$$3); } RETURN_MM_MEMBER_TYPED(getThis(), "name", IS_STRING); } @@ -554,7 +554,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, 1350, adapter); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1351, adapter); RETURN_THISW(); } @@ -701,7 +701,7 @@ PHP_METHOD(Phalcon_Session_Manager, setName) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1349, &name_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1350, &name_zv); ZEPHIR_CALL_FUNCTION(NULL, "session_name", NULL, 0, &name_zv); zephir_check_call_status(); RETURN_THIS(); @@ -746,8 +746,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, 1351, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1352, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1352, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1353, &options); ZEPHIR_MM_RESTORE(); } @@ -808,7 +808,7 @@ PHP_METHOD(Phalcon_Session_Manager, start) } } zephir_memory_observe(&_6); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 1350, PH_NOISY_CC); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 1351, 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); @@ -818,7 +818,7 @@ PHP_METHOD(Phalcon_Session_Manager, start) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 1350, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 1351, 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); @@ -884,9 +884,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, 1351, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1352, PH_NOISY_CC); if (1 != ZEPHIR_IS_EMPTY(&_0)) { - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1351, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1352, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&prefix); ZEPHIR_CONCAT_VS(&prefix, &_1, "#"); } else { diff --git a/ext/phalcon/storage/adapter/abstractadapter.zep.c b/ext/phalcon/storage/adapter/abstractadapter.zep.c index f24c025e12..74a0fec8b2 100644 --- a/ext/phalcon/storage/adapter/abstractadapter.zep.c +++ b/ext/phalcon/storage/adapter/abstractadapter.zep.c @@ -270,7 +270,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, decrement) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long value, ZEPHIR_LAST_CALL_STATUS; - zval *key_param = NULL, *value_param = NULL, result, _0, _1, _2, _3, _4; + zval *key_param = NULL, *value_param = NULL, result, _0, _1, _4, _2$$3, _3$$3, _5$$4, _6$$4; zval key; zval *this_ptr = getThis(); @@ -278,12 +278,18 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, decrement) ZVAL_UNDEF(&result); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); - ZVAL_UNDEF(&_2); - ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_4); + ZVAL_UNDEF(&_2$$3); + ZVAL_UNDEF(&_3$$3); + ZVAL_UNDEF(&_5$$4); + ZVAL_UNDEF(&_6$$4); 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("eventType", 9, 1); + _zephir_prop_0 = zend_string_init("eventsManager", 13, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("eventType", 9, 1); } ZEND_PARSE_PARAMETERS_START(1, 2) @@ -303,18 +309,24 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, decrement) zephir_check_call_status(); zephir_get_strval(&key, &_0); zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); - ZEPHIR_INIT_VAR(&_2); - ZEPHIR_CONCAT_VS(&_2, &_1, ":beforeDecrement"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_2, &key); - zephir_check_call_status(); - ZVAL_LONG(&_3, value); - ZEPHIR_CALL_METHOD(&result, this_ptr, "doDecrement", NULL, 0, &key, &_3); - zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); - ZEPHIR_INIT_VAR(&_4); - ZEPHIR_CONCAT_VS(&_4, &_3, ":afterDecrement"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_4, &key); + if (Z_TYPE_P(&_1) != IS_NULL) { + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 37, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_3$$3); + ZEPHIR_CONCAT_VS(&_3$$3, &_2$$3, ":beforeDecrement"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_3$$3, &key); + zephir_check_call_status(); + } + ZVAL_LONG(&_4, value); + ZEPHIR_CALL_METHOD(&result, this_ptr, "doDecrement", NULL, 0, &key, &_4); zephir_check_call_status(); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_4) != IS_NULL) { + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_1, 37, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_6$$4); + ZEPHIR_CONCAT_VS(&_6$$4, &_5$$4, ":afterDecrement"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_6$$4, &key); + zephir_check_call_status(); + } RETURN_CCTOR(&result); } @@ -325,7 +337,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, delete) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *key_param = NULL, result, _0, _1, _2, _3, _4; + zval *key_param = NULL, result, _0, _1, _4, _2$$3, _3$$3, _5$$4, _6$$4; zval key; zval *this_ptr = getThis(); @@ -333,12 +345,18 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, delete) ZVAL_UNDEF(&result); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); - ZVAL_UNDEF(&_2); - ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_4); + ZVAL_UNDEF(&_2$$3); + ZVAL_UNDEF(&_3$$3); + ZVAL_UNDEF(&_5$$4); + ZVAL_UNDEF(&_6$$4); 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("eventType", 9, 1); + _zephir_prop_0 = zend_string_init("eventsManager", 13, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("eventType", 9, 1); } ZEND_PARSE_PARAMETERS_START(1, 1) @@ -352,17 +370,23 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, delete) zephir_check_call_status(); zephir_get_strval(&key, &_0); zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); - ZEPHIR_INIT_VAR(&_2); - ZEPHIR_CONCAT_VS(&_2, &_1, ":beforeDelete"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_2, &key); - zephir_check_call_status(); + if (Z_TYPE_P(&_1) != IS_NULL) { + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 37, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_3$$3); + ZEPHIR_CONCAT_VS(&_3$$3, &_2$$3, ":beforeDelete"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_3$$3, &key); + zephir_check_call_status(); + } ZEPHIR_CALL_METHOD(&result, this_ptr, "doDelete", NULL, 0, &key); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); - ZEPHIR_INIT_VAR(&_4); - ZEPHIR_CONCAT_VS(&_4, &_3, ":afterDelete"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_4, &key); - zephir_check_call_status(); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_4) != IS_NULL) { + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_1, 37, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_6$$4); + ZEPHIR_CONCAT_VS(&_6$$4, &_5$$4, ":afterDelete"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_6$$4, &key); + zephir_check_call_status(); + } RETURN_CCTOR(&result); } @@ -377,7 +401,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, deleteMultiple) zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zephir_fcall_cache_entry *_2 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *keys_param = NULL, key, result, *_0, _3, _6, _7, _8, _9, _1$$3, _5$$4; + zval *keys_param = NULL, key, result, *_0, _3, _6, _9, _1$$3, _5$$4, _7$$5, _8$$5, _10$$6, _11$$6; zval keys, filteredKeys; zval *this_ptr = getThis(); @@ -387,14 +411,20 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, deleteMultiple) ZVAL_UNDEF(&result); ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_6); - ZVAL_UNDEF(&_7); - ZVAL_UNDEF(&_8); ZVAL_UNDEF(&_9); ZVAL_UNDEF(&_1$$3); ZVAL_UNDEF(&_5$$4); + ZVAL_UNDEF(&_7$$5); + ZVAL_UNDEF(&_8$$5); + ZVAL_UNDEF(&_10$$6); + ZVAL_UNDEF(&_11$$6); 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("eventType", 9, 1); + _zephir_prop_0 = zend_string_init("eventsManager", 13, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("eventType", 9, 1); } ZEND_PARSE_PARAMETERS_START(1, 1) @@ -406,7 +436,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, deleteMultiple) zephir_get_arrval(&keys, keys_param); ZEPHIR_INIT_VAR(&filteredKeys); array_init(&filteredKeys); - zephir_is_iterable(&keys, 0, "phalcon/Storage/Adapter/AbstractAdapter.zep", 178); + zephir_is_iterable(&keys, 0, "phalcon/Storage/Adapter/AbstractAdapter.zep", 190); if (Z_TYPE_P(&keys) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&keys), _0) { @@ -414,7 +444,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, deleteMultiple) ZVAL_COPY(&key, _0); ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "getKeyWithoutPrefix", &_2, 0, &key); zephir_check_call_status(); - zephir_array_append(&filteredKeys, &_1$$3, PH_SEPARATE, "phalcon/Storage/Adapter/AbstractAdapter.zep", 175); + zephir_array_append(&filteredKeys, &_1$$3, PH_SEPARATE, "phalcon/Storage/Adapter/AbstractAdapter.zep", 187); } ZEND_HASH_FOREACH_END(); } else { ZEPHIR_CALL_METHOD(NULL, &keys, "rewind", NULL, 0); @@ -436,23 +466,29 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, deleteMultiple) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_5$$4, this_ptr, "getKeyWithoutPrefix", &_2, 0, &key); zephir_check_call_status(); - zephir_array_append(&filteredKeys, &_5$$4, PH_SEPARATE, "phalcon/Storage/Adapter/AbstractAdapter.zep", 175); + zephir_array_append(&filteredKeys, &_5$$4, PH_SEPARATE, "phalcon/Storage/Adapter/AbstractAdapter.zep", 187); } } ZEPHIR_INIT_NVAR(&key); ZEPHIR_CPY_WRT(&keys, &filteredKeys); zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); - ZEPHIR_INIT_VAR(&_7); - ZEPHIR_CONCAT_VS(&_7, &_6, ":beforeDeleteMultiple"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_7, &keys); - zephir_check_call_status(); + if (Z_TYPE_P(&_6) != IS_NULL) { + zephir_read_property_cached(&_7$$5, this_ptr, _zephir_prop_1, 37, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_8$$5); + ZEPHIR_CONCAT_VS(&_8$$5, &_7$$5, ":beforeDeleteMultiple"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_8$$5, &keys); + zephir_check_call_status(); + } ZEPHIR_CALL_METHOD(&result, this_ptr, "doDeleteMultiple", NULL, 0, &keys); zephir_check_call_status(); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); - ZEPHIR_INIT_VAR(&_9); - ZEPHIR_CONCAT_VS(&_9, &_8, ":afterDeleteMultiple"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_9, &keys); - zephir_check_call_status(); + zephir_read_property_cached(&_9, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_9) != IS_NULL) { + zephir_read_property_cached(&_10$$6, this_ptr, _zephir_prop_1, 37, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_11$$6); + ZEPHIR_CONCAT_VS(&_11$$6, &_10$$6, ":afterDeleteMultiple"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_11$$6, &keys); + zephir_check_call_status(); + } RETURN_CCTOR(&result); } @@ -463,7 +499,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, get) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *key_param = NULL, *defaultValue = NULL, defaultValue_sub, __$null, result, _0, _1, _2, _3, _4; + zval *key_param = NULL, *defaultValue = NULL, defaultValue_sub, __$null, result, _0, _1, _4, _2$$3, _3$$3, _5$$4, _6$$4; zval key; zval *this_ptr = getThis(); @@ -473,12 +509,18 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, get) ZVAL_UNDEF(&result); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); - ZVAL_UNDEF(&_2); - ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_4); + ZVAL_UNDEF(&_2$$3); + ZVAL_UNDEF(&_3$$3); + ZVAL_UNDEF(&_5$$4); + ZVAL_UNDEF(&_6$$4); 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("eventType", 9, 1); + _zephir_prop_0 = zend_string_init("eventsManager", 13, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("eventType", 9, 1); } bool is_null_true = 1; @@ -499,17 +541,23 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, get) zephir_check_call_status(); zephir_get_strval(&key, &_0); zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); - ZEPHIR_INIT_VAR(&_2); - ZEPHIR_CONCAT_VS(&_2, &_1, ":beforeGet"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_2, &key); - zephir_check_call_status(); + if (Z_TYPE_P(&_1) != IS_NULL) { + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 37, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_3$$3); + ZEPHIR_CONCAT_VS(&_3$$3, &_2$$3, ":beforeGet"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_3$$3, &key); + zephir_check_call_status(); + } ZEPHIR_CALL_METHOD(&result, this_ptr, "doGet", NULL, 0, &key, defaultValue); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); - ZEPHIR_INIT_VAR(&_4); - ZEPHIR_CONCAT_VS(&_4, &_3, ":afterGet"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_4, &key); - zephir_check_call_status(); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_4) != IS_NULL) { + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_1, 37, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_6$$4); + ZEPHIR_CONCAT_VS(&_6$$4, &_5$$4, ":afterGet"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_6$$4, &key); + zephir_check_call_status(); + } RETURN_CCTOR(&result); } @@ -574,7 +622,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, has) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *key_param = NULL, result, _0, _1, _2, _3, _4; + zval *key_param = NULL, result, _0, _1, _4, _2$$3, _3$$3, _5$$4, _6$$4; zval key; zval *this_ptr = getThis(); @@ -582,12 +630,18 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, has) ZVAL_UNDEF(&result); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); - ZVAL_UNDEF(&_2); - ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_4); + ZVAL_UNDEF(&_2$$3); + ZVAL_UNDEF(&_3$$3); + ZVAL_UNDEF(&_5$$4); + ZVAL_UNDEF(&_6$$4); 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("eventType", 9, 1); + _zephir_prop_0 = zend_string_init("eventsManager", 13, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("eventType", 9, 1); } ZEND_PARSE_PARAMETERS_START(1, 1) @@ -601,17 +655,23 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, has) zephir_check_call_status(); zephir_get_strval(&key, &_0); zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); - ZEPHIR_INIT_VAR(&_2); - ZEPHIR_CONCAT_VS(&_2, &_1, ":beforeHas"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_2, &key); - zephir_check_call_status(); + if (Z_TYPE_P(&_1) != IS_NULL) { + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 37, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_3$$3); + ZEPHIR_CONCAT_VS(&_3$$3, &_2$$3, ":beforeHas"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_3$$3, &key); + zephir_check_call_status(); + } ZEPHIR_CALL_METHOD(&result, this_ptr, "doHas", NULL, 0, &key); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); - ZEPHIR_INIT_VAR(&_4); - ZEPHIR_CONCAT_VS(&_4, &_3, ":afterHas"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_4, &key); - zephir_check_call_status(); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_4) != IS_NULL) { + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_1, 37, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_6$$4); + ZEPHIR_CONCAT_VS(&_6$$4, &_5$$4, ":afterHas"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_6$$4, &key); + zephir_check_call_status(); + } RETURN_CCTOR(&result); } @@ -622,7 +682,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, increment) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long value, ZEPHIR_LAST_CALL_STATUS; - zval *key_param = NULL, *value_param = NULL, result, _0, _1, _2, _3, _4; + zval *key_param = NULL, *value_param = NULL, result, _0, _1, _4, _2$$3, _3$$3, _5$$4, _6$$4; zval key; zval *this_ptr = getThis(); @@ -630,12 +690,18 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, increment) ZVAL_UNDEF(&result); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); - ZVAL_UNDEF(&_2); - ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_4); + ZVAL_UNDEF(&_2$$3); + ZVAL_UNDEF(&_3$$3); + ZVAL_UNDEF(&_5$$4); + ZVAL_UNDEF(&_6$$4); 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("eventType", 9, 1); + _zephir_prop_0 = zend_string_init("eventsManager", 13, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("eventType", 9, 1); } ZEND_PARSE_PARAMETERS_START(1, 2) @@ -655,18 +721,24 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, increment) zephir_check_call_status(); zephir_get_strval(&key, &_0); zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); - ZEPHIR_INIT_VAR(&_2); - ZEPHIR_CONCAT_VS(&_2, &_1, ":beforeIncrement"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_2, &key); - zephir_check_call_status(); - ZVAL_LONG(&_3, value); - ZEPHIR_CALL_METHOD(&result, this_ptr, "doIncrement", NULL, 0, &key, &_3); - zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); - ZEPHIR_INIT_VAR(&_4); - ZEPHIR_CONCAT_VS(&_4, &_3, ":afterIncrement"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_4, &key); + if (Z_TYPE_P(&_1) != IS_NULL) { + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 37, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_3$$3); + ZEPHIR_CONCAT_VS(&_3$$3, &_2$$3, ":beforeIncrement"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_3$$3, &key); + zephir_check_call_status(); + } + ZVAL_LONG(&_4, value); + ZEPHIR_CALL_METHOD(&result, this_ptr, "doIncrement", NULL, 0, &key, &_4); zephir_check_call_status(); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_4) != IS_NULL) { + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_1, 37, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_6$$4); + ZEPHIR_CONCAT_VS(&_6$$4, &_5$$4, ":afterIncrement"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_6$$4, &key); + zephir_check_call_status(); + } RETURN_CCTOR(&result); } @@ -681,7 +753,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, set) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *key_param = NULL, *value, value_sub, *ttl = NULL, ttl_sub, __$null, result, _0, _1, _2, _3, _4; + zval *key_param = NULL, *value, value_sub, *ttl = NULL, ttl_sub, __$null, result, _0, _1, _4, _2$$3, _3$$3, _5$$4, _6$$4; zval key; zval *this_ptr = getThis(); @@ -692,12 +764,18 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, set) ZVAL_UNDEF(&result); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); - ZVAL_UNDEF(&_2); - ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_4); + ZVAL_UNDEF(&_2$$3); + ZVAL_UNDEF(&_3$$3); + ZVAL_UNDEF(&_5$$4); + ZVAL_UNDEF(&_6$$4); 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("eventType", 9, 1); + _zephir_prop_0 = zend_string_init("eventsManager", 13, 1); + } + if (UNEXPECTED(!_zephir_prop_1)) { + _zephir_prop_1 = zend_string_init("eventType", 9, 1); } bool is_null_true = 1; @@ -719,17 +797,23 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, set) zephir_check_call_status(); zephir_get_strval(&key, &_0); zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); - ZEPHIR_INIT_VAR(&_2); - ZEPHIR_CONCAT_VS(&_2, &_1, ":beforeSet"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_2, &key); - zephir_check_call_status(); + if (Z_TYPE_P(&_1) != IS_NULL) { + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_1, 37, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_3$$3); + ZEPHIR_CONCAT_VS(&_3$$3, &_2$$3, ":beforeSet"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_3$$3, &key); + zephir_check_call_status(); + } ZEPHIR_CALL_METHOD(&result, this_ptr, "doSet", NULL, 0, &key, value, ttl); zephir_check_call_status(); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); - ZEPHIR_INIT_VAR(&_4); - ZEPHIR_CONCAT_VS(&_4, &_3, ":afterSet"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_4, &key); - zephir_check_call_status(); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_4) != IS_NULL) { + zephir_read_property_cached(&_5$$4, this_ptr, _zephir_prop_1, 37, PH_NOISY_CC | PH_READONLY); + ZEPHIR_INIT_VAR(&_6$$4); + ZEPHIR_CONCAT_VS(&_6$$4, &_5$$4, ":afterSet"); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "fireManagerEvent", NULL, 0, &_6$$4, &key); + zephir_check_call_status(); + } RETURN_CCTOR(&result); } @@ -803,7 +887,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, doDeleteMultiple) zephir_fetch_params(1, 1, 0, &keys_param); zephir_get_arrval(&keys, keys_param); result = 1; - zephir_is_iterable(&keys, 0, "phalcon/Storage/Adapter/AbstractAdapter.zep", 343); + zephir_is_iterable(&keys, 0, "phalcon/Storage/Adapter/AbstractAdapter.zep", 375); if (Z_TYPE_P(&keys) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&keys), _0) { @@ -1017,14 +1101,14 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, getFilteredKeys) } else { _2 = keys; } - zephir_is_iterable(_2, 0, "phalcon/Storage/Adapter/AbstractAdapter.zep", 434); + zephir_is_iterable(_2, 0, "phalcon/Storage/Adapter/AbstractAdapter.zep", 466); if (Z_TYPE_P(_2) == IS_ARRAY) { ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(_2), _4) { ZEPHIR_INIT_NVAR(&key); ZVAL_COPY(&key, _4); if (zephir_start_with(&key, &pattern, NULL)) { - zephir_array_append(&results, &key, PH_SEPARATE, "phalcon/Storage/Adapter/AbstractAdapter.zep", 430); + zephir_array_append(&results, &key, PH_SEPARATE, "phalcon/Storage/Adapter/AbstractAdapter.zep", 462); } } ZEND_HASH_FOREACH_END(); } else { @@ -1046,7 +1130,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, getFilteredKeys) ZEPHIR_CALL_METHOD(&key, _2, "current", NULL, 0); zephir_check_call_status(); if (zephir_start_with(&key, &pattern, NULL)) { - zephir_array_append(&results, &key, PH_SEPARATE, "phalcon/Storage/Adapter/AbstractAdapter.zep", 430); + zephir_array_append(&results, &key, PH_SEPARATE, "phalcon/Storage/Adapter/AbstractAdapter.zep", 462); } } } @@ -1402,19 +1486,19 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, setEventsManager) _2 = ZEPHIR_IS_TRUE_IDENTICAL(&_1); if (_2) { zephir_memory_observe(&_3); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 37, PH_NOISY_CC); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 38, PH_NOISY_CC); _2 = Z_TYPE_P(&_3) != IS_NULL; } if (_2) { zephir_memory_observe(&_4$$3); - zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 37, PH_NOISY_CC); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 38, PH_NOISY_CC); ZEPHIR_INIT_VAR(&_5$$3); ZVAL_STRING(&_5$$3, "eventsManager"); ZVAL_BOOL(&_6$$3, 1); ZEPHIR_CALL_METHOD(NULL, &_4$$3, "set", NULL, 0, &_5$$3, eventsManager, &_6$$3); zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 38, eventsManager); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 36, eventsManager); ZEPHIR_MM_RESTORE(); } @@ -1480,16 +1564,16 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, fireManagerEvent) stopOnFalse = 0; } else { } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 38, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) != IS_NULL) { _1$$3 = stopOnFalse; if (_1$$3) { zephir_memory_observe(&_2$$3); - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 38, PH_NOISY_CC); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC); _1$$3 = zephir_instance_of_ev(&_2$$3, phalcon_events_manager_ce); } if (_1$$3) { - zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 38, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3$$4, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); if (cancellable) { ZVAL_BOOL(&_4$$4, 1); } else { @@ -1500,7 +1584,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_AbstractAdapter, fireManagerEvent) zephir_check_call_status(); RETURN_MM(); } - zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 38, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 36, PH_NOISY_CC | PH_READONLY); if (cancellable) { ZVAL_BOOL(&_7$$3, 1); } else { diff --git a/ext/phalcon/storage/adapter/apcu.zep.c b/ext/phalcon/storage/adapter/apcu.zep.c index 214d947308..1661b6ebc3 100644 --- a/ext/phalcon/storage/adapter/apcu.zep.c +++ b/ext/phalcon/storage/adapter/apcu.zep.c @@ -122,7 +122,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Apcu, clear) ZEPHIR_INIT_VAR(&apc); ZVAL_NULL(&apc); result = 1; - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 322, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 323, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&pattern); ZEPHIR_CONCAT_SVS(&pattern, "/^", &_0, "/"); ZEPHIR_CALL_METHOD(&apc, this_ptr, "phpApcuIterator", NULL, 0, &pattern); @@ -193,7 +193,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Apcu, getKeys) } ZEPHIR_INIT_VAR(&apc); ZVAL_NULL(&apc); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 322, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 323, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&pattern); ZEPHIR_CONCAT_SVVS(&pattern, "/^", &_0, &prefix_zv, "/"); ZEPHIR_CALL_METHOD(&apc, this_ptr, "phpApcuIterator", NULL, 0, &pattern); diff --git a/ext/phalcon/storage/adapter/libmemcached.zep.c b/ext/phalcon/storage/adapter/libmemcached.zep.c index 54fc6b8cae..ce1d283868 100644 --- a/ext/phalcon/storage/adapter/libmemcached.zep.c +++ b/ext/phalcon/storage/adapter/libmemcached.zep.c @@ -184,9 +184,9 @@ PHP_METHOD(Phalcon_Storage_Adapter_Libmemcached, getAdapter) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 323, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 324, PH_NOISY_CC | PH_READONLY); if (!(zephir_is_true(&_0))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 324, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 325, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_1$$3); ZEPHIR_INIT_VAR(&_2$$3); ZVAL_STRING(&_2$$3, "persistentId"); @@ -206,7 +206,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Libmemcached, getAdapter) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&serverList, &connection, "getServerList", NULL, 0); zephir_check_call_status(); - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 325, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 326, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_4$$3, -1002); ZEPHIR_CALL_METHOD(NULL, &connection, "setOption", NULL, 0, &_4$$3, &_1$$3); zephir_check_call_status(); @@ -254,7 +254,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Libmemcached, getAdapter) } ZEPHIR_CALL_METHOD(NULL, this_ptr, "setSerializer", NULL, 294, &connection); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 323, &connection); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 324, &connection); } RETURN_MM_MEMBER(getThis(), "adapter"); } @@ -737,14 +737,14 @@ PHP_METHOD(Phalcon_Storage_Adapter_Libmemcached, setSerializer) add_assoc_long_ex(&map, SL("memcached_igbinary"), 2); add_assoc_long_ex(&map, SL("memcached_json"), 3); add_assoc_long_ex(&map, SL("memcached_php"), 1); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 326, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 327, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&serializer); zephir_fast_strtolower(&serializer, &_0); if (zephir_array_isset_value(&map, &serializer)) { ZEPHIR_INIT_VAR(&_1$$3); ZEPHIR_INIT_NVAR(&_1$$3); ZVAL_STRING(&_1$$3, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 326, &_1$$3); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 327, &_1$$3); zephir_array_fetch(&_2$$3, &map, &serializer, PH_NOISY | PH_READONLY, "phalcon/Storage/Adapter/Libmemcached.zep", 315); ZVAL_LONG(&_3$$3, -1003); ZEPHIR_CALL_METHOD(NULL, connection, "setOption", NULL, 0, &_3$$3, &_2$$3); diff --git a/ext/phalcon/storage/adapter/memory.zep.c b/ext/phalcon/storage/adapter/memory.zep.c index d139bf0e3e..aa1241c681 100644 --- a/ext/phalcon/storage/adapter/memory.zep.c +++ b/ext/phalcon/storage/adapter/memory.zep.c @@ -133,7 +133,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, clear) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 327, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 328, &_0); RETURN_MM_BOOL(1); } @@ -177,7 +177,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, getKeys) ZVAL_STR_COPY(&prefix_zv, prefix); } ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 327, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 328, PH_NOISY_CC | PH_READONLY); zephir_array_keys(&_0, &_1); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getFilteredKeys", NULL, 0, &_0, &prefix_zv); zephir_check_call_status(); @@ -245,7 +245,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, setMaxItems) zephir_fetch_params_without_memory_grow(1, 0, &maxItems_param); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, maxItems); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 328, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 329, &_0); RETURN_THISW(); } @@ -290,11 +290,11 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, doDecrement) } ZEPHIR_CALL_METHOD(&prefixedKey, this_ptr, "getPrefixedKey", NULL, 0, &key_zv); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 327, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 328, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&result); ZVAL_BOOL(&result, zephir_array_key_exists(&_0, &prefixedKey)); if (EXPECTED(ZEPHIR_IS_TRUE_IDENTICAL(&result))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 327, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 328, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(¤t); zephir_array_fetch(¤t, &_1$$3, &prefixedKey, PH_NOISY, "phalcon/Storage/Adapter/Memory.zep", 132); ZEPHIR_INIT_VAR(&newValue); @@ -334,7 +334,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, doDelete) ZVAL_STR_COPY(&key_zv, key); ZEPHIR_CALL_METHOD(&prefixedKey, this_ptr, "getPrefixedKey", NULL, 0, &key_zv); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 327, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 328, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&exists); ZVAL_BOOL(&exists, zephir_array_key_exists(&_0, &prefixedKey)); zephir_unset_property_array(this_ptr, ZEND_STRL("data"), &prefixedKey); @@ -365,7 +365,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, doGetData) zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 327, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 328, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_1); ZEPHIR_CALL_METHOD(&_2, this_ptr, "getPrefixedKey", NULL, 0, &key_zv); zephir_check_call_status(); @@ -401,7 +401,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, doHas) ZVAL_STR_COPY(&key_zv, key); ZEPHIR_CALL_METHOD(&_0, this_ptr, "getPrefixedKey", NULL, 0, &key_zv); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 327, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 328, PH_NOISY_CC | PH_READONLY); RETURN_MM_BOOL(zephir_array_key_exists(&_1, &_0)); } @@ -446,11 +446,11 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, doIncrement) } ZEPHIR_CALL_METHOD(&prefixedKey, this_ptr, "getPrefixedKey", NULL, 0, &key_zv); zephir_check_call_status(); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 327, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 328, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&result); ZVAL_BOOL(&result, zephir_array_key_exists(&_0, &prefixedKey)); if (EXPECTED(ZEPHIR_IS_TRUE_IDENTICAL(&result))) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 327, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_0, 328, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(¤t); zephir_array_fetch(¤t, &_1$$3, &prefixedKey, PH_NOISY, "phalcon/Storage/Adapter/Memory.zep", 182); ZEPHIR_INIT_VAR(&newValue); @@ -530,20 +530,20 @@ PHP_METHOD(Phalcon_Storage_Adapter_Memory, doSet) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&prefixedKey, this_ptr, "getPrefixedKey", NULL, 0, &key_zv); zephir_check_call_status(); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 328, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 329, PH_NOISY_CC | PH_READONLY); _2 = ZEPHIR_GT_LONG(&_1, 0); if (_2) { - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 327, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_1, 328, PH_NOISY_CC | PH_READONLY); _2 = !(zephir_array_key_exists(&_3, &prefixedKey)); } _4 = _2; if (_4) { - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 327, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 328, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_1, 328, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_0, 329, PH_NOISY_CC | PH_READONLY); _4 = ZEPHIR_LE_LONG(&_6, zephir_fast_count_int(&_5)); } if (_4) { - zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_1, 327, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7$$4, this_ptr, _zephir_prop_1, 328, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_FUNCTION(&firstKey, "array_key_first", NULL, 18, &_7$$4); zephir_check_call_status(); zephir_unset_property_array(this_ptr, ZEND_STRL("data"), &firstKey); diff --git a/ext/phalcon/storage/adapter/rediscluster.zep.c b/ext/phalcon/storage/adapter/rediscluster.zep.c index 532ee1108c..3cc1794ad7 100644 --- a/ext/phalcon/storage/adapter/rediscluster.zep.c +++ b/ext/phalcon/storage/adapter/rediscluster.zep.c @@ -248,9 +248,9 @@ PHP_METHOD(Phalcon_Storage_Adapter_RedisCluster, getAdapter) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 329, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 330, PH_NOISY_CC | PH_READONLY); if (Z_TYPE_P(&_0) == IS_NULL) { - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 330, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_1, 331, PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&options, &_1$$3); /* try_start_1: */ @@ -297,13 +297,13 @@ PHP_METHOD(Phalcon_Storage_Adapter_RedisCluster, getAdapter) return; } } - zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 331, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$3, this_ptr, _zephir_prop_2, 332, PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_14$$3, 2); ZEPHIR_CALL_METHOD(NULL, &connection, "setOption", NULL, 0, &_14$$3, &_1$$3); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, this_ptr, "setSerializer", NULL, 295, &connection); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 329, &connection); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 330, &connection); } RETURN_MM_MEMBER(getThis(), "adapter"); } @@ -515,14 +515,14 @@ PHP_METHOD(Phalcon_Storage_Adapter_RedisCluster, setSerializer) zephir_check_call_status(); zephir_array_update_string(&map, SL("redis_json"), &_9$$5, PH_COPY | PH_SEPARATE); } - zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 332, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_10, this_ptr, _zephir_prop_0, 333, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&serializer); zephir_fast_strtolower(&serializer, &_10); if (1 == zephir_array_isset_value(&map, &serializer)) { ZEPHIR_INIT_VAR(&_11$$6); ZEPHIR_INIT_NVAR(&_11$$6); ZVAL_STRING(&_11$$6, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 332, &_11$$6); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 333, &_11$$6); zephir_array_fetch(&_12$$6, &map, &serializer, PH_NOISY | PH_READONLY, "phalcon/Storage/Adapter/RedisCluster.zep", 230); ZVAL_LONG(&_13$$6, 1); ZEPHIR_CALL_METHOD(NULL, connection, "setOption", NULL, 0, &_13$$6, &_12$$6); diff --git a/ext/phalcon/storage/adapter/stream.zep.c b/ext/phalcon/storage/adapter/stream.zep.c index 0e4591749b..5287ef4894 100644 --- a/ext/phalcon/storage/adapter/stream.zep.c +++ b/ext/phalcon/storage/adapter/stream.zep.c @@ -118,7 +118,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, __construct) } ZEPHIR_CALL_METHOD(&_2, this_ptr, "toDirSeparator", NULL, 0, &storageDir); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 333, &_2); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 334, &_2); ZEPHIR_CALL_PARENT(NULL, phalcon_storage_adapter_stream_ce, getThis(), "__construct", NULL, 0, factory, &options); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, this_ptr, "initSerializer", NULL, 0); @@ -305,7 +305,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, getKeys) ZEPHIR_CALL_METHOD(&_4$$4, &file, "isFile", NULL, 0); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_4$$4)) { - zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_0, 334, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5$$5, this_ptr, _zephir_prop_0, 335, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_6$$5, &file, "getFilename", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_7$$5); @@ -334,7 +334,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, getKeys) ZEPHIR_CALL_METHOD(&_10$$6, &file, "isFile", NULL, 0); zephir_check_call_status(); if (ZEPHIR_IS_TRUE_IDENTICAL(&_10$$6)) { - zephir_read_property_cached(&_11$$7, this_ptr, _zephir_prop_0, 334, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_11$$7, this_ptr, _zephir_prop_0, 335, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_12$$7, &file, "getFilename", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_13$$7); @@ -739,8 +739,8 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, getDir) zephir_memory_observe(&key_zv); ZVAL_STR_COPY(&key_zv, key); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 333, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 334, PH_NOISY_CC | PH_READONLY); + 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_INIT_VAR(&_2); ZEPHIR_CONCAT_VV(&_2, &_0, &_1); ZEPHIR_CALL_METHOD(&dirPrefix, this_ptr, "toDirSeparator", NULL, 0, &_2); diff --git a/ext/phalcon/storage/adapter/weak.zep.c b/ext/phalcon/storage/adapter/weak.zep.c index d66dc1b522..578dde0eb6 100644 --- a/ext/phalcon/storage/adapter/weak.zep.c +++ b/ext/phalcon/storage/adapter/weak.zep.c @@ -128,17 +128,17 @@ PHP_METHOD(Phalcon_Storage_Adapter_Weak, __construct) ZEPHIR_INIT_VAR(&_0); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "none"); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 335, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 336, &_0); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "lifetime"); ZVAL_LONG(&_2, 3600); ZEPHIR_CALL_METHOD(&_1, this_ptr, "getArrVal", NULL, 0, &options, &_0, &_2); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 336, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 337, &_1); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, ""); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 337, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 338, &options); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 338, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 339, &options); ZEPHIR_MM_RESTORE(); } @@ -161,7 +161,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Weak, clear) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 339, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 340, &_0); RETURN_MM_BOOL(1); } @@ -205,7 +205,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Weak, getKeys) zephir_memory_observe(&prefix_zv); ZVAL_STR_COPY(&prefix_zv, prefix); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 339, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 340, PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&keys); zephir_array_keys(&keys, &_0); ZEPHIR_INIT_VAR(&_1); @@ -334,11 +334,11 @@ PHP_METHOD(Phalcon_Storage_Adapter_Weak, doDelete) Z_PARAM_STR(key) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&key_zv, key); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 340, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 341, PH_NOISY_CC | PH_READONLY); if (ZEPHIR_IS_IDENTICAL(&key_zv, &_0)) { RETURN_BOOL(0); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 339, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 340, PH_NOISY_CC | PH_READONLY); exists = zephir_array_isset_value(&_1, &key_zv); zephir_unset_property_array(this_ptr, ZEND_STRL("weakList"), &key_zv); RETURN_BOOL(exists); @@ -388,19 +388,19 @@ PHP_METHOD(Phalcon_Storage_Adapter_Weak, doGet) defaultValue = &defaultValue_sub; defaultValue = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 340, &key_zv); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 339, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 341, &key_zv); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_1, 340, PH_NOISY_CC | PH_READONLY); if (0 == zephir_array_isset_value(&_0, &key_zv)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 340, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 341, &__$null); RETVAL_ZVAL(defaultValue, 1, 0); RETURN_MM(); } - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 339, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 340, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&wr); zephir_array_fetch(&wr, &_1, &key_zv, PH_NOISY, "phalcon/Storage/Adapter/Weak.zep", 159); ZEPHIR_CALL_METHOD(&value, &wr, "get", NULL, 0); zephir_check_call_status(); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 340, &__$null); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 341, &__$null); if (Z_TYPE_P(&value) == IS_NULL) { ZEPHIR_CALL_METHOD(NULL, this_ptr, "delete", NULL, 0, &key_zv); zephir_check_call_status(); @@ -428,7 +428,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Weak, doHas) Z_PARAM_STR(key) ZEND_PARSE_PARAMETERS_END(); ZVAL_STR(&key_zv, key); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 339, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 340, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &key_zv)); } @@ -509,7 +509,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Weak, doSet) if (Z_TYPE_P(value) != IS_OBJECT) { RETURN_MM_BOOL(0); } - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 339, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 340, PH_NOISY_CC | PH_READONLY); if (0 == zephir_array_isset_value(&_0, &key_zv)) { _2$$4 = zephir_fetch_class_str_ex(SL("WeakReference"), ZEND_FETCH_CLASS_AUTO); ZEPHIR_CALL_CE_STATIC(&_1$$4, _2$$4, "create", NULL, 0, value); diff --git a/ext/phalcon/storage/adapterfactory.zep.c b/ext/phalcon/storage/adapterfactory.zep.c index 304659e569..730e7236c9 100644 --- a/ext/phalcon/storage/adapterfactory.zep.c +++ b/ext/phalcon/storage/adapterfactory.zep.c @@ -78,7 +78,7 @@ PHP_METHOD(Phalcon_Storage_AdapterFactory, __construct) } else { zephir_get_arrval(&services, services_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1353, factory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1354, factory); ZEPHIR_CALL_METHOD(NULL, this_ptr, "init", NULL, 0, &services); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -155,7 +155,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, 1353, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1354, 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 53de800a84..ce284a4f53 100644 --- a/ext/phalcon/storage/serializer/base64.zep.c +++ b/ext/phalcon/storage/serializer/base64.zep.c @@ -56,7 +56,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, 1354, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1355, 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); @@ -66,7 +66,7 @@ PHP_METHOD(Phalcon_Storage_Serializer_Base64, serialize) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1354, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1355, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "phpBase64Encode", NULL, 0, &_2); zephir_check_call_status(); RETURN_MM(); @@ -121,20 +121,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, 1355, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1356, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1355, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1356, &__$false); } ZEPHIR_INIT_NVAR(&result); ZVAL_STRING(&result, ""); } else { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1355, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1356, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1355, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1356, &__$false); } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1354, &result); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1355, &result); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/storage/serializer/igbinary.zep.c b/ext/phalcon/storage/serializer/igbinary.zep.c index aafd8b5598..8242242ab5 100644 --- a/ext/phalcon/storage/serializer/igbinary.zep.c +++ b/ext/phalcon/storage/serializer/igbinary.zep.c @@ -60,28 +60,28 @@ PHP_METHOD(Phalcon_Storage_Serializer_Igbinary, serialize) ZEPHIR_METHOD_GLOBALS_PTR = pecalloc(1, sizeof(zephir_method_globals), 0); zephir_memory_grow_stack(ZEPHIR_METHOD_GLOBALS_PTR, __func__); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 341, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 342, 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, 341, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 342, PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&result, this_ptr, "doSerialize", NULL, 0, &_2); zephir_check_call_status(); if (UNEXPECTED(Z_TYPE_P(&result) == IS_NULL)) { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 342, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 343, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 342, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 343, &__$false); } ZEPHIR_INIT_NVAR(&result); ZVAL_STRING(&result, ""); } else { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 342, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 343, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 342, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 343, &__$false); } } RETURN_CCTOR(&result); @@ -124,7 +124,7 @@ PHP_METHOD(Phalcon_Storage_Serializer_Igbinary, unserialize) ZEPHIR_CALL_METHOD(&_0, this_ptr, "isSerializable", NULL, 0, data); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 341, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 342, data); } else { ZEPHIR_GLOBAL(warning).enable = zend_is_true(&__$false); ZEPHIR_INIT_VAR(&_1$$4); @@ -143,20 +143,20 @@ PHP_METHOD(Phalcon_Storage_Serializer_Igbinary, unserialize) } if (UNEXPECTED(_3$$4)) { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 342, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 343, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 342, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 343, &__$false); } ZEPHIR_INIT_NVAR(&result); ZVAL_STRING(&result, ""); } else { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 342, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 343, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 342, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 343, &__$false); } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 341, &result); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 342, &result); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/storage/serializer/json.zep.c b/ext/phalcon/storage/serializer/json.zep.c index 6e82439512..bc618eda62 100644 --- a/ext/phalcon/storage/serializer/json.zep.c +++ b/ext/phalcon/storage/serializer/json.zep.c @@ -87,7 +87,7 @@ PHP_METHOD(Phalcon_Storage_Serializer_Json, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1356, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1357, &_0); ZEPHIR_INIT_VAR(&_1); object_init_ex(&_1, phalcon_support_helper_json_decode_ce); if (zephir_has_constructor(&_1)) { @@ -95,7 +95,7 @@ PHP_METHOD(Phalcon_Storage_Serializer_Json, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1357, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1358, &_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, 1358, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1359, 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, 1356, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1358, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_1, 1357, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1359, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_2, "__invoke", NULL, 0, &_3); zephir_check_call_status(); RETURN_MM(); @@ -172,12 +172,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, 1358, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1359, data); } else { - zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_1, 1357, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1$$4, this_ptr, _zephir_prop_1, 1358, 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, 1358, &_2$$4); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1359, &_2$$4); } ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/storage/serializer/php.zep.c b/ext/phalcon/storage/serializer/php.zep.c index 168ec0944c..e99ced2239 100644 --- a/ext/phalcon/storage/serializer/php.zep.c +++ b/ext/phalcon/storage/serializer/php.zep.c @@ -74,13 +74,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, 1359, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1360, 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, 1359, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1360, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "phpSerialize", NULL, 0, &_2); zephir_check_call_status(); RETURN_MM(); @@ -107,7 +107,7 @@ PHP_METHOD(Phalcon_Storage_Serializer_Php, setAllowedClasses) Z_PARAM_ZVAL(allowedClasses) ZEND_PARSE_PARAMETERS_END(); zephir_fetch_params_without_memory_grow(1, 0, &allowedClasses); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1360, allowedClasses); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1361, allowedClasses); RETURN_THISW(); } @@ -158,7 +158,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, 1359, data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1360, data); RETURN_MM_NULL(); } ZEPHIR_INIT_VAR(&_1); @@ -182,7 +182,7 @@ PHP_METHOD(Phalcon_Storage_Serializer_Php, unserialize) ZEPHIR_INIT_VAR(&_5); zephir_create_array(&_5, 1, 0); zephir_memory_observe(&_6); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 1360, PH_NOISY_CC); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_1, 1361, PH_NOISY_CC); zephir_array_update_string(&_5, SL("allowed_classes"), &_6, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(&result, this_ptr, "phpUnserialize", NULL, 0, data, &_5); zephir_check_call_status(); @@ -204,20 +204,20 @@ PHP_METHOD(Phalcon_Storage_Serializer_Php, unserialize) } if (UNEXPECTED(_8)) { if (0) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1361, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1362, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1361, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1362, &__$false); } ZEPHIR_INIT_NVAR(&result); ZVAL_STRING(&result, ""); } else { if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1361, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1362, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1361, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1362, &__$false); } } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1359, &result); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1360, &result); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/support/collection/readonlycollection.zep.c b/ext/phalcon/support/collection/readonlycollection.zep.c index cbd8560aab..6feabe03ed 100644 --- a/ext/phalcon/support/collection/readonlycollection.zep.c +++ b/ext/phalcon/support/collection/readonlycollection.zep.c @@ -125,9 +125,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, 1362, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1363, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1362, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1363, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -166,9 +166,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, 1362, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1363, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1362, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1363, &__$false); } /* try_start_1: */ @@ -186,9 +186,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, 1362, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1363, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1362, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1363, &__$false); } zephir_throw_exception_debug(&ex, "phalcon/Support/Collection/ReadOnlyCollection.zep", 62); ZEPHIR_MM_RESTORE(); @@ -196,9 +196,9 @@ PHP_METHOD(Phalcon_Support_Collection_ReadOnlyCollection, __unserialize) } } if (1) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1362, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1363, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1362, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1363, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -257,7 +257,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, 1362, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1363, 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 d5d2029f2c..4d423e2f79 100644 --- a/ext/phalcon/support/debug.zep.c +++ b/ext/phalcon/support/debug.zep.c @@ -144,7 +144,7 @@ PHP_METHOD(Phalcon_Support_Debug, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1363, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1364, &_0); ZEPHIR_INIT_VAR(&_1); object_init_ex(&_1, phalcon_support_debug_reportbuilder_ce); if (zephir_has_constructor(&_1)) { @@ -152,7 +152,7 @@ PHP_METHOD(Phalcon_Support_Debug, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1364, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1365, &_1); ZEPHIR_MM_RESTORE(); } @@ -175,7 +175,7 @@ PHP_METHOD(Phalcon_Support_Debug, clearVars) ZEPHIR_INIT_VAR(&_0); array_init(&_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1365, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1366, &_0); RETURN_THIS(); } @@ -236,8 +236,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, 1363, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1366, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1364, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1367, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getCssSources", NULL, 0, &_1); zephir_check_call_status(); RETURN_MM(); @@ -266,8 +266,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, 1363, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1366, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1364, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1367, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getJsSources", NULL, 0, &_1); zephir_check_call_status(); RETURN_MM(); @@ -300,7 +300,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, 1363, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1364, PH_NOISY_CC | PH_READONLY); ZEPHIR_RETURN_CALL_METHOD(&_0, "getVersion", NULL, 0); zephir_check_call_status(); RETURN_MM(); @@ -588,14 +588,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, 1363, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1364, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1367, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 1368, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_4, 1369, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_6, this_ptr, _zephir_prop_5, 1370, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_7, this_ptr, _zephir_prop_6, 1366, PH_NOISY_CC | PH_READONLY); - zephir_read_property_cached(&_8, this_ptr, _zephir_prop_7, 1365, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1364, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_1, 1365, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_2, 1368, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4, this_ptr, _zephir_prop_3, 1369, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_4, 1370, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6, this_ptr, _zephir_prop_5, 1371, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_7, this_ptr, _zephir_prop_6, 1367, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8, this_ptr, _zephir_prop_7, 1366, 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); @@ -763,7 +763,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, 1367, &result); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1368, &result); RETURN_THIS(); } @@ -785,7 +785,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, 1363, renderer); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1364, renderer); RETURN_THISW(); } @@ -810,9 +810,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, 1368, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1369, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1368, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1369, &__$false); } RETURN_THISW(); } @@ -839,9 +839,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, 1370, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1371, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1370, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1371, &__$false); } RETURN_THISW(); } @@ -867,9 +867,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, 1369, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1370, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1369, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1370, &__$false); } RETURN_THISW(); } @@ -893,7 +893,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, 1366, &uri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1367, &uri_zv); RETURN_THISW(); } diff --git a/ext/phalcon/support/debug/dump.zep.c b/ext/phalcon/support/debug/dump.zep.c index 005c1bf423..81c160f177 100644 --- a/ext/phalcon/support/debug/dump.zep.c +++ b/ext/phalcon/support/debug/dump.zep.c @@ -148,13 +148,13 @@ PHP_METHOD(Phalcon_Support_Debug_Dump, __construct) zephir_check_call_status(); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1371, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1372, &_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, 1372, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1373, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1372, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1373, &__$false); } ZEPHIR_MM_RESTORE(); } @@ -247,9 +247,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, 1372, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1373, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1372, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1373, &__$false); } } @@ -306,7 +306,7 @@ PHP_METHOD(Phalcon_Support_Debug_Dump, setStyles) add_assoc_stringl_ex(&defaultStyles, SL("str"), SL("color:teal")); ZEPHIR_INIT_VAR(&_1); zephir_fast_array_merge(&_1, &defaultStyles, &styles); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1373, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1374, &_1); RETURN_MM_MEMBER_TYPED(getThis(), "styles", IS_ARRAY); } @@ -350,7 +350,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, 1371, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1372, 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(); @@ -585,7 +585,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, 1373, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1374, PH_NOISY_CC | PH_READONLY); if (!(zephir_array_isset_fetch(&style, &_0, &type_zv, 0))) { RETURN_MM_STRING("color:gray"); } @@ -1030,7 +1030,7 @@ PHP_METHOD(Phalcon_Support_Debug_Dump, output) ZEPHIR_CONCAT_VS(&_50$$11, &_49$$11, "[skipped]\n"); zephir_concat_self(&output, &_50$$11); } else { - zephir_read_property_cached(&_46$$9, this_ptr, _zephir_prop_0, 1372, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_46$$9, this_ptr, _zephir_prop_0, 1373, PH_NOISY_CC | PH_READONLY); _47$$9 = !ZEPHIR_IS_TRUE_IDENTICAL(&_46$$9); if (!(_47$$9)) { _47$$9 = zephir_is_instance_of(variable, SL("stdClass")); @@ -1285,7 +1285,7 @@ PHP_METHOD(Phalcon_Support_Debug_Dump, output) zephir_concat_self(&output, &_105$$9); ZEPHIR_INIT_NVAR(&_37$$9); zephir_get_class(&_37$$9, variable, 0); - zephir_read_property_cached(&_103$$9, this_ptr, _zephir_prop_1, 1374, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_103$$9, this_ptr, _zephir_prop_1, 1375, PH_NOISY_CC | PH_READONLY); if (1 == zephir_fast_in_array(&_37$$9, &_103$$9)) { ZVAL_LONG(&_106$$18, tab); ZEPHIR_CALL_FUNCTION(&_107$$18, "str_repeat", &_10, 5, &space, &_106$$18); @@ -1775,9 +1775,9 @@ PHP_METHOD(Phalcon_Support_Debug_Dump, getTemplate) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1375, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1376, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_1, &name_zv)) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1375, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1376, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_0); zephir_array_fetch(&_0, &_2, &name_zv, PH_NOISY, "phalcon/Support/Debug/Traits/TemplateAwareTrait.zep", 33); } else { diff --git a/ext/phalcon/support/debug/renderer/htmlrenderer.zep.c b/ext/phalcon/support/debug/renderer/htmlrenderer.zep.c index 4566301bd9..3f368bbfb6 100644 --- a/ext/phalcon/support/debug/renderer/htmlrenderer.zep.c +++ b/ext/phalcon/support/debug/renderer/htmlrenderer.zep.c @@ -1979,9 +1979,9 @@ PHP_METHOD(Phalcon_Support_Debug_Renderer_HtmlRenderer, getTemplate) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1376, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1377, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_1, &name_zv)) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1376, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1377, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_0); zephir_array_fetch(&_0, &_2, &name_zv, PH_NOISY, "phalcon/Support/Debug/Traits/TemplateAwareTrait.zep", 33); } else { diff --git a/ext/phalcon/support/debug/report/backtraceitem.zep.c b/ext/phalcon/support/debug/report/backtraceitem.zep.c index e519f0322d..eab32ccf5e 100644 --- a/ext/phalcon/support/debug/report/backtraceitem.zep.c +++ b/ext/phalcon/support/debug/report/backtraceitem.zep.c @@ -245,22 +245,22 @@ PHP_METHOD(Phalcon_Support_Debug_Report_BacktraceItem, __construct) fragment = &fragment_sub; fragment = &__$null; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1377, &functionName_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1378, &type_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1379, &className_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1380, &classLink_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1381, &functionLink_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1378, &functionName_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1379, &type_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1380, &className_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1381, &classLink_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1382, &functionLink_zv); if (hasArgs) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1382, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1383, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1382, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1383, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1383, &args); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1384, &file_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_6, 1384, &args); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_7, 1385, &file_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, line); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1385, &_0); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1386, fragment); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_8, 1386, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_9, 1387, 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 5682e68b20..9d74105eeb 100644 --- a/ext/phalcon/support/debug/report/exceptionreport.zep.c +++ b/ext/phalcon/support/debug/report/exceptionreport.zep.c @@ -187,18 +187,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, 1387, &className_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1388, &message_zv); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1389, &file_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1388, &className_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1389, &message_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_2, 1390, &file_zv); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, line); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1390, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_3, 1391, &_0); if (showBackTrace) { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1391, &__$true); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1392, &__$true); } else { - zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1391, &__$false); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_4, 1392, &__$false); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1392, &uri_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_5, 1393, &uri_zv); } /** @@ -303,7 +303,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, 1393, PH_NOISY_CC); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1394, PH_NOISY_CC); RETURN_MM_BOOL(!(ZEPHIR_IS_EMPTY(&_0))); } @@ -336,7 +336,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, 1394, &backtrace); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1395, &backtrace); RETURN_THIS(); } @@ -363,7 +363,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, 1395, &includedFiles); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1396, &includedFiles); RETURN_THIS(); } @@ -385,7 +385,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, 1396, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1397, &_0); RETURN_THISW(); } @@ -407,7 +407,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, 1397, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1398, &_0); RETURN_THISW(); } @@ -434,7 +434,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, 1398, &request); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1399, &request); RETURN_THIS(); } @@ -461,7 +461,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, 1399, &server); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1400, &server); RETURN_THIS(); } @@ -488,7 +488,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, 1393, &variables); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1394, &variables); RETURN_THIS(); } diff --git a/ext/phalcon/support/debug/traits/templateawaretrait.zep.c b/ext/phalcon/support/debug/traits/templateawaretrait.zep.c index de7a6c182f..e079426652 100644 --- a/ext/phalcon/support/debug/traits/templateawaretrait.zep.c +++ b/ext/phalcon/support/debug/traits/templateawaretrait.zep.c @@ -76,9 +76,9 @@ PHP_METHOD(Phalcon_Support_Debug_Traits_TemplateAwareTrait, getTemplate) zephir_memory_observe(&name_zv); ZVAL_STR_COPY(&name_zv, name); ZEPHIR_INIT_VAR(&_0); - zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1400, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1401, PH_NOISY_CC | PH_READONLY); if (zephir_array_isset_value(&_1, &name_zv)) { - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1400, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1401, PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_NVAR(&_0); zephir_array_fetch(&_0, &_2, &name_zv, PH_NOISY, "phalcon/Support/Debug/Traits/TemplateAwareTrait.zep", 33); } else { diff --git a/ext/phalcon/support/helperfactory.zep.c b/ext/phalcon/support/helperfactory.zep.c index c9108d88c0..50f0b83f81 100644 --- a/ext/phalcon/support/helperfactory.zep.c +++ b/ext/phalcon/support/helperfactory.zep.c @@ -206,7 +206,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, 1401, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1402, 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); @@ -215,7 +215,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, 1401, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_3, this_ptr, _zephir_prop_0, 1402, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_4); zephir_array_fetch(&_4, &_3, &name_zv, PH_NOISY, "phalcon/Support/HelperFactory.zep", 179); RETURN_CCTOR(&_4); diff --git a/ext/phalcon/time/clock/frozenclock.zep.c b/ext/phalcon/time/clock/frozenclock.zep.c index ef2fe5fa61..19b12021ac 100644 --- a/ext/phalcon/time/clock/frozenclock.zep.c +++ b/ext/phalcon/time/clock/frozenclock.zep.c @@ -62,7 +62,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, 1402, now); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1403, now); } /** @@ -186,7 +186,7 @@ PHP_METHOD(Phalcon_Time_Clock_FrozenClock, adjust) /* try_start_1: */ - zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_0, 1402, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$4, this_ptr, _zephir_prop_0, 1403, 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); @@ -218,7 +218,7 @@ PHP_METHOD(Phalcon_Time_Clock_FrozenClock, adjust) ZVAL_LONG(&_8$$6, 2); ZEPHIR_CALL_FUNCTION(NULL, "set_error_handler", NULL, 306, &_7$$6, &_8$$6); zephir_check_call_status(); - zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_0, 1402, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$6, this_ptr, _zephir_prop_0, 1403, 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, 307); @@ -239,7 +239,7 @@ PHP_METHOD(Phalcon_Time_Clock_FrozenClock, adjust) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1402, &modified); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1403, &modified); RETURN_THIS(); } @@ -270,7 +270,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, 1402, now); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1403, now); RETURN_THISW(); } diff --git a/ext/phalcon/time/clock/systemclock.zep.c b/ext/phalcon/time/clock/systemclock.zep.c index 3912a8aaff..97e28e1bde 100644 --- a/ext/phalcon/time/clock/systemclock.zep.c +++ b/ext/phalcon/time/clock/systemclock.zep.c @@ -60,7 +60,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, 1403, timezone); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1404, timezone); } /** @@ -135,7 +135,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, 1403, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1404, 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/factory/factorytrait.zep.c b/ext/phalcon/traits/factory/factorytrait.zep.c index 508e42fc4c..a0aa03da4a 100644 --- a/ext/phalcon/traits/factory/factorytrait.zep.c +++ b/ext/phalcon/traits/factory/factorytrait.zep.c @@ -94,7 +94,7 @@ PHP_METHOD(Phalcon_Traits_Factory_FactoryTrait, getCachedInstance) ZVAL_STR_COPY(&name_zv, name); ZEPHIR_INIT_VAR(&arguments); zephir_get_args_from(&arguments, 1); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1404, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1405, PH_NOISY_CC | PH_READONLY); if (1 != zephir_array_isset_value(&_0, &name_zv)) { ZEPHIR_CALL_METHOD(&definition, this_ptr, "getService", NULL, 0, &name_zv); zephir_check_call_status(); @@ -103,7 +103,7 @@ PHP_METHOD(Phalcon_Traits_Factory_FactoryTrait, getCachedInstance) zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("instances"), &name_zv, &_1$$3); } - zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1404, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2, this_ptr, _zephir_prop_0, 1405, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_3); zephir_array_fetch(&_3, &_2, &name_zv, PH_NOISY, "phalcon/Traits/Factory/FactoryTrait.zep", 46); RETURN_CCTOR(&_3); @@ -154,7 +154,7 @@ PHP_METHOD(Phalcon_Traits_Factory_FactoryTrait, getService) 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, 1405, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1406, PH_NOISY_CC | PH_READONLY); if (1 != zephir_array_isset_value(&_0, &name_zv)) { ZEPHIR_CALL_METHOD(&exceptionClass, this_ptr, "getExceptionClass", NULL, 0); zephir_check_call_status(); @@ -178,7 +178,7 @@ PHP_METHOD(Phalcon_Traits_Factory_FactoryTrait, getService) ZEPHIR_MM_RESTORE(); return; } - zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 1405, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_5, this_ptr, _zephir_prop_0, 1406, PH_NOISY_CC | PH_READONLY); zephir_memory_observe(&_6); zephir_array_fetch(&_6, &_5, &name_zv, PH_NOISY, "phalcon/Traits/Factory/FactoryTrait.zep", 73); RETURN_CCTOR(&_6); @@ -231,7 +231,7 @@ PHP_METHOD(Phalcon_Traits_Factory_FactoryTrait, init) ZEPHIR_CALL_METHOD(&_1, this_ptr, "getServices", NULL, 0); zephir_check_call_status(); zephir_fast_array_merge(&_0, &_1, &services); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1405, &_0); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1406, &_0); ZEPHIR_MM_RESTORE(); } diff --git a/ext/phalcon/translate/adapter/csv.zep.c b/ext/phalcon/translate/adapter/csv.zep.c index 2376930656..38af78a398 100644 --- a/ext/phalcon/translate/adapter/csv.zep.c +++ b/ext/phalcon/translate/adapter/csv.zep.c @@ -162,7 +162,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, 1406, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1407, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &index_zv)); } @@ -208,7 +208,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, 1406, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1407, 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 63c05a1a07..7c654d14cd 100644 --- a/ext/phalcon/translate/adapter/gettext.zep.c +++ b/ext/phalcon/translate/adapter/gettext.zep.c @@ -367,7 +367,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, 1407, &domain_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1408, &domain_zv); } /** @@ -419,7 +419,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, 1408, directory); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1409, directory); if (Z_TYPE_P(directory) == IS_ARRAY) { if (Z_TYPE_P(directory) == IS_STRING) { ZEPHIR_INIT_VAR(&_1$$4); @@ -572,28 +572,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, 1409, &_1); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1410, &_1); ZVAL_UNDEF(&_0); ZVAL_LONG(&_0, category); - zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1410, &_0); - zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1409, PH_NOISY_CC | PH_READONLY); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_1, 1411, &_0); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1410, PH_NOISY_CC | PH_READONLY); if (!ZEPHIR_IS_FALSE_IDENTICAL(&_0)) { - zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 1409, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_2$$3, this_ptr, _zephir_prop_0, 1410, 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, 1409, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_4$$3, this_ptr, _zephir_prop_0, 1410, 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, 1409, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_6$$3, this_ptr, _zephir_prop_0, 1410, 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, 1409, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_8$$3, this_ptr, _zephir_prop_0, 1410, 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(); diff --git a/ext/phalcon/translate/adapter/nativearray.zep.c b/ext/phalcon/translate/adapter/nativearray.zep.c index 0be233f260..7fa6b341c7 100644 --- a/ext/phalcon/translate/adapter/nativearray.zep.c +++ b/ext/phalcon/translate/adapter/nativearray.zep.c @@ -106,7 +106,7 @@ PHP_METHOD(Phalcon_Translate_Adapter_NativeArray, __construct) ZEPHIR_MM_RESTORE(); return; } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1411, &data); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1412, &data); ZEPHIR_MM_RESTORE(); } @@ -156,7 +156,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, 1411, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1412, PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset_value(&_0, &index_zv)); } @@ -204,7 +204,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, 1411, PH_NOISY_CC | PH_READONLY); + zephir_read_property_cached(&_0, this_ptr, _zephir_prop_0, 1412, 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 f898e685f3..07dec7aff4 100644 --- a/ext/phalcon/translate/exceptions/missingrequiredparameter.zep.c +++ b/ext/phalcon/translate/exceptions/missingrequiredparameter.zep.c @@ -62,7 +62,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, 1412, ¶meter_zv); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1413, ¶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 ef19aca9c0..6cb71969f2 100644 --- a/ext/phalcon/translate/translatefactory.zep.c +++ b/ext/phalcon/translate/translatefactory.zep.c @@ -77,7 +77,7 @@ PHP_METHOD(Phalcon_Translate_TranslateFactory, __construct) } else { zephir_get_arrval(&services, services_param); } - zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1413, interpolator); + zephir_update_property_zval_cached(this_ptr, _zephir_prop_0, 1414, interpolator); ZEPHIR_CALL_METHOD(NULL, this_ptr, "init", NULL, 0, &services); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -179,7 +179,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, 1413, PH_NOISY_CC); + zephir_read_property_cached(&_1, this_ptr, _zephir_prop_0, 1414, 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);