From 4d60280d75d10961b134a073fd7df569cb720d88 Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Mon, 18 Apr 2022 22:24:04 -0400 Subject: [PATCH 1/4] added abstract classes for link and refactoring --- phalcon/Html/Link/AbstractLink.zep | 217 ++++++++++++++++++ phalcon/Html/Link/AbstractLinkProvider.zep | 141 ++++++++++++ phalcon/Html/Link/EvolvableLink.zep | 75 ++---- phalcon/Html/Link/EvolvableLinkProvider.zep | 29 +-- .../Interfaces/EvolvableLinkInterface.zep | 76 ++++++ .../EvolvableLinkProviderInterface.zep | 39 ++++ .../Html/Link/Interfaces/LinkInterface.zep | 60 +++++ .../Link/Interfaces/LinkProviderInterface.zep | 32 +++ phalcon/Html/Link/Link.zep | 78 +------ phalcon/Html/Link/LinkProvider.zep | 57 +---- 10 files changed, 605 insertions(+), 199 deletions(-) create mode 100644 phalcon/Html/Link/AbstractLink.zep create mode 100644 phalcon/Html/Link/AbstractLinkProvider.zep create mode 100644 phalcon/Html/Link/Interfaces/EvolvableLinkInterface.zep create mode 100644 phalcon/Html/Link/Interfaces/EvolvableLinkProviderInterface.zep create mode 100644 phalcon/Html/Link/Interfaces/LinkInterface.zep create mode 100644 phalcon/Html/Link/Interfaces/LinkProviderInterface.zep diff --git a/phalcon/Html/Link/AbstractLink.zep b/phalcon/Html/Link/AbstractLink.zep new file mode 100644 index 00000000000..1e7d99aa586 --- /dev/null +++ b/phalcon/Html/Link/AbstractLink.zep @@ -0,0 +1,217 @@ + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ + +namespace Phalcon\Html\Link; + +use Phalcon\Support\Collection; + +/** + * @property array $attributes + * @property string $href + * @property array $rels + * @property bool $templated + */ +abstract class AbstractLink +{ + /** + * @var Collection + */ + protected attributes; + + /** + * @var string + */ + protected href = ""; + + /** + * @var Collection + */ + protected rels; + + /** + * @var bool + */ + protected templated = false; + + /** + * Link constructor. + * + * @param string $rel + * @param string $href + * @param array $attributes + */ + public function __construct( + string rel = "", + string href = "", + array attributes = [] + ) { + let this->attributes = new Collection(attributes), + this->rels = new Collection(), + this->href = href, + this->templated = this->hrefIsTemplated(href); + + if (true !== empty(rel)) { + this->rels->set(rel, true); + } + } + + /** + * Returns a list of attributes that describe the target URI. + * + * @return array + * A key-value list of attributes, where the key is a string and the value + * is either a PHP primitive or an array of PHP strings. If no values are + * found an empty array MUST be returned. + */ + protected function doGetAttributes() -> array + { + return this->attributes->toArray(); + } + + /** + * Returns the target of the link. + * + * The target link must be one of: + * - An absolute URI, as defined by RFC 5988. + * - A relative URI, as defined by RFC 5988. The base of the relative link + * is assumed to be known based on context by the client. + * - A URI template as defined by RFC 6570. + * + * If a URI template is returned, isTemplated() MUST return True. + * + * @return string + */ + protected function doGetHref() -> string + { + return this->href; + } + + /** + * Returns the relationship type(s) of the link. + * + * This method returns 0 or more relationship types for a link, expressed + * as an array of strings. + * + * @return string[] + */ + protected function doGetRels() -> array + { + return this->rels->getKeys(false); + } + + /** + * Returns whether this is a templated link. + * + * @return bool + * True if this link object is templated, False otherwise. + */ + protected function doIsTemplated() -> bool + { + return this->templated; + } + + /** + * Determines if a href is a templated link or not. + * + * @see https://tools.ietf.org/html/rfc6570 + * + * @param string $href + * + * @return bool + */ + protected function hrefIsTemplated(string href) -> bool + { + return ( + false !== mb_strpos(href, "{") && + false !== mb_strpos(href, "}") + ); + } + /** + * @param string $key + * @param mixed $value + * + * @return mixed + */ + protected function doWithAttribute(string key, var value) + { + var newInstance; + + let newInstance = clone this; + + newInstance->attributes->set(key, value); + + return newInstance; + } + + /** + * @param string $href + * + * @return mixed + */ + protected function doWithHref(string href) + { + var newInstance; + + let newInstance = clone this; + + let newInstance->href = href, + newInstance->templated = this->hrefIsTemplated(href); + + return newInstance; + } + + /** + * @param string $key + * + * @return mixed + */ + protected function doWithRel(string key) + { + var newInstance; + + let newInstance = clone this; + + newInstance->rels->set(key, true); + + return newInstance; + } + + /** + * @param string $key + * + * @return mixed + */ + protected function doWithoutAttribute(string key) + { + var newInstance; + + let newInstance = clone this; + + newInstance->attributes->remove(key); + + return newInstance; + } + + /** + * @param string $key + * + * @return mixed + */ + protected function doWithoutRel(string key) + { + var newInstance; + + let newInstance = clone this; + + newInstance->rels->remove(key); + + return newInstance; + } +} diff --git a/phalcon/Html/Link/AbstractLinkProvider.zep b/phalcon/Html/Link/AbstractLinkProvider.zep new file mode 100644 index 00000000000..275973b208e --- /dev/null +++ b/phalcon/Html/Link/AbstractLinkProvider.zep @@ -0,0 +1,141 @@ + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ + +namespace Phalcon\Html\Link; + +use Phalcon\Html\Link\Interfaces\LinkInterface; + +/** + * @property array $links + */ +abstract class AbstractLinkProvider +{ + /** + * @var array + */ + protected links = []; + + /** + * LinkProvider constructor. + * + * @param array $links + */ + public function __construct(array links = []) + { + var link; + + for link in links { + if ( + true === is_a(link, "Phalcon\\Html\\Link\\Interfaces\\LinkInterface") || + true === is_a(link, "Psr\\Link\\LinkInterface") + ) { + let this->links[this->getKey(link)] = link; + } + } + } + + /** + * Returns an iterable of LinkInterface objects. + * + * The iterable may be an array or any PHP \Traversable object. If no links + * are available, an empty array or \Traversable MUST be returned. + * + * @return array + */ + protected function doGetLinks() -> array + { + return this->links; + } + + /** + * Returns an iterable of LinkInterface objects that have a specific + * relationship. + * + * The iterable may be an array or any PHP \Traversable object. If no links + * with that relationship are available, an empty array or \Traversable + * MUST be returned. + * + * @return array + */ + protected function doGetLinksByRel(string rel) -> array + { + var link, rels; + array filtered; + + let filtered = []; + for link in this->links { + let rels = link->getRels(); + if (true === in_array(rel, rels)) { + let filtered[] = link; + } + } + + return filtered; + } + + /** + * Returns an instance with the specified link included. + * + * If the specified link is already present, this method MUST return + * normally without errors. The link is present if $link is === identical + * to a link object already in the collection. + * + * @param mixed $link A link object that should be included in this + * collection. + * + * @return $this + */ + protected function doWithLink(link) + { + var key, newInstance; + + let key = this->getKey(link), + newInstance = clone this; + + let newInstance->links[key] = link; + + return newInstance; + } + + /** + * Returns an instance with the specified link removed. + * + * If the specified link is not present, this method MUST return normally + * without errors. The link is present if $link is === identical to a link + * object already in the collection. + * + * @param mixed $link The link to remove. + * + * @return $this + */ + protected function doWithoutLink(link) + { + var key, newInstance; + + let key = this->getKey(link), + newInstance = clone this; + + unset(newInstance->links[key]); + + return newInstance; + } + + /** + * Returns the object hash key + * + * @param mixed link + * + * @return string + */ + protected function getKey(link) -> string + { + return spl_object_hash(link); + } +} diff --git a/phalcon/Html/Link/EvolvableLink.zep b/phalcon/Html/Link/EvolvableLink.zep index ac231e08862..57788705b72 100644 --- a/phalcon/Html/Link/EvolvableLink.zep +++ b/phalcon/Html/Link/EvolvableLink.zep @@ -10,7 +10,7 @@ namespace Phalcon\Html\Link; -use Psr\Link\EvolvableLinkInterface; +use Phalcon\Html\Link\Interfaces\EvolvableLinkInterface; /** * Class Phalcon\Http\Link\EvolvableLink @@ -28,20 +28,12 @@ class EvolvableLink extends Link implements EvolvableLinkInterface * If the specified attribute is already present, it will be overwritten * with the new value. * - * @param string attribute The attribute to include. - * @param string value The value of the attribute to set. - * - * @return static + * @param string $attribute The attribute to include. + * @param string $value The value of the attribute to set. */ - public function withAttribute(var attribute, var value) + public function withAttribute(var attribute, var value) -> { - var newInstance; - - let newInstance = clone this; - - newInstance->attributes->set(attribute, value); - - return newInstance; + return this->doWithAttribute(attribute, value); } /** @@ -59,17 +51,11 @@ class EvolvableLink extends Link implements EvolvableLinkInterface * An implementing library SHOULD evaluate a passed object to a string * immediately rather than waiting for it to be returned later. * - * @return static + * @param string $rel The relationship value to add. */ - public function withHref(var href) + public function withHref(string href) -> { - var newInstance; - - let newInstance = clone this, - newInstance->href = href, - newInstance->templated = this->hrefIsTemplated(href); - - return newInstance; + return this->doWithHref(href); } /** @@ -78,20 +64,11 @@ class EvolvableLink extends Link implements EvolvableLinkInterface * If the specified rel is already present, this method MUST return * normally without errors, but without adding the rel a second time. * - * @param string rel - * The relationship value to add. - * - * @return static + * @param string $rel The relationship value to add. */ - public function withRel(var rel) + public function withRel(string rel) -> { - var newInstance; - - let newInstance = clone this; - - newInstance->rels->set(rel, true); - - return newInstance; + return this->doWithRel(rel); } /** @@ -100,20 +77,11 @@ class EvolvableLink extends Link implements EvolvableLinkInterface * If the specified attribute is not present, this method MUST return * normally without errors. * - * @param string attribute - * The attribute to remove. - * - * @return static + * @param string $attribute The attribute to remove. */ - public function withoutAttribute(var attribute) + public function withoutAttribute(string attribute) -> { - var newInstance; - - let newInstance = clone this; - - newInstance->attributes->remove(attribute); - - return newInstance; + return this->doWithoutAttribute(attribute); } /** @@ -122,19 +90,10 @@ class EvolvableLink extends Link implements EvolvableLinkInterface * If the specified rel is not present, this method MUST return * normally without errors. * - * @param string rel - * The relationship value to exclude. - * - * @return static + * @param string $rel The relationship value to exclude. */ - public function withoutRel(var rel) + public function withoutRel(string rel) -> { - var newInstance; - - let newInstance = clone this; - - newInstance->rels->remove(rel); - - return newInstance; + return this->doWithoutRel(rel); } } diff --git a/phalcon/Html/Link/EvolvableLinkProvider.zep b/phalcon/Html/Link/EvolvableLinkProvider.zep index 81add25dbf0..a9a97700f74 100644 --- a/phalcon/Html/Link/EvolvableLinkProvider.zep +++ b/phalcon/Html/Link/EvolvableLinkProvider.zep @@ -10,8 +10,8 @@ namespace Phalcon\Html\Link; -use Psr\Link\EvolvableLinkProviderInterface; -use Psr\Link\LinkInterface; +use Phalcon\Html\Link\Interfaces\EvolvableLinkProviderInterface; +use Phalcon\Html\Link\Interfaces\LinkInterface; /** * Class Phalcon\Http\Link\LinkProvider @@ -32,16 +32,9 @@ class EvolvableLinkProvider extends LinkProvider implements EvolvableLinkProvide * * @return static */ - public function withLink( link) + public function withLink( link) -> { - var key, newInstance; - - let key = this->getKey(link), - newInstance = clone this; - - let newInstance->links[key] = link; - - return newInstance; + return this->doWithLink(link); } /** @@ -56,18 +49,8 @@ class EvolvableLinkProvider extends LinkProvider implements EvolvableLinkProvide * * @return static */ - public function withoutLink( link) + public function withoutLink( link) -> { - var key, links, newInstance; - - let key = this->getKey(link), - newInstance = clone this, - links = this->links; - - unset links[key]; - - let newInstance->links = links; - - return newInstance; + return this->doWithoutLink(link); } } diff --git a/phalcon/Html/Link/Interfaces/EvolvableLinkInterface.zep b/phalcon/Html/Link/Interfaces/EvolvableLinkInterface.zep new file mode 100644 index 00000000000..78fb874a2bf --- /dev/null +++ b/phalcon/Html/Link/Interfaces/EvolvableLinkInterface.zep @@ -0,0 +1,76 @@ + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ + +namespace Phalcon\Html\Link\Interfaces; + +/** + * An evolvable link value object. + */ +interface EvolvableLinkInterface extends LinkInterface +{ + /** + * Returns an instance with the specified href. + * + * @param string $href + * The href value to include. It must be one of: + * - An absolute URI, as defined by RFC 5988. + * - A relative URI, as defined by RFC 5988. The base of the relative + * link is assumed to be known based on context by the client. + * - A URI template as defined by RFC 6570. + * - An object implementing __toString() that produces one of the + * above values. + * + * An implementing library SHOULD evaluate a passed object to a string + * immediately rather than waiting for it to be returned later. + */ + public function withHref(string href) -> ; + + /** + * Returns an instance with the specified relationship included. + * + * If the specified rel is already present, this method MUST return + * normally without errors, but without adding the rel a second time. + * + * @param string $rel The relationship value to add. + */ + public function withRel(string rel) -> ; + + /** + * Returns an instance with the specified relationship excluded. + * + * If the specified rel is already not present, this method MUST return + * normally without errors. + * + * @param string $rel The relationship value to exclude. + */ + public function withoutRel(string rel) -> ; + + /** + * Returns an instance with the specified attribute added. + * + * If the specified attribute is already present, it will be overwritten + * with the new value. + * + * @param string $attribute The attribute to include. + * @param string $value The value of the attribute to set. + */ + public function withAttribute(string attribute, string value) -> ; + + + /** + * Returns an instance with the specified attribute excluded. + * + * If the specified attribute is not present, this method MUST return + * normally without errors. + * + * @param string $attribute The attribute to remove. + */ + public function withoutAttribute(string attribute) -> ; +} diff --git a/phalcon/Html/Link/Interfaces/EvolvableLinkProviderInterface.zep b/phalcon/Html/Link/Interfaces/EvolvableLinkProviderInterface.zep new file mode 100644 index 00000000000..a59beb6f757 --- /dev/null +++ b/phalcon/Html/Link/Interfaces/EvolvableLinkProviderInterface.zep @@ -0,0 +1,39 @@ + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ + +namespace Phalcon\Html\Link\Interfaces; + +/** + * An evolvable link provider value object. + */ +interface EvolvableLinkProviderInterface extends LinkProviderInterface +{ + /** + * Returns an instance with the specified link included. + * + * If the specified link is already present, this method MUST return + * normally without errors. The link is present if $link is === identical + * to a link object already in the collection. + * + * @param LinkInterface $link A link object that should be included in this collection. + */ + public function withLink( link) -> ; + + /** + * Returns an instance with the specifed link removed. + * + * If the specified link is not present, this method MUST return normally + * without errors. The link is present if $link is === identical to a link + * object already in the collection. + * + * @param LinkInterface $link The link to remove. + */ + public function withoutLink( link) -> ; +} diff --git a/phalcon/Html/Link/Interfaces/LinkInterface.zep b/phalcon/Html/Link/Interfaces/LinkInterface.zep new file mode 100644 index 00000000000..9edf8b0840e --- /dev/null +++ b/phalcon/Html/Link/Interfaces/LinkInterface.zep @@ -0,0 +1,60 @@ + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ + +namespace Phalcon\Html\Link\Interfaces; + +/** + * A readable link object. + */ +interface LinkInterface +{ + /** + * Returns a list of attributes that describe the target URI. + * + * @return array + * A key-value list of attributes, where the key is a string and the value + * is either a PHP primitive or an array of PHP strings. If no values are + * found an empty array MUST be returned. + */ + public function getAttributes() -> array; + + /** + * Returns the target of the link. + * + * The target link must be one of: + * - An absolute URI, as defined by RFC 5988. + * - A relative URI, as defined by RFC 5988. The base of the relative link + * is assumed to be known based on context by the client. + * - A URI template as defined by RFC 6570. + * + * If a URI template is returned, isTemplated() MUST return True. + * + * @return string + */ + public function getHref() -> string; + + /** + * Returns the relationship type(s) of the link. + * + * This method returns 0 or more relationship types for a link, expressed + * as an array of strings. + * + * @return string[] + */ + public function getRels() -> array; + + /** + * Returns whether this is a templated link. + * + * @return bool + * True if this link object is templated, False otherwise. + */ + public function isTemplated() -> bool; +} diff --git a/phalcon/Html/Link/Interfaces/LinkProviderInterface.zep b/phalcon/Html/Link/Interfaces/LinkProviderInterface.zep new file mode 100644 index 00000000000..abe0d27e775 --- /dev/null +++ b/phalcon/Html/Link/Interfaces/LinkProviderInterface.zep @@ -0,0 +1,32 @@ + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ + +namespace Phalcon\Html\Link\Interfaces; + +/** + * A link provider object. + */ +interface LinkProviderInterface +{ + /** + * Returns an array of LinkInterface objects. + * + * @return LinkInterface[] + */ + public function getLinks() -> array; + + /** + * Returns an array of LinkInterface objects that have a specific + * relationship. + * + * @return LinkInterface[] + */ + public function getLinksByRel(string rel) -> array; +} diff --git a/phalcon/Html/Link/Link.zep b/phalcon/Html/Link/Link.zep index cb2f497e79b..5cedb8239bd 100644 --- a/phalcon/Html/Link/Link.zep +++ b/phalcon/Html/Link/Link.zep @@ -12,7 +12,7 @@ namespace Phalcon\Html\Link; use Phalcon\Support\Collection; use Phalcon\Support\Collection\CollectionInterface; -use Psr\Link\LinkInterface; +use Phalcon\Html\Link\Interfaces\LinkInterface; /** * Class Phalcon\Http\Link\Link @@ -22,49 +22,8 @@ use Psr\Link\LinkInterface; * @property array rels * @property bool templated */ -class Link implements LinkInterface +class Link extends AbstractLink implements LinkInterface { - /** - * @var Collection|CollectionInterface - */ - protected attributes; - - /** - * @var string - */ - protected href = ""; - - /** - * @var Collection|CollectionInterface - */ - protected rels; - - /** - * @var bool - */ - protected templated = false; - - /** - * Link constructor. - * - * @param string rel - * @param string href - */ - public function __construct( - string rel = "", - string href = "", - array attributes = [] - ) { - let this->rels = new Collection(), - this->attributes = new Collection(attributes), - this->href = href, - this->templated = this->hrefIsTemplated(href); - - if !empty rel { - this->rels->set(rel, true); - } - } - /** * Returns a list of attributes that describe the target URI. * @@ -73,9 +32,9 @@ class Link implements LinkInterface * is either a PHP primitive or an array of PHP strings. If no values are * found an empty array MUST be returned. */ - public function getAttributes() + public function getAttributes() -> array { - return this->attributes->toArray(); + return this->doGetAttributes(); } /** @@ -91,9 +50,9 @@ class Link implements LinkInterface * * @return string */ - public function getHref() + public function getHref() -> string { - return this->href; + return this->doGetHref(); } /** @@ -104,9 +63,9 @@ class Link implements LinkInterface * * @return string[] */ - public function getRels() + public function getRels() -> array { - return this->rels->getKeys(false); + return this->doGetRels(); } /** @@ -114,25 +73,8 @@ class Link implements LinkInterface * * @return bool True if this link object is templated, False otherwise. */ - public function isTemplated() - { - return this->templated; - } - - /** - * Determines if a href is a templated link or not. - * - * @see https://tools.ietf.org/html/rfc6570 - * - * @param string href - * - * @return bool - */ - protected function hrefIsTemplated(string href) -> bool + public function isTemplated() -> bool { - return ( - false !== strpos(href, "{") && - false !== strrpos(href, "}") - ); + return this->doIsTemplated(); } } diff --git a/phalcon/Html/Link/LinkProvider.zep b/phalcon/Html/Link/LinkProvider.zep index 584b5a3e600..190b4a64ba8 100644 --- a/phalcon/Html/Link/LinkProvider.zep +++ b/phalcon/Html/Link/LinkProvider.zep @@ -10,35 +10,14 @@ namespace Phalcon\Html\Link; -use Psr\Link\LinkInterface; -use Psr\Link\LinkProviderInterface; +use Phalcon\Html\Link\Interfaces\LinkInterface; +use Phalcon\Html\Link\Interfaces\LinkProviderInterface; /** * @property LinkInterface[] links */ -class LinkProvider implements LinkProviderInterface +class LinkProvider extends AbstractLinkProvider implements LinkProviderInterface { - /** - * @var LinkInterface[] - */ - protected links = []; - - /** - * LinkProvider constructor. - * - * @param array links - */ - public function __construct(array links = []) - { - var link; - - for link in links { - if link instanceof LinkInterface { - let this->links[this->getKey(link)] = link; - } - } - } - /** * Returns an iterable of LinkInterface objects. * @@ -47,9 +26,9 @@ class LinkProvider implements LinkProviderInterface * * @return LinkInterface[]|\Traversable */ - public function getLinks() + public function getLinks() -> array { - return this->links; + return this->doGetLinks(); } /** @@ -62,30 +41,8 @@ class LinkProvider implements LinkProviderInterface * * @return LinkInterface[]|\Traversable */ - public function getLinksByRel(var rel) - { - var link, links, rels; - - let links = []; - for link in this->links { - let rels = link->getRels(); - if true === in_array(rel, rels) { - let links[] = link; - } - } - - return links; - } - - /** - * Returns the object hash key - * - * @param LinkInterface link - * - * @return string - */ - protected function getKey( link) -> string + public function getLinksByRel(var rel) -> array { - return spl_object_hash(link); + return this->doGetLinksByRel(rel); } } From 41e6f4029724c1a52a8a809465f9fbcfd4377590 Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Mon, 18 Apr 2022 22:24:17 -0400 Subject: [PATCH 2/4] adjusted tests --- tests/unit/Html/Link/EvolvableLink/ConstructCest.php | 2 +- tests/unit/Html/Link/EvolvableLinkProvider/ConstructCest.php | 2 +- tests/unit/Html/Link/Link/ConstructCest.php | 2 +- tests/unit/Html/Link/LinkProvider/ConstructCest.php | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/unit/Html/Link/EvolvableLink/ConstructCest.php b/tests/unit/Html/Link/EvolvableLink/ConstructCest.php index 4dd9d4252a8..d653c475752 100644 --- a/tests/unit/Html/Link/EvolvableLink/ConstructCest.php +++ b/tests/unit/Html/Link/EvolvableLink/ConstructCest.php @@ -14,7 +14,7 @@ namespace Phalcon\Tests\Unit\Html\Link\EvolvableLink; use Phalcon\Html\Link\EvolvableLink; -use Psr\Link\EvolvableLinkInterface; +use Phalcon\Html\Link\Interfaces\EvolvableLinkInterface; use UnitTester; /** diff --git a/tests/unit/Html/Link/EvolvableLinkProvider/ConstructCest.php b/tests/unit/Html/Link/EvolvableLinkProvider/ConstructCest.php index af6f1154344..3dbb76574e9 100644 --- a/tests/unit/Html/Link/EvolvableLinkProvider/ConstructCest.php +++ b/tests/unit/Html/Link/EvolvableLinkProvider/ConstructCest.php @@ -14,7 +14,7 @@ namespace Phalcon\Tests\Unit\Html\Link\EvolvableLinkProvider; use Phalcon\Html\Link\EvolvableLinkProvider; -use Psr\Link\EvolvableLinkProviderInterface; +use Phalcon\Html\Link\Interfaces\EvolvableLinkProviderInterface; use UnitTester; /** diff --git a/tests/unit/Html/Link/Link/ConstructCest.php b/tests/unit/Html/Link/Link/ConstructCest.php index e4c13026a04..08a8f1ac844 100644 --- a/tests/unit/Html/Link/Link/ConstructCest.php +++ b/tests/unit/Html/Link/Link/ConstructCest.php @@ -14,7 +14,7 @@ namespace Phalcon\Tests\Unit\Html\Link\Link; use Phalcon\Html\Link\Link; -use Psr\Link\LinkInterface; +use Phalcon\Html\Link\Interfaces\LinkInterface; use UnitTester; /** diff --git a/tests/unit/Html/Link/LinkProvider/ConstructCest.php b/tests/unit/Html/Link/LinkProvider/ConstructCest.php index 86db49414e9..905378fb057 100644 --- a/tests/unit/Html/Link/LinkProvider/ConstructCest.php +++ b/tests/unit/Html/Link/LinkProvider/ConstructCest.php @@ -15,7 +15,7 @@ use Phalcon\Html\Link\Link; use Phalcon\Html\Link\LinkProvider; -use Psr\Link\LinkProviderInterface; +use Phalcon\Html\Link\Interfaces\LinkProviderInterface; use UnitTester; /** From 109b2069a2c6775deada78aed786ef1d5a18b0f5 Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Mon, 18 Apr 2022 22:24:26 -0400 Subject: [PATCH 3/4] refreshing ext --- ext/config.m4 | 8 +- ext/config.w32 | 3 +- ext/phalcon.c | 12 + ext/phalcon.h | 6 + ext/phalcon/config/configfactory.zep.c | 4 +- ext/phalcon/di/factorydefault.zep.c | 2 +- ext/phalcon/di/factorydefault/cli.zep.c | 2 +- ext/phalcon/encryption/crypt.zep.c | 4 +- .../encryption/crypt/padding/ansi.zep.c | 8 +- .../encryption/crypt/padding/iso10126.zep.c | 8 +- .../encryption/crypt/padding/isoiek.zep.c | 10 +- .../encryption/crypt/padding/pkcs7.zep.c | 6 +- .../encryption/crypt/padding/space.zep.c | 4 +- .../encryption/crypt/padding/zero.zep.c | 6 +- ext/phalcon/encryption/security.zep.c | 18 +- .../encryption/security/jwt/builder.zep.c | 18 +- .../encryption/security/jwt/signer/hmac.zep.c | 4 +- .../security/jwt/token/parser.zep.c | 26 +- .../encryption/security/jwt/validator.zep.c | 6 +- ext/phalcon/encryption/security/random.zep.c | 12 +- ext/phalcon/events/manager.zep.c | 14 +- ext/phalcon/filter/filter.zep.c | 28 +- ext/phalcon/filter/filterfactory.zep.c | 2 +- ext/phalcon/filter/sanitize/absint.zep.c | 4 +- ext/phalcon/filter/sanitize/email.zep.c | 2 +- ext/phalcon/filter/sanitize/floatval.zep.c | 2 +- ext/phalcon/filter/sanitize/intval.zep.c | 2 +- ext/phalcon/filter/sanitize/lower.zep.c | 2 +- ext/phalcon/filter/sanitize/special.zep.c | 2 +- ext/phalcon/filter/sanitize/specialfull.zep.c | 2 +- ext/phalcon/filter/sanitize/stringval.zep.c | 2 +- ext/phalcon/filter/sanitize/striptags.zep.c | 2 +- ext/phalcon/filter/sanitize/upper.zep.c | 2 +- ext/phalcon/filter/sanitize/upperwords.zep.c | 4 +- ext/phalcon/filter/sanitize/url.zep.c | 2 +- ext/phalcon/filter/validation.zep.c | 8 +- .../filter/validation/validator/alnum.zep.c | 2 +- .../validation/validator/confirmation.zep.c | 4 +- .../validation/validator/creditcard.zep.c | 10 +- .../filter/validation/validator/date.zep.c | 2 +- .../filter/validation/validator/digit.zep.c | 2 +- .../filter/validation/validator/email.zep.c | 2 +- .../validation/validator/exclusionin.zep.c | 2 +- .../filter/validation/validator/file.zep.c | 40 +- .../validation/validator/file/mimetype.zep.c | 6 +- .../validator/file/resolution/equal.zep.c | 2 +- .../validator/file/resolution/max.zep.c | 2 +- .../validator/file/resolution/min.zep.c | 2 +- .../validation/validator/inclusionin.zep.c | 2 +- .../filter/validation/validator/ip.zep.c | 2 +- .../validation/validator/stringlength.zep.c | 8 +- .../validation/validator/uniqueness.zep.c | 4 +- .../filter/validation/validator/url.zep.c | 4 +- ext/phalcon/forms/form.zep.c | 16 +- ext/phalcon/forms/manager.zep.c | 2 +- ext/phalcon/html/attributes.zep.c | 4 +- ext/phalcon/html/breadcrumbs.zep.c | 2 +- ext/phalcon/html/escaper.zep.c | 24 +- ext/phalcon/html/helper/input/checkbox.zep.c | 4 +- ext/phalcon/html/helper/input/select.zep.c | 2 +- ext/phalcon/html/helper/meta.zep.c | 6 +- ext/phalcon/html/helper/title.zep.c | 2 +- ext/phalcon/html/link/abstractlink.zep.c | 479 ++++++++++++++++++ ext/phalcon/html/link/abstractlink.zep.h | 78 +++ .../html/link/abstractlinkprovider.zep.c | 390 ++++++++++++++ .../html/link/abstractlinkprovider.zep.h | 52 ++ ext/phalcon/html/link/evolvablelink.zep.c | 130 ++--- ext/phalcon/html/link/evolvablelink.zep.h | 18 +- .../html/link/evolvablelinkprovider.zep.c | 40 +- .../html/link/evolvablelinkprovider.zep.h | 8 +- .../interfaces/evolvablelinkinterface.zep.c | 86 ++++ .../interfaces/evolvablelinkinterface.zep.h | 34 ++ .../evolvablelinkproviderinterface.zep.c | 53 ++ .../evolvablelinkproviderinterface.zep.h | 18 + .../html/link/interfaces/linkinterface.zep.c | 71 +++ .../html/link/interfaces/linkinterface.zep.h | 24 + .../interfaces/linkproviderinterface.zep.c | 45 ++ .../interfaces/linkproviderinterface.zep.h | 17 + ext/phalcon/html/link/link.zep.c | 174 +------ ext/phalcon/html/link/link.zep.h | 42 +- ext/phalcon/html/link/linkprovider.zep.c | 195 +------ ext/phalcon/html/link/linkprovider.zep.h | 28 +- ext/phalcon/http/cookie.zep.c | 24 +- .../http/message/abstractrequest.zep.c | 6 +- ext/phalcon/http/message/request.zep.c | 8 +- ext/phalcon/http/message/requestfactory.zep.c | 2 +- ext/phalcon/http/message/response.zep.c | 12 +- .../http/message/responsefactory.zep.c | 4 +- ext/phalcon/http/message/serverrequest.zep.c | 16 +- .../http/message/serverrequestfactory.zep.c | 76 +-- ext/phalcon/http/message/streamfactory.zep.c | 4 +- ext/phalcon/http/message/uploadedfile.zep.c | 22 +- .../http/message/uploadedfilefactory.zep.c | 2 +- ext/phalcon/http/message/uri.zep.c | 82 +-- ext/phalcon/http/message/urifactory.zep.c | 2 +- ext/phalcon/http/request.zep.c | 158 +++--- ext/phalcon/http/request/file.zep.c | 18 +- ext/phalcon/http/response.zep.c | 22 +- ext/phalcon/http/response/cookies.zep.c | 2 +- ext/phalcon/http/response/headers.zep.c | 14 +- .../image/adapter/abstractadapter.zep.c | 10 +- ext/phalcon/image/adapter/gd.zep.c | 246 ++++----- ext/phalcon/image/adapter/imagick.zep.c | 2 +- ext/phalcon/image/imagefactory.zep.c | 6 +- ext/phalcon/logger/adapter/stream.zep.c | 2 +- ext/phalcon/mvc/model.zep.c | 2 +- ext/phalcon/mvc/model/criteria.zep.c | 4 +- ext/phalcon/mvc/model/query.zep.c | 4 +- ext/phalcon/mvc/model/query/builder.zep.c | 4 +- ext/phalcon/mvc/model/resultset.zep.c | 22 +- ext/phalcon/mvc/model/resultset/complex.zep.c | 2 +- ext/phalcon/mvc/view.zep.c | 6 +- ext/phalcon/mvc/view/engine/volt.zep.c | 6 +- .../mvc/view/engine/volt/compiler.zep.c | 2 +- ext/phalcon/mvc/view/simple.zep.c | 4 +- ext/phalcon/session/adapter/stream.zep.c | 2 +- ext/phalcon/session/manager.zep.c | 2 +- ext/phalcon/storage/adapter/stream.zep.c | 4 +- ext/phalcon/support/helper/arr/last.zep.c | 2 +- .../support/helper/file/basename.zep.c | 4 +- ext/phalcon/support/helper/str/concat.zep.c | 2 +- .../support/helper/str/dirfromfile.zep.c | 2 +- ext/phalcon/support/helper/str/dynamic.zep.c | 8 +- ext/phalcon/support/helper/str/includes.zep.c | 2 +- ext/phalcon/support/helper/str/random.zep.c | 22 +- ext/phalcon/tag.zep.c | 4 +- ext/phalcon/tag/select.zep.c | 4 +- .../translate/interpolator/indexedarray.zep.c | 2 +- 128 files changed, 2091 insertions(+), 1152 deletions(-) create mode 100644 ext/phalcon/html/link/abstractlink.zep.c create mode 100644 ext/phalcon/html/link/abstractlink.zep.h create mode 100644 ext/phalcon/html/link/abstractlinkprovider.zep.c create mode 100644 ext/phalcon/html/link/abstractlinkprovider.zep.h create mode 100644 ext/phalcon/html/link/interfaces/evolvablelinkinterface.zep.c create mode 100644 ext/phalcon/html/link/interfaces/evolvablelinkinterface.zep.h create mode 100644 ext/phalcon/html/link/interfaces/evolvablelinkproviderinterface.zep.c create mode 100644 ext/phalcon/html/link/interfaces/evolvablelinkproviderinterface.zep.h create mode 100644 ext/phalcon/html/link/interfaces/linkinterface.zep.c create mode 100644 ext/phalcon/html/link/interfaces/linkinterface.zep.h create mode 100644 ext/phalcon/html/link/interfaces/linkproviderinterface.zep.c create mode 100644 ext/phalcon/html/link/interfaces/linkproviderinterface.zep.h diff --git a/ext/config.m4 b/ext/config.m4 index 81122e5334f..fae4ccd56c7 100644 --- a/ext/config.m4 +++ b/ext/config.m4 @@ -48,6 +48,8 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/db/adapter/abstractadapter.zep.c phalcon/db/dialectinterface.zep.c phalcon/html/helper/abstractseries.zep.c + phalcon/html/link/interfaces/linkinterface.zep.c + phalcon/html/link/interfaces/linkproviderinterface.zep.c phalcon/http/message/abstractmessage.zep.c phalcon/logger/adapter/adapterinterface.zep.c phalcon/mvc/model/resultsetinterface.zep.c @@ -92,6 +94,8 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/encryption/security/jwt/token/abstractitem.zep.c phalcon/filter/validation/abstractvalidatorcomposite.zep.c phalcon/flash/abstractflash.zep.c + phalcon/html/link/abstractlink.zep.c + phalcon/html/link/abstractlinkprovider.zep.c phalcon/http/message/abstractrequest.zep.c phalcon/http/message/responsestatuscodeinterface.zep.c phalcon/image/adapter/abstractadapter.zep.c @@ -137,6 +141,8 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/html/helper/input/checkbox.zep.c phalcon/html/helper/ol.zep.c phalcon/html/helper/style.zep.c + phalcon/html/link/interfaces/evolvablelinkinterface.zep.c + phalcon/html/link/interfaces/evolvablelinkproviderinterface.zep.c phalcon/html/link/link.zep.c phalcon/html/link/linkprovider.zep.c phalcon/html/link/serializer/serializerinterface.zep.c @@ -649,7 +655,7 @@ if test "$PHP_PHALCON" = "yes"; then phalcon/mvc/url/utils.c" PHP_NEW_EXTENSION(phalcon, $phalcon_sources, $ext_shared,, ) PHP_ADD_BUILD_DIR([$ext_builddir/kernel/]) - for dir in "phalcon phalcon/acl phalcon/acl/adapter phalcon/annotations phalcon/annotations/adapter phalcon/application phalcon/assets phalcon/assets/asset phalcon/assets/filters phalcon/assets/inline phalcon/autoload phalcon/cache phalcon/cache/adapter phalcon/cache/exception phalcon/cli phalcon/cli/console phalcon/cli/dispatcher phalcon/cli/router phalcon/config phalcon/config/adapter phalcon/container phalcon/datamapper/pdo phalcon/datamapper/pdo/connection phalcon/datamapper/pdo/exception phalcon/datamapper/pdo/profiler phalcon/datamapper/query phalcon/db phalcon/db/adapter phalcon/db/adapter/pdo phalcon/db/dialect phalcon/db/profiler phalcon/db/result phalcon/di phalcon/di/exception phalcon/di/factorydefault phalcon/di/service phalcon/dispatcher phalcon/domain/payload phalcon/encryption phalcon/encryption/crypt phalcon/encryption/crypt/exception phalcon/encryption/crypt/padding phalcon/encryption/security phalcon/encryption/security/jwt phalcon/encryption/security/jwt/exceptions phalcon/encryption/security/jwt/signer phalcon/encryption/security/jwt/token phalcon/events phalcon/factory phalcon/filter phalcon/filter/sanitize phalcon/filter/validation phalcon/filter/validation/validator phalcon/filter/validation/validator/file phalcon/filter/validation/validator/file/resolution phalcon/filter/validation/validator/file/size phalcon/filter/validation/validator/stringlength phalcon/flash phalcon/forms phalcon/forms/element phalcon/html phalcon/html/attributes phalcon/html/escaper phalcon/html/helper phalcon/html/helper/input phalcon/html/link phalcon/html/link/serializer phalcon/http phalcon/http/cookie phalcon/http/message phalcon/http/message/exception phalcon/http/message/stream phalcon/http/request phalcon/http/response phalcon/http/server phalcon/image phalcon/image/adapter phalcon/logger phalcon/logger/adapter phalcon/logger/formatter phalcon/messages phalcon/mvc phalcon/mvc/application phalcon/mvc/controller phalcon/mvc/dispatcher phalcon/mvc/micro phalcon/mvc/model phalcon/mvc/model/behavior phalcon/mvc/model/binder phalcon/mvc/model/metadata phalcon/mvc/model/metadata/strategy phalcon/mvc/model/query phalcon/mvc/model/resultset phalcon/mvc/model/transaction phalcon/mvc/router phalcon/mvc/url phalcon/mvc/view phalcon/mvc/view/engine phalcon/mvc/view/engine/volt phalcon/paginator phalcon/paginator/adapter phalcon/session phalcon/session/adapter phalcon/storage phalcon/storage/adapter phalcon/storage/serializer phalcon/support phalcon/support/collection phalcon/support/debug phalcon/support/helper phalcon/support/helper/arr phalcon/support/helper/file phalcon/support/helper/json phalcon/support/helper/number phalcon/support/helper/str phalcon/tag phalcon/translate phalcon/translate/adapter phalcon/translate/interpolator"; do + for dir in "phalcon phalcon/acl phalcon/acl/adapter phalcon/annotations phalcon/annotations/adapter phalcon/application phalcon/assets phalcon/assets/asset phalcon/assets/filters phalcon/assets/inline phalcon/autoload phalcon/cache phalcon/cache/adapter phalcon/cache/exception phalcon/cli phalcon/cli/console phalcon/cli/dispatcher phalcon/cli/router phalcon/config phalcon/config/adapter phalcon/container phalcon/datamapper/pdo phalcon/datamapper/pdo/connection phalcon/datamapper/pdo/exception phalcon/datamapper/pdo/profiler phalcon/datamapper/query phalcon/db phalcon/db/adapter phalcon/db/adapter/pdo phalcon/db/dialect phalcon/db/profiler phalcon/db/result phalcon/di phalcon/di/exception phalcon/di/factorydefault phalcon/di/service phalcon/dispatcher phalcon/domain/payload phalcon/encryption phalcon/encryption/crypt phalcon/encryption/crypt/exception phalcon/encryption/crypt/padding phalcon/encryption/security phalcon/encryption/security/jwt phalcon/encryption/security/jwt/exceptions phalcon/encryption/security/jwt/signer phalcon/encryption/security/jwt/token phalcon/events phalcon/factory phalcon/filter phalcon/filter/sanitize phalcon/filter/validation phalcon/filter/validation/validator phalcon/filter/validation/validator/file phalcon/filter/validation/validator/file/resolution phalcon/filter/validation/validator/file/size phalcon/filter/validation/validator/stringlength phalcon/flash phalcon/forms phalcon/forms/element phalcon/html phalcon/html/attributes phalcon/html/escaper phalcon/html/helper phalcon/html/helper/input phalcon/html/link phalcon/html/link/interfaces phalcon/html/link/serializer phalcon/http phalcon/http/cookie phalcon/http/message phalcon/http/message/exception phalcon/http/message/stream phalcon/http/request phalcon/http/response phalcon/http/server phalcon/image phalcon/image/adapter phalcon/logger phalcon/logger/adapter phalcon/logger/formatter phalcon/messages phalcon/mvc phalcon/mvc/application phalcon/mvc/controller phalcon/mvc/dispatcher phalcon/mvc/micro phalcon/mvc/model phalcon/mvc/model/behavior phalcon/mvc/model/binder phalcon/mvc/model/metadata phalcon/mvc/model/metadata/strategy phalcon/mvc/model/query phalcon/mvc/model/resultset phalcon/mvc/model/transaction phalcon/mvc/router phalcon/mvc/url phalcon/mvc/view phalcon/mvc/view/engine phalcon/mvc/view/engine/volt phalcon/paginator phalcon/paginator/adapter phalcon/session phalcon/session/adapter phalcon/storage phalcon/storage/adapter phalcon/storage/serializer phalcon/support phalcon/support/collection phalcon/support/debug phalcon/support/helper phalcon/support/helper/arr phalcon/support/helper/file phalcon/support/helper/json phalcon/support/helper/number phalcon/support/helper/str phalcon/tag phalcon/translate phalcon/translate/adapter phalcon/translate/interpolator"; do PHP_ADD_BUILD_DIR([$ext_builddir/$dir]) done PHP_SUBST(PHALCON_SHARED_LIBADD) diff --git a/ext/config.w32 b/ext/config.w32 index 319924c1f28..7e186be44bc 100644 --- a/ext/config.w32 +++ b/ext/config.w32 @@ -40,6 +40,7 @@ if (PHP_PHALCON != "no") { ADD_SOURCES(configure_module_dirname + "/phalcon/annotations/adapter", "adapterinterface.zep.c abstractadapter.zep.c apcu.zep.c memory.zep.c stream.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/datamapper/pdo/connection", "pdointerface.zep.c connectioninterface.zep.c abstractconnection.zep.c decorated.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/db", "dialectinterface.zep.c dialect.zep.c columninterface.zep.c indexinterface.zep.c referenceinterface.zep.c resultinterface.zep.c abstractdb.zep.c column.zep.c enum.zep.c exception.zep.c index.zep.c profiler.zep.c rawvalue.zep.c reference.zep.c", "phalcon"); + ADD_SOURCES(configure_module_dirname + "/phalcon/html/link/interfaces", "linkinterface.zep.c linkproviderinterface.zep.c evolvablelinkinterface.zep.c evolvablelinkproviderinterface.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/logger/adapter", "adapterinterface.zep.c abstractadapter.zep.c noop.zep.c stream.zep.c syslog.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/paginator/adapter", "adapterinterface.zep.c abstractadapter.zep.c model.zep.c nativearray.zep.c querybuilder.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/translate/adapter", "adapterinterface.zep.c abstractadapter.zep.c csv.zep.c gettext.zep.c nativearray.zep.c", "phalcon"); @@ -56,6 +57,7 @@ if (PHP_PHALCON != "no") { ADD_SOURCES(configure_module_dirname + "/phalcon/datamapper/pdo/exception", "exception.zep.c cannotdisconnect.zep.c connectionnotfound.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/domain/payload", "readableinterface.zep.c writeableinterface.zep.c payloadinterface.zep.c payload.zep.c payloadfactory.zep.c status.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/encryption/security/jwt/token", "abstractitem.zep.c enum.zep.c item.zep.c parser.zep.c signature.zep.c token.zep.c", "phalcon"); + ADD_SOURCES(configure_module_dirname + "/phalcon/html/link", "abstractlink.zep.c abstractlinkprovider.zep.c link.zep.c linkprovider.zep.c evolvablelink.zep.c evolvablelinkprovider.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/mvc/model/metadata/strategy", "strategyinterface.zep.c annotations.zep.c introspection.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/session/adapter", "abstractadapter.zep.c noop.zep.c libmemcached.zep.c redis.zep.c stream.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/translate/interpolator", "interpolatorinterface.zep.c associativearray.zep.c indexedarray.zep.c", "phalcon"); @@ -70,7 +72,6 @@ if (PHP_PHALCON != "no") { ADD_SOURCES(configure_module_dirname + "/phalcon/filter", "filterinterface.zep.c exception.zep.c filter.zep.c filterfactory.zep.c validation.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/html/attributes", "attributesinterface.zep.c renderinterface.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/html/escaper", "escaperinterface.zep.c exception.zep.c", "phalcon"); - ADD_SOURCES(configure_module_dirname + "/phalcon/html/link", "link.zep.c linkprovider.zep.c evolvablelink.zep.c evolvablelinkprovider.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/html/link/serializer", "serializerinterface.zep.c header.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/http/cookie", "cookieinterface.zep.c exception.zep.c", "phalcon"); ADD_SOURCES(configure_module_dirname + "/phalcon/http/request", "fileinterface.zep.c exception.zep.c file.zep.c", "phalcon"); diff --git a/ext/phalcon.c b/ext/phalcon.c index 4c992abb52a..d42b383d61f 100644 --- a/ext/phalcon.c +++ b/ext/phalcon.c @@ -42,6 +42,8 @@ zend_class_entry *phalcon_http_message_requestmethodinterface_ce; zend_class_entry *phalcon_annotations_adapter_adapterinterface_ce; zend_class_entry *phalcon_datamapper_pdo_connection_pdointerface_ce; zend_class_entry *phalcon_db_dialectinterface_ce; +zend_class_entry *phalcon_html_link_interfaces_linkinterface_ce; +zend_class_entry *phalcon_html_link_interfaces_linkproviderinterface_ce; zend_class_entry *phalcon_logger_adapter_adapterinterface_ce; zend_class_entry *phalcon_mvc_model_resultsetinterface_ce; zend_class_entry *phalcon_paginator_adapter_adapterinterface_ce; @@ -89,6 +91,8 @@ zend_class_entry *phalcon_filter_validation_validationinterface_ce; zend_class_entry *phalcon_html_attributes_attributesinterface_ce; zend_class_entry *phalcon_html_attributes_renderinterface_ce; zend_class_entry *phalcon_html_escaper_escaperinterface_ce; +zend_class_entry *phalcon_html_link_interfaces_evolvablelinkinterface_ce; +zend_class_entry *phalcon_html_link_interfaces_evolvablelinkproviderinterface_ce; zend_class_entry *phalcon_html_link_serializer_serializerinterface_ce; zend_class_entry *phalcon_http_cookie_cookieinterface_ce; zend_class_entry *phalcon_http_request_fileinterface_ce; @@ -172,6 +176,8 @@ zend_class_entry *phalcon_dispatcher_exception_ce; zend_class_entry *phalcon_encryption_security_jwt_token_abstractitem_ce; zend_class_entry *phalcon_filter_validation_abstractvalidatorcomposite_ce; zend_class_entry *phalcon_flash_abstractflash_ce; +zend_class_entry *phalcon_html_link_abstractlink_ce; +zend_class_entry *phalcon_html_link_abstractlinkprovider_ce; zend_class_entry *phalcon_http_message_abstractrequest_ce; zend_class_entry *phalcon_image_adapter_abstractadapter_ce; zend_class_entry *phalcon_logger_formatter_abstractformatter_ce; @@ -706,6 +712,8 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(Phalcon_Annotations_Adapter_AdapterInterface); ZEPHIR_INIT(Phalcon_DataMapper_Pdo_Connection_PdoInterface); ZEPHIR_INIT(Phalcon_Db_DialectInterface); + ZEPHIR_INIT(Phalcon_Html_Link_Interfaces_LinkInterface); + ZEPHIR_INIT(Phalcon_Html_Link_Interfaces_LinkProviderInterface); ZEPHIR_INIT(Phalcon_Logger_Adapter_AdapterInterface); ZEPHIR_INIT(Phalcon_Mvc_Model_ResultsetInterface); ZEPHIR_INIT(Phalcon_Paginator_Adapter_AdapterInterface); @@ -753,6 +761,8 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(Phalcon_Html_Attributes_AttributesInterface); ZEPHIR_INIT(Phalcon_Html_Attributes_RenderInterface); ZEPHIR_INIT(Phalcon_Html_Escaper_EscaperInterface); + ZEPHIR_INIT(Phalcon_Html_Link_Interfaces_EvolvableLinkInterface); + ZEPHIR_INIT(Phalcon_Html_Link_Interfaces_EvolvableLinkProviderInterface); ZEPHIR_INIT(Phalcon_Html_Link_Serializer_SerializerInterface); ZEPHIR_INIT(Phalcon_Http_Cookie_CookieInterface); ZEPHIR_INIT(Phalcon_Http_RequestInterface); @@ -836,6 +846,8 @@ static PHP_MINIT_FUNCTION(phalcon) ZEPHIR_INIT(Phalcon_Encryption_Security_JWT_Token_AbstractItem); ZEPHIR_INIT(Phalcon_Filter_Validation_AbstractValidatorComposite); ZEPHIR_INIT(Phalcon_Flash_AbstractFlash); + ZEPHIR_INIT(Phalcon_Html_Link_AbstractLink); + ZEPHIR_INIT(Phalcon_Html_Link_AbstractLinkProvider); ZEPHIR_INIT(Phalcon_Http_Message_AbstractRequest); ZEPHIR_INIT(Phalcon_Image_Adapter_AbstractAdapter); ZEPHIR_INIT(Phalcon_Logger_Formatter_AbstractFormatter); diff --git a/ext/phalcon.h b/ext/phalcon.h index 8a1fd5d1873..afeca9667dd 100644 --- a/ext/phalcon.h +++ b/ext/phalcon.h @@ -43,6 +43,8 @@ #include "phalcon/db/adapter/abstractadapter.zep.h" #include "phalcon/db/dialectinterface.zep.h" #include "phalcon/html/helper/abstractseries.zep.h" +#include "phalcon/html/link/interfaces/linkinterface.zep.h" +#include "phalcon/html/link/interfaces/linkproviderinterface.zep.h" #include "phalcon/http/message/abstractmessage.zep.h" #include "phalcon/logger/adapter/adapterinterface.zep.h" #include "phalcon/mvc/model/resultsetinterface.zep.h" @@ -87,6 +89,8 @@ #include "phalcon/encryption/security/jwt/token/abstractitem.zep.h" #include "phalcon/filter/validation/abstractvalidatorcomposite.zep.h" #include "phalcon/flash/abstractflash.zep.h" +#include "phalcon/html/link/abstractlink.zep.h" +#include "phalcon/html/link/abstractlinkprovider.zep.h" #include "phalcon/http/message/abstractrequest.zep.h" #include "phalcon/http/message/responsestatuscodeinterface.zep.h" #include "phalcon/image/adapter/abstractadapter.zep.h" @@ -132,6 +136,8 @@ #include "phalcon/html/helper/input/checkbox.zep.h" #include "phalcon/html/helper/ol.zep.h" #include "phalcon/html/helper/style.zep.h" +#include "phalcon/html/link/interfaces/evolvablelinkinterface.zep.h" +#include "phalcon/html/link/interfaces/evolvablelinkproviderinterface.zep.h" #include "phalcon/html/link/link.zep.h" #include "phalcon/html/link/linkprovider.zep.h" #include "phalcon/html/link/serializer/serializerinterface.zep.h" diff --git a/ext/phalcon/config/configfactory.zep.c b/ext/phalcon/config/configfactory.zep.c index 3f6151b13d3..9f9d3233703 100644 --- a/ext/phalcon/config/configfactory.zep.c +++ b/ext/phalcon/config/configfactory.zep.c @@ -138,7 +138,7 @@ PHP_METHOD(Phalcon_Config_ConfigFactory, load) ZEPHIR_OBS_VAR(&filePath); zephir_array_fetch_string(&filePath, &configArray, SL("filePath"), PH_NOISY, "phalcon/Config/ConfigFactory.zep", 61); ZVAL_LONG(&_1, 4); - ZEPHIR_CALL_FUNCTION(&_2, "pathinfo", NULL, 116, &filePath, &_1); + ZEPHIR_CALL_FUNCTION(&_2, "pathinfo", NULL, 118, &filePath, &_1); zephir_check_call_status(); if (1 == ZEPHIR_IS_EMPTY(&_2)) { ZEPHIR_CALL_FUNCTION(&_3$$3, "lcfirst", NULL, 104, &adapter); @@ -310,7 +310,7 @@ PHP_METHOD(Phalcon_Config_ConfigFactory, parseConfig) if (Z_TYPE_P(config) == IS_STRING) { ZEPHIR_CPY_WRT(&oldConfig, config); ZVAL_LONG(&_0$$3, 4); - ZEPHIR_CALL_FUNCTION(&extension, "pathinfo", NULL, 116, config, &_0$$3); + ZEPHIR_CALL_FUNCTION(&extension, "pathinfo", NULL, 118, config, &_0$$3); zephir_check_call_status(); if (1 == ZEPHIR_IS_EMPTY(&extension)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_config_exception_ce, "You need to provide the extension in the file path", "phalcon/Config/ConfigFactory.zep", 161); diff --git a/ext/phalcon/di/factorydefault.zep.c b/ext/phalcon/di/factorydefault.zep.c index 0dc0cf5d253..f2f4f84f413 100644 --- a/ext/phalcon/di/factorydefault.zep.c +++ b/ext/phalcon/di/factorydefault.zep.c @@ -159,7 +159,7 @@ PHP_METHOD(Phalcon_Di_FactoryDefault, __construct) zephir_array_update_string(&_1, SL("flashSession"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_2); object_init_ex(&_2, phalcon_di_service_ce); - ZEPHIR_CALL_METHOD(&_8, &filter, "newinstance", NULL, 121); + ZEPHIR_CALL_METHOD(&_8, &filter, "newinstance", NULL, 122); zephir_check_call_status(); ZVAL_BOOL(&_4, 1); ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 105, &_8, &_4); diff --git a/ext/phalcon/di/factorydefault/cli.zep.c b/ext/phalcon/di/factorydefault/cli.zep.c index 3685a307fef..bc2ecceae84 100644 --- a/ext/phalcon/di/factorydefault/cli.zep.c +++ b/ext/phalcon/di/factorydefault/cli.zep.c @@ -108,7 +108,7 @@ PHP_METHOD(Phalcon_Di_FactoryDefault_Cli, __construct) zephir_array_update_string(&_1, SL("eventsManager"), &_2, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_2); object_init_ex(&_2, phalcon_di_service_ce); - ZEPHIR_CALL_METHOD(&_5, &filter, "newinstance", NULL, 121); + ZEPHIR_CALL_METHOD(&_5, &filter, "newinstance", NULL, 122); zephir_check_call_status(); ZVAL_BOOL(&_4, 1); ZEPHIR_CALL_METHOD(NULL, &_2, "__construct", NULL, 105, &_5, &_4); diff --git a/ext/phalcon/encryption/crypt.zep.c b/ext/phalcon/encryption/crypt.zep.c index 9bf732d8ab5..68786366eec 100644 --- a/ext/phalcon/encryption/crypt.zep.c +++ b/ext/phalcon/encryption/crypt.zep.c @@ -1919,7 +1919,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, getMode) zephir_read_property(&_0, this_ptr, ZEND_STRL("cipher"), PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "-"); - ZEPHIR_CALL_FUNCTION(&_2, "strrpos", NULL, 124, &_0, &_1); + ZEPHIR_CALL_FUNCTION(&_2, "strrpos", NULL, 262, &_0, &_1); zephir_check_call_status(); ZEPHIR_INIT_VAR(&position); ZVAL_LONG(&position, zephir_get_intval(&_2)); @@ -2009,7 +2009,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt, phpOpensslRandomPseudoBytes) ZVAL_LONG(&_0, length); - ZEPHIR_RETURN_CALL_FUNCTION("openssl_random_pseudo_bytes", NULL, 262, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("openssl_random_pseudo_bytes", NULL, 263, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/encryption/crypt/padding/ansi.zep.c b/ext/phalcon/encryption/crypt/padding/ansi.zep.c index 303a7d50798..5b026b8aed2 100644 --- a/ext/phalcon/encryption/crypt/padding/ansi.zep.c +++ b/ext/phalcon/encryption/crypt/padding/ansi.zep.c @@ -71,13 +71,13 @@ PHP_METHOD(Phalcon_Encryption_Crypt_Padding_Ansi, pad) ZVAL_LONG(&_0, 0); - ZEPHIR_CALL_FUNCTION(&_1, "chr", NULL, 263, &_0); + ZEPHIR_CALL_FUNCTION(&_1, "chr", NULL, 264, &_0); zephir_check_call_status(); ZVAL_LONG(&_0, (paddingSize - 1)); ZEPHIR_CALL_FUNCTION(&_2, "str_repeat", NULL, 1, &_1, &_0); zephir_check_call_status(); ZVAL_LONG(&_0, paddingSize); - ZEPHIR_CALL_FUNCTION(&_3, "chr", NULL, 263, &_0); + ZEPHIR_CALL_FUNCTION(&_3, "chr", NULL, 264, &_0); zephir_check_call_status(); ZEPHIR_CONCAT_VV(return_value, &_2, &_3); RETURN_MM(); @@ -133,7 +133,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt_Padding_Ansi, unpad) ZVAL_LONG(&_1, 1); ZEPHIR_INIT_VAR(&last); zephir_substr(&last, &input, zephir_get_intval(&_0), 1 , 0); - ZEPHIR_CALL_FUNCTION(&ord, "ord", NULL, 264, &last); + ZEPHIR_CALL_FUNCTION(&ord, "ord", NULL, 265, &last); zephir_check_call_status(); if (ZEPHIR_LE_LONG(&ord, blockSize)) { ZEPHIR_CPY_WRT(&paddingSize, &ord); @@ -141,7 +141,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt_Padding_Ansi, unpad) ZVAL_STRING(&repeat, ""); if (ZEPHIR_GT_LONG(&paddingSize, 1)) { ZVAL_LONG(&_2$$4, 0); - ZEPHIR_CALL_FUNCTION(&_3$$4, "chr", NULL, 263, &_2$$4); + ZEPHIR_CALL_FUNCTION(&_3$$4, "chr", NULL, 264, &_2$$4); zephir_check_call_status(); ZVAL_LONG(&_2$$4, (zephir_get_numberval(&paddingSize) - 1)); ZEPHIR_CALL_FUNCTION(&repeat, "str_repeat", NULL, 1, &_3$$4, &_2$$4); diff --git a/ext/phalcon/encryption/crypt/padding/iso10126.zep.c b/ext/phalcon/encryption/crypt/padding/iso10126.zep.c index 1e6a0f9f40f..8b9ab6355e5 100644 --- a/ext/phalcon/encryption/crypt/padding/iso10126.zep.c +++ b/ext/phalcon/encryption/crypt/padding/iso10126.zep.c @@ -91,15 +91,15 @@ PHP_METHOD(Phalcon_Encryption_Crypt_Padding_Iso10126, pad) } ZEPHIR_INIT_NVAR(&counter); ZVAL_LONG(&counter, _1); - ZEPHIR_CALL_FUNCTION(&_3$$3, "rand", &_4, 265); + ZEPHIR_CALL_FUNCTION(&_3$$3, "rand", &_4, 266); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&_5$$3, "chr", &_6, 263, &_3$$3); + ZEPHIR_CALL_FUNCTION(&_5$$3, "chr", &_6, 264, &_3$$3); zephir_check_call_status(); zephir_concat_self(&padding, &_5$$3); } } ZVAL_LONG(&_7, paddingSize); - ZEPHIR_CALL_FUNCTION(&_8, "chr", &_6, 263, &_7); + ZEPHIR_CALL_FUNCTION(&_8, "chr", &_6, 264, &_7); zephir_check_call_status(); zephir_concat_self(&padding, &_8); RETURN_CCTOR(&padding); @@ -145,7 +145,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt_Padding_Iso10126, unpad) ZVAL_LONG(&_1, 1); ZEPHIR_INIT_VAR(&last); zephir_substr(&last, &input, zephir_get_intval(&_0), 1 , 0); - ZEPHIR_RETURN_CALL_FUNCTION("ord", NULL, 264, &last); + ZEPHIR_RETURN_CALL_FUNCTION("ord", NULL, 265, &last); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/encryption/crypt/padding/isoiek.zep.c b/ext/phalcon/encryption/crypt/padding/isoiek.zep.c index 025ccb698e4..8982136bfb6 100644 --- a/ext/phalcon/encryption/crypt/padding/isoiek.zep.c +++ b/ext/phalcon/encryption/crypt/padding/isoiek.zep.c @@ -71,10 +71,10 @@ PHP_METHOD(Phalcon_Encryption_Crypt_Padding_IsoIek, pad) ZVAL_LONG(&_0, 0x80); - ZEPHIR_CALL_FUNCTION(&_1, "chr", NULL, 263, &_0); + ZEPHIR_CALL_FUNCTION(&_1, "chr", NULL, 264, &_0); zephir_check_call_status(); ZVAL_LONG(&_0, 0); - ZEPHIR_CALL_FUNCTION(&_2, "chr", NULL, 263, &_0); + ZEPHIR_CALL_FUNCTION(&_2, "chr", NULL, 264, &_0); zephir_check_call_status(); ZVAL_LONG(&_0, (paddingSize - 1)); ZEPHIR_CALL_FUNCTION(&_3, "str_repeat", NULL, 1, &_2, &_0); @@ -125,7 +125,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt_Padding_IsoIek, unpad) paddingSize = 0; ZEPHIR_CALL_FUNCTION(&length, "mb_strlen", NULL, 254, &input); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&inputArray, "str_split", NULL, 115, &input); + ZEPHIR_CALL_FUNCTION(&inputArray, "str_split", NULL, 117, &input); zephir_check_call_status(); counter = (zephir_get_numberval(&length) - 1); while (1) { @@ -133,7 +133,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt_Padding_IsoIek, unpad) if (_0) { zephir_array_fetch_long(&_1, &inputArray, counter, PH_NOISY | PH_READONLY, "phalcon/Encryption/Crypt/Padding/IsoIek.zep", 48); ZVAL_LONG(&_2, 0); - ZEPHIR_CALL_FUNCTION(&_3, "chr", &_4, 263, &_2); + ZEPHIR_CALL_FUNCTION(&_3, "chr", &_4, 264, &_2); zephir_check_call_status(); _0 = ZEPHIR_IS_IDENTICAL(&_1, &_3); } @@ -149,7 +149,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt_Padding_IsoIek, unpad) } zephir_array_fetch_long(&_6, &inputArray, counter, PH_NOISY | PH_READONLY, "phalcon/Encryption/Crypt/Padding/IsoIek.zep", 55); ZVAL_LONG(&_2, 0x80); - ZEPHIR_CALL_FUNCTION(&_7, "chr", &_4, 263, &_2); + ZEPHIR_CALL_FUNCTION(&_7, "chr", &_4, 264, &_2); zephir_check_call_status(); if (ZEPHIR_IS_EQUAL(&_6, &_7)) { paddingSize++; diff --git a/ext/phalcon/encryption/crypt/padding/pkcs7.zep.c b/ext/phalcon/encryption/crypt/padding/pkcs7.zep.c index d48a5093478..b2ca3a94aa3 100644 --- a/ext/phalcon/encryption/crypt/padding/pkcs7.zep.c +++ b/ext/phalcon/encryption/crypt/padding/pkcs7.zep.c @@ -68,7 +68,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt_Padding_Pkcs7, pad) ZVAL_LONG(&_0, paddingSize); - ZEPHIR_CALL_FUNCTION(&_1, "chr", NULL, 263, &_0); + ZEPHIR_CALL_FUNCTION(&_1, "chr", NULL, 264, &_0); zephir_check_call_status(); ZVAL_LONG(&_0, paddingSize); ZEPHIR_RETURN_CALL_FUNCTION("str_repeat", NULL, 1, &_1, &_0); @@ -122,11 +122,11 @@ PHP_METHOD(Phalcon_Encryption_Crypt_Padding_Pkcs7, unpad) ZVAL_LONG(&_1, 1); ZEPHIR_INIT_VAR(&last); zephir_substr(&last, &input, zephir_get_intval(&_0), 1 , 0); - ZEPHIR_CALL_FUNCTION(&ord, "ord", NULL, 264, &last); + ZEPHIR_CALL_FUNCTION(&ord, "ord", NULL, 265, &last); zephir_check_call_status(); if (ZEPHIR_LE_LONG(&ord, blockSize)) { ZEPHIR_CPY_WRT(&paddingSize, &ord); - ZEPHIR_CALL_FUNCTION(&_2$$3, "chr", NULL, 263, &paddingSize); + ZEPHIR_CALL_FUNCTION(&_2$$3, "chr", NULL, 264, &paddingSize); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", NULL, 1, &_2$$3, &paddingSize); zephir_check_call_status(); diff --git a/ext/phalcon/encryption/crypt/padding/space.zep.c b/ext/phalcon/encryption/crypt/padding/space.zep.c index 4651c17a628..6527b1c0af8 100644 --- a/ext/phalcon/encryption/crypt/padding/space.zep.c +++ b/ext/phalcon/encryption/crypt/padding/space.zep.c @@ -114,7 +114,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt_Padding_Space, unpad) ZEPHIR_CALL_FUNCTION(&length, "mb_strlen", NULL, 254, &input); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&inputArray, "str_split", NULL, 115, &input); + ZEPHIR_CALL_FUNCTION(&inputArray, "str_split", NULL, 117, &input); zephir_check_call_status(); counter = (zephir_get_numberval(&length) - 1); paddingSize = 0; @@ -123,7 +123,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt_Padding_Space, unpad) if (_0) { zephir_array_fetch_long(&_1, &inputArray, counter, PH_NOISY | PH_READONLY, "phalcon/Encryption/Crypt/Padding/Space.zep", 48); ZVAL_LONG(&_2, 32); - ZEPHIR_CALL_FUNCTION(&_3, "chr", &_4, 263, &_2); + ZEPHIR_CALL_FUNCTION(&_3, "chr", &_4, 264, &_2); zephir_check_call_status(); _0 = ZEPHIR_IS_EQUAL(&_1, &_3); } diff --git a/ext/phalcon/encryption/crypt/padding/zero.zep.c b/ext/phalcon/encryption/crypt/padding/zero.zep.c index 8b32fe80b43..43da17db1d9 100644 --- a/ext/phalcon/encryption/crypt/padding/zero.zep.c +++ b/ext/phalcon/encryption/crypt/padding/zero.zep.c @@ -68,7 +68,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt_Padding_Zero, pad) ZVAL_LONG(&_0, 0); - ZEPHIR_CALL_FUNCTION(&_1, "chr", NULL, 263, &_0); + ZEPHIR_CALL_FUNCTION(&_1, "chr", NULL, 264, &_0); zephir_check_call_status(); ZVAL_LONG(&_0, paddingSize); ZEPHIR_RETURN_CALL_FUNCTION("str_repeat", NULL, 1, &_1, &_0); @@ -115,7 +115,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt_Padding_Zero, unpad) ZEPHIR_CALL_FUNCTION(&length, "mb_strlen", NULL, 254, &input); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&inputArray, "str_split", NULL, 115, &input); + ZEPHIR_CALL_FUNCTION(&inputArray, "str_split", NULL, 117, &input); zephir_check_call_status(); counter = (zephir_get_numberval(&length) - 1); paddingSize = 0; @@ -124,7 +124,7 @@ PHP_METHOD(Phalcon_Encryption_Crypt_Padding_Zero, unpad) if (_0) { zephir_array_fetch_long(&_1, &inputArray, counter, PH_NOISY | PH_READONLY, "phalcon/Encryption/Crypt/Padding/Zero.zep", 48); ZVAL_LONG(&_2, 0); - ZEPHIR_CALL_FUNCTION(&_3, "chr", &_4, 263, &_2); + ZEPHIR_CALL_FUNCTION(&_3, "chr", &_4, 264, &_2); zephir_check_call_status(); _0 = ZEPHIR_IS_EQUAL(&_1, &_3); } diff --git a/ext/phalcon/encryption/security.zep.c b/ext/phalcon/encryption/security.zep.c index 6e1b10317ac..7a364fe7393 100644 --- a/ext/phalcon/encryption/security.zep.c +++ b/ext/phalcon/encryption/security.zep.c @@ -238,7 +238,7 @@ PHP_METHOD(Phalcon_Encryption_Security, checkHash) if (_0) { RETURN_MM_BOOL(0); } - ZEPHIR_RETURN_CALL_FUNCTION("password_verify", NULL, 266, &password, &passwordHash); + ZEPHIR_RETURN_CALL_FUNCTION("password_verify", NULL, 267, &password, &passwordHash); zephir_check_call_status(); RETURN_MM(); } @@ -298,13 +298,13 @@ PHP_METHOD(Phalcon_Encryption_Security, checkToken) } - ZEPHIR_CALL_METHOD(&_0, this_ptr, "processtokenkey", NULL, 267, &tokenKey); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "processtokenkey", NULL, 268, &tokenKey); zephir_check_call_status(); zephir_get_strval(&tokenKey, &_0); if (!(!(ZEPHIR_IS_EMPTY(&tokenKey)))) { RETURN_MM_BOOL(0); } - ZEPHIR_CALL_METHOD(&userToken, this_ptr, "processusertoken", NULL, 268, &tokenKey, tokenValue); + ZEPHIR_CALL_METHOD(&userToken, this_ptr, "processusertoken", NULL, 269, &tokenKey, tokenValue); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&knownToken, this_ptr, "getrequesttoken", NULL, 0); zephir_check_call_status(); @@ -483,7 +483,7 @@ PHP_METHOD(Phalcon_Encryption_Security, getHashInformation) zephir_get_strval(&hash, hash_param); - ZEPHIR_RETURN_CALL_FUNCTION("password_get_info", NULL, 269, &hash); + ZEPHIR_RETURN_CALL_FUNCTION("password_get_info", NULL, 270, &hash); zephir_check_call_status(); RETURN_MM(); } @@ -789,7 +789,7 @@ PHP_METHOD(Phalcon_Encryption_Security, hash) } - ZEPHIR_CALL_METHOD(&cost, this_ptr, "processcost", NULL, 270, &options); + ZEPHIR_CALL_METHOD(&cost, this_ptr, "processcost", NULL, 271, &options); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "%02s"); @@ -844,7 +844,7 @@ PHP_METHOD(Phalcon_Encryption_Security, hash) zephir_check_call_status(); ZEPHIR_INIT_VAR(&salt); ZEPHIR_CONCAT_VVS(&salt, &prefix, &_4$$9, "$"); - ZEPHIR_RETURN_CALL_FUNCTION("crypt", NULL, 271, &password, &salt); + ZEPHIR_RETURN_CALL_FUNCTION("crypt", NULL, 272, &password, &salt); zephir_check_call_status(); RETURN_MM(); } @@ -852,11 +852,11 @@ PHP_METHOD(Phalcon_Encryption_Security, hash) zephir_create_array(&_6, 1, 0); zephir_array_update_string(&_6, SL("cost"), &cost, PH_COPY | PH_SEPARATE); ZEPHIR_CPY_WRT(&options, &_6); - ZEPHIR_CALL_METHOD(&algorithm, this_ptr, "processalgorithm", NULL, 272); + ZEPHIR_CALL_METHOD(&algorithm, this_ptr, "processalgorithm", NULL, 273); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&arguments, this_ptr, "processargonoptions", NULL, 273, &options); + ZEPHIR_CALL_METHOD(&arguments, this_ptr, "processargonoptions", NULL, 274, &options); zephir_check_call_status(); - ZEPHIR_RETURN_CALL_FUNCTION("password_hash", NULL, 274, &password, &algorithm, &arguments); + ZEPHIR_RETURN_CALL_FUNCTION("password_hash", NULL, 275, &password, &algorithm, &arguments); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/encryption/security/jwt/builder.zep.c b/ext/phalcon/encryption/security/jwt/builder.zep.c index 1685a693978..2a4208725b4 100644 --- a/ext/phalcon/encryption/security/jwt/builder.zep.c +++ b/ext/phalcon/encryption/security/jwt/builder.zep.c @@ -502,27 +502,27 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, getToken) } ZEPHIR_CALL_METHOD(&_2, this_ptr, "getclaims", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_1, this_ptr, "encode", NULL, 275, &_2); + ZEPHIR_CALL_METHOD(&_1, this_ptr, "encode", NULL, 276, &_2); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&encodedClaims, this_ptr, "encodeurl", NULL, 276, &_1); + ZEPHIR_CALL_METHOD(&encodedClaims, this_ptr, "encodeurl", NULL, 277, &_1); zephir_check_call_status(); ZEPHIR_INIT_VAR(&claims); object_init_ex(&claims, phalcon_encryption_security_jwt_token_item_ce); ZEPHIR_CALL_METHOD(&_3, this_ptr, "getclaims", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &claims, "__construct", NULL, 277, &_3, &encodedClaims); + ZEPHIR_CALL_METHOD(NULL, &claims, "__construct", NULL, 278, &_3, &encodedClaims); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_5, this_ptr, "getheaders", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_4, this_ptr, "encode", NULL, 275, &_5); + ZEPHIR_CALL_METHOD(&_4, this_ptr, "encode", NULL, 276, &_5); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&encodedHeaders, this_ptr, "encodeurl", NULL, 276, &_4); + ZEPHIR_CALL_METHOD(&encodedHeaders, this_ptr, "encodeurl", NULL, 277, &_4); zephir_check_call_status(); ZEPHIR_INIT_VAR(&headers); object_init_ex(&headers, phalcon_encryption_security_jwt_token_item_ce); ZEPHIR_CALL_METHOD(&_6, this_ptr, "getheaders", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &headers, "__construct", NULL, 277, &_6, &encodedHeaders); + ZEPHIR_CALL_METHOD(NULL, &headers, "__construct", NULL, 278, &_6, &encodedHeaders); zephir_check_call_status(); zephir_read_property(&_7, this_ptr, ZEND_STRL("signer"), PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_VAR(&_8); @@ -530,14 +530,14 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Builder, getToken) zephir_read_property(&_9, this_ptr, ZEND_STRL("passphrase"), PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&signatureHash, &_7, "sign", NULL, 0, &_8, &_9); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&encodedSignature, this_ptr, "encodeurl", NULL, 276, &signatureHash); + ZEPHIR_CALL_METHOD(&encodedSignature, this_ptr, "encodeurl", NULL, 277, &signatureHash); zephir_check_call_status(); ZEPHIR_INIT_VAR(&signature); object_init_ex(&signature, phalcon_encryption_security_jwt_token_signature_ce); - ZEPHIR_CALL_METHOD(NULL, &signature, "__construct", NULL, 278, &signatureHash, &encodedSignature); + ZEPHIR_CALL_METHOD(NULL, &signature, "__construct", NULL, 279, &signatureHash, &encodedSignature); zephir_check_call_status(); object_init_ex(return_value, phalcon_encryption_security_jwt_token_token_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 279, &headers, &claims, &signature); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 280, &headers, &claims, &signature); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/encryption/security/jwt/signer/hmac.zep.c b/ext/phalcon/encryption/security/jwt/signer/hmac.zep.c index 5f8b9da305f..05d4d24dd68 100644 --- a/ext/phalcon/encryption/security/jwt/signer/hmac.zep.c +++ b/ext/phalcon/encryption/security/jwt/signer/hmac.zep.c @@ -177,7 +177,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Signer_Hmac, sign) } - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "gethash", NULL, 280, &payload, &passphrase); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "gethash", NULL, 281, &payload, &passphrase); zephir_check_call_status(); RETURN_MM(); } @@ -244,7 +244,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Signer_Hmac, verify) } - ZEPHIR_CALL_METHOD(&_0, this_ptr, "gethash", NULL, 280, &payload, &passphrase); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "gethash", NULL, 281, &payload, &passphrase); zephir_check_call_status(); RETURN_MM_BOOL(zephir_hash_equals(&source, &_0)); } diff --git a/ext/phalcon/encryption/security/jwt/token/parser.zep.c b/ext/phalcon/encryption/security/jwt/token/parser.zep.c index 9b9a08a8378..d8245fd946d 100644 --- a/ext/phalcon/encryption/security/jwt/token/parser.zep.c +++ b/ext/phalcon/encryption/security/jwt/token/parser.zep.c @@ -85,7 +85,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Parser, parse) } - ZEPHIR_CALL_METHOD(&results, this_ptr, "parsetoken", NULL, 281, &token); + ZEPHIR_CALL_METHOD(&results, this_ptr, "parsetoken", NULL, 282, &token); zephir_check_call_status(); ZEPHIR_OBS_VAR(&encodedHeaders); zephir_array_fetch_long(&encodedHeaders, &results, 0, PH_NOISY, "phalcon/Encryption/Security/JWT/Token/Parser.zep", 33); @@ -93,14 +93,14 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Parser, parse) zephir_array_fetch_long(&encodedClaims, &results, 1, PH_NOISY, "phalcon/Encryption/Security/JWT/Token/Parser.zep", 34); ZEPHIR_OBS_VAR(&encodedSignature); zephir_array_fetch_long(&encodedSignature, &results, 2, PH_NOISY, "phalcon/Encryption/Security/JWT/Token/Parser.zep", 35); - ZEPHIR_CALL_METHOD(&headers, this_ptr, "decodeheaders", NULL, 282, &encodedHeaders); + ZEPHIR_CALL_METHOD(&headers, this_ptr, "decodeheaders", NULL, 283, &encodedHeaders); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&claims, this_ptr, "decodeclaims", NULL, 283, &encodedClaims); + ZEPHIR_CALL_METHOD(&claims, this_ptr, "decodeclaims", NULL, 284, &encodedClaims); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&signature, this_ptr, "decodesignature", NULL, 284, &headers, &encodedSignature); + ZEPHIR_CALL_METHOD(&signature, this_ptr, "decodesignature", NULL, 285, &headers, &encodedSignature); zephir_check_call_status(); object_init_ex(return_value, phalcon_encryption_security_jwt_token_token_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 279, &headers, &claims, &signature); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 280, &headers, &claims, &signature); zephir_check_call_status(); RETURN_MM(); } @@ -142,10 +142,10 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Parser, decodeClaims) zephir_get_strval(&claims, claims_param); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "decodeurl", NULL, 285, &claims); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "decodeurl", NULL, 286, &claims); zephir_check_call_status(); ZVAL_BOOL(&_1, 1); - ZEPHIR_CALL_METHOD(&decoded, this_ptr, "decode", NULL, 286, &_0, &_1); + ZEPHIR_CALL_METHOD(&decoded, this_ptr, "decode", NULL, 287, &_0, &_1); zephir_check_call_status(); if (Z_TYPE_P(&decoded) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Invalid Claims (not an array)", "phalcon/Encryption/Security/JWT/Token/Parser.zep", 59); @@ -166,7 +166,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Parser, decodeClaims) zephir_array_update_string(&decoded, SL("aud"), &_4$$4, PH_COPY | PH_SEPARATE); } object_init_ex(return_value, phalcon_encryption_security_jwt_token_item_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 277, &decoded, &claims); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 278, &decoded, &claims); zephir_check_call_status(); RETURN_MM(); } @@ -203,10 +203,10 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Parser, decodeHeaders) zephir_get_strval(&headers, headers_param); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "decodeurl", NULL, 285, &headers); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "decodeurl", NULL, 286, &headers); zephir_check_call_status(); ZVAL_BOOL(&_1, 1); - ZEPHIR_CALL_METHOD(&decoded, this_ptr, "decode", NULL, 286, &_0, &_1); + ZEPHIR_CALL_METHOD(&decoded, this_ptr, "decode", NULL, 287, &_0, &_1); zephir_check_call_status(); if (Z_TYPE_P(&decoded) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Invalid Header (not an array)", "phalcon/Encryption/Security/JWT/Token/Parser.zep", 88); @@ -217,7 +217,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Parser, decodeHeaders) return; } object_init_ex(return_value, phalcon_encryption_security_jwt_token_item_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 277, &decoded, &headers); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 278, &decoded, &headers); zephir_check_call_status(); RETURN_MM(); } @@ -272,11 +272,11 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Token_Parser, decodeSignature) ZVAL_STRING(&decoded, ""); ZEPHIR_INIT_NVAR(&signature); } else { - ZEPHIR_CALL_METHOD(&decoded, this_ptr, "decodeurl", NULL, 285, &signature); + ZEPHIR_CALL_METHOD(&decoded, this_ptr, "decodeurl", NULL, 286, &signature); zephir_check_call_status(); } object_init_ex(return_value, phalcon_encryption_security_jwt_token_signature_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 278, &decoded, &signature); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 279, &decoded, &signature); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/encryption/security/jwt/validator.zep.c b/ext/phalcon/encryption/security/jwt/validator.zep.c index 385444d5162..f6e4ebd444f 100644 --- a/ext/phalcon/encryption/security/jwt/validator.zep.c +++ b/ext/phalcon/encryption/security/jwt/validator.zep.c @@ -216,7 +216,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, validateExpiration) _4 = zephir_is_true(&_2); if (_4) { ZVAL_LONG(&_6, timestamp); - ZEPHIR_CALL_METHOD(&_5, this_ptr, "gettimestamp", NULL, 287, &_6); + ZEPHIR_CALL_METHOD(&_5, this_ptr, "gettimestamp", NULL, 288, &_6); zephir_check_call_status(); zephir_read_property(&_6, this_ptr, ZEND_STRL("token"), PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_7, &_6, "getclaims", NULL, 0); @@ -322,7 +322,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, validateIssuedAt) ZVAL_LONG(&_1, timestamp); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "gettimestamp", NULL, 287, &_1); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "gettimestamp", NULL, 288, &_1); zephir_check_call_status(); zephir_read_property(&_1, this_ptr, ZEND_STRL("token"), PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "getclaims", NULL, 0); @@ -426,7 +426,7 @@ PHP_METHOD(Phalcon_Encryption_Security_JWT_Validator, validateNotBefore) ZVAL_LONG(&_1, timestamp); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "gettimestamp", NULL, 287, &_1); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "gettimestamp", NULL, 288, &_1); zephir_check_call_status(); zephir_read_property(&_1, this_ptr, ZEND_STRL("token"), PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(&_2, &_1, "getclaims", NULL, 0); diff --git a/ext/phalcon/encryption/security/random.zep.c b/ext/phalcon/encryption/security/random.zep.c index cfbf963f461..9c8dcdafbb5 100644 --- a/ext/phalcon/encryption/security/random.zep.c +++ b/ext/phalcon/encryption/security/random.zep.c @@ -400,7 +400,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Random, bytes) len = 16; } ZVAL_LONG(&_0, len); - ZEPHIR_RETURN_CALL_FUNCTION("random_bytes", NULL, 288, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("random_bytes", NULL, 289, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -453,7 +453,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Random, hex) zephir_check_call_status(); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "H*"); - ZEPHIR_CALL_FUNCTION(&_3, "unpack", NULL, 289, &_2, &_0); + ZEPHIR_CALL_FUNCTION(&_3, "unpack", NULL, 290, &_2, &_0); zephir_check_call_status(); ZEPHIR_MAKE_REF(&_3); ZEPHIR_RETURN_CALL_FUNCTION("array_shift", NULL, 23, &_3); @@ -503,7 +503,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Random, number) } ZVAL_LONG(&_0, 0); ZVAL_LONG(&_1, len); - ZEPHIR_RETURN_CALL_FUNCTION("random_int", NULL, 290, &_0, &_1); + ZEPHIR_RETURN_CALL_FUNCTION("random_int", NULL, 291, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -555,7 +555,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Random, uuid) zephir_check_call_status(); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "N1a/n1b/n1c/n1d/n1e/N1f"); - ZEPHIR_CALL_FUNCTION(&_3, "unpack", NULL, 289, &_2, &_0); + ZEPHIR_CALL_FUNCTION(&_3, "unpack", NULL, 290, &_2, &_0); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&ary, "array_values", NULL, 14, &_3); zephir_check_call_status(); @@ -570,7 +570,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Random, uuid) ZEPHIR_INIT_VAR(&_7); ZVAL_STRING(&_7, "%08x-%04x-%04x-%04x-%04x%08x"); ZEPHIR_MAKE_REF(&ary); - ZEPHIR_CALL_FUNCTION(NULL, "array_unshift", NULL, 291, &ary, &_7); + ZEPHIR_CALL_FUNCTION(NULL, "array_unshift", NULL, 292, &ary, &_7); ZEPHIR_UNREF(&ary); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_7); @@ -636,7 +636,7 @@ PHP_METHOD(Phalcon_Encryption_Security_Random, base) zephir_check_call_status(); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "C*"); - ZEPHIR_CALL_FUNCTION(&bytes, "unpack", NULL, 289, &_1, &_0); + ZEPHIR_CALL_FUNCTION(&bytes, "unpack", NULL, 290, &_1, &_0); zephir_check_call_status(); zephir_is_iterable(&bytes, 0, "phalcon/Encryption/Security/Random.zep", 351); if (Z_TYPE_P(&bytes) == IS_ARRAY) { diff --git a/ext/phalcon/events/manager.zep.c b/ext/phalcon/events/manager.zep.c index 254915e12cc..8ed5fdc5da7 100644 --- a/ext/phalcon/events/manager.zep.c +++ b/ext/phalcon/events/manager.zep.c @@ -139,7 +139,7 @@ PHP_METHOD(Phalcon_Events_Manager, attach) } ZVAL_LONG(&_2$$4, 1); - ZEPHIR_CALL_METHOD(NULL, &priorityQueue, "setextractflags", NULL, 292, &_2$$4); + ZEPHIR_CALL_METHOD(NULL, &priorityQueue, "setextractflags", NULL, 293, &_2$$4); zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("events"), &eventType, &priorityQueue); } @@ -148,7 +148,7 @@ PHP_METHOD(Phalcon_Events_Manager, attach) priority = 100; } ZVAL_LONG(&_4, priority); - ZEPHIR_CALL_METHOD(NULL, &priorityQueue, "insert", NULL, 293, handler, &_4); + ZEPHIR_CALL_METHOD(NULL, &priorityQueue, "insert", NULL, 294, handler, &_4); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); } @@ -261,7 +261,7 @@ PHP_METHOD(Phalcon_Events_Manager, detach) } ZVAL_LONG(&_2$$4, 1); - ZEPHIR_CALL_METHOD(NULL, &newPriorityQueue, "setextractflags", NULL, 292, &_2$$4); + ZEPHIR_CALL_METHOD(NULL, &newPriorityQueue, "setextractflags", NULL, 293, &_2$$4); zephir_check_call_status(); ZVAL_LONG(&_2$$4, 3); ZEPHIR_CALL_METHOD(NULL, &priorityQueue, "setextractflags", NULL, 0, &_2$$4); @@ -282,7 +282,7 @@ PHP_METHOD(Phalcon_Events_Manager, detach) if (!ZEPHIR_IS_IDENTICAL(&_6$$5, handler)) { zephir_array_fetch_string(&_7$$6, &data, SL("data"), PH_NOISY | PH_READONLY, "phalcon/Events/Manager.zep", 136); zephir_array_fetch_string(&_8$$6, &data, SL("priority"), PH_NOISY | PH_READONLY, "phalcon/Events/Manager.zep", 138); - ZEPHIR_CALL_METHOD(NULL, &newPriorityQueue, "insert", &_9, 293, &_7$$6, &_8$$6); + ZEPHIR_CALL_METHOD(NULL, &newPriorityQueue, "insert", &_9, 294, &_7$$6, &_8$$6); zephir_check_call_status(); } } @@ -490,19 +490,19 @@ PHP_METHOD(Phalcon_Events_Manager, fire) } else { ZVAL_BOOL(&_4, 0); } - ZEPHIR_CALL_METHOD(NULL, &event, "__construct", NULL, 294, &eventName, source, data, &_4); + ZEPHIR_CALL_METHOD(NULL, &event, "__construct", NULL, 295, &eventName, source, data, &_4); zephir_check_call_status(); ZEPHIR_OBS_VAR(&fireEvents); if (zephir_array_isset_fetch(&fireEvents, &events, &type, 0)) { if (Z_TYPE_P(&fireEvents) == IS_OBJECT) { - ZEPHIR_CALL_METHOD(&status, this_ptr, "firequeue", NULL, 295, &fireEvents, &event); + ZEPHIR_CALL_METHOD(&status, this_ptr, "firequeue", NULL, 296, &fireEvents, &event); zephir_check_call_status(); } } ZEPHIR_OBS_NVAR(&fireEvents); if (zephir_array_isset_fetch(&fireEvents, &events, &eventType, 0)) { if (Z_TYPE_P(&fireEvents) == IS_OBJECT) { - ZEPHIR_CALL_METHOD(&status, this_ptr, "firequeue", NULL, 295, &fireEvents, &event); + ZEPHIR_CALL_METHOD(&status, this_ptr, "firequeue", NULL, 296, &fireEvents, &event); zephir_check_call_status(); } } diff --git a/ext/phalcon/filter/filter.zep.c b/ext/phalcon/filter/filter.zep.c index 70ad49b04f2..96098e68f58 100644 --- a/ext/phalcon/filter/filter.zep.c +++ b/ext/phalcon/filter/filter.zep.c @@ -262,7 +262,7 @@ PHP_METHOD(Phalcon_Filter_Filter, get) zephir_read_property(&_4$$4, this_ptr, ZEND_STRL("mapper"), PH_NOISY_CC | PH_READONLY); ZEPHIR_OBS_VAR(&definition); zephir_array_fetch(&definition, &_4$$4, &name, PH_NOISY, "phalcon/Filter/Filter.zep", 123); - ZEPHIR_CALL_METHOD(&_5$$4, this_ptr, "createinstance", NULL, 296, &definition); + ZEPHIR_CALL_METHOD(&_5$$4, this_ptr, "createinstance", NULL, 297, &definition); zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("services"), &name, &_5$$4); } @@ -351,7 +351,7 @@ PHP_METHOD(Phalcon_Filter_Filter, sanitize) } else { ZVAL_BOOL(&_0$$3, 0); } - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processarraysanitizers", NULL, 297, sanitizers, value, &_0$$3); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processarraysanitizers", NULL, 298, sanitizers, value, &_0$$3); zephir_check_call_status(); RETURN_MM(); } @@ -360,11 +360,11 @@ PHP_METHOD(Phalcon_Filter_Filter, sanitize) _1 = !noRecursive; } if (_1) { - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processarrayvalues", NULL, 298, value, sanitizers); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processarrayvalues", NULL, 299, value, sanitizers); zephir_check_call_status(); RETURN_MM(); } - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "sanitizer", NULL, 299, value, sanitizers); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "sanitizer", NULL, 300, value, sanitizers); zephir_check_call_status(); RETURN_MM(); } @@ -578,7 +578,7 @@ PHP_METHOD(Phalcon_Filter_Filter, processArraySanitizers) } ZEPHIR_INIT_NVAR(&sanitizer); ZVAL_COPY(&sanitizer, _0); - ZEPHIR_CALL_METHOD(&split, this_ptr, "splitsanitizerparameters", &_4, 300, &sanitizerKey, &sanitizer); + ZEPHIR_CALL_METHOD(&split, this_ptr, "splitsanitizerparameters", &_4, 301, &sanitizerKey, &sanitizer); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&sanitizerName); zephir_array_fetch_long(&sanitizerName, &split, 0, PH_NOISY, "phalcon/Filter/Filter.zep", 279); @@ -589,10 +589,10 @@ PHP_METHOD(Phalcon_Filter_Filter, processArraySanitizers) } else { ZVAL_BOOL(&_6$$4, 0); } - ZEPHIR_CALL_METHOD(&_5$$4, this_ptr, "processvalueisarray", &_7, 301, value, &sanitizerName, &sanitizerParams, &_6$$4); + ZEPHIR_CALL_METHOD(&_5$$4, this_ptr, "processvalueisarray", &_7, 302, value, &sanitizerName, &sanitizerParams, &_6$$4); zephir_check_call_status(); ZEPHIR_CPY_WRT(value, &_5$$4); - ZEPHIR_CALL_METHOD(&_5$$4, this_ptr, "processvalueisnotarray", &_8, 302, value, &sanitizerName, &sanitizerParams); + ZEPHIR_CALL_METHOD(&_5$$4, this_ptr, "processvalueisnotarray", &_8, 303, value, &sanitizerName, &sanitizerParams); zephir_check_call_status(); ZEPHIR_CPY_WRT(value, &_5$$4); } ZEND_HASH_FOREACH_END(); @@ -609,7 +609,7 @@ PHP_METHOD(Phalcon_Filter_Filter, processArraySanitizers) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&sanitizer, &sanitizers, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&split, this_ptr, "splitsanitizerparameters", &_4, 300, &sanitizerKey, &sanitizer); + ZEPHIR_CALL_METHOD(&split, this_ptr, "splitsanitizerparameters", &_4, 301, &sanitizerKey, &sanitizer); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&sanitizerName); zephir_array_fetch_long(&sanitizerName, &split, 0, PH_NOISY, "phalcon/Filter/Filter.zep", 279); @@ -620,10 +620,10 @@ PHP_METHOD(Phalcon_Filter_Filter, processArraySanitizers) } else { ZVAL_BOOL(&_10$$5, 0); } - ZEPHIR_CALL_METHOD(&_9$$5, this_ptr, "processvalueisarray", &_7, 301, value, &sanitizerName, &sanitizerParams, &_10$$5); + ZEPHIR_CALL_METHOD(&_9$$5, this_ptr, "processvalueisarray", &_7, 302, value, &sanitizerName, &sanitizerParams, &_10$$5); zephir_check_call_status(); ZEPHIR_CPY_WRT(value, &_9$$5); - ZEPHIR_CALL_METHOD(&_9$$5, this_ptr, "processvalueisnotarray", &_8, 302, value, &sanitizerName, &sanitizerParams); + ZEPHIR_CALL_METHOD(&_9$$5, this_ptr, "processvalueisnotarray", &_8, 303, value, &sanitizerName, &sanitizerParams); zephir_check_call_status(); ZEPHIR_CPY_WRT(value, &_9$$5); ZEPHIR_CALL_METHOD(NULL, &sanitizers, "next", NULL, 0); @@ -704,7 +704,7 @@ PHP_METHOD(Phalcon_Filter_Filter, processArrayValues) } ZEPHIR_INIT_NVAR(&itemValue); ZVAL_COPY(&itemValue, _0); - ZEPHIR_CALL_METHOD(&_4$$3, this_ptr, "sanitizer", &_5, 299, &itemValue, &sanitizerName, &sanitizerParams); + ZEPHIR_CALL_METHOD(&_4$$3, this_ptr, "sanitizer", &_5, 300, &itemValue, &sanitizerName, &sanitizerParams); zephir_check_call_status(); zephir_array_update_zval(&arrayValues, &itemKey, &_4$$3, PH_COPY | PH_SEPARATE); } ZEND_HASH_FOREACH_END(); @@ -721,7 +721,7 @@ PHP_METHOD(Phalcon_Filter_Filter, processArrayValues) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&itemValue, &values, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_6$$4, this_ptr, "sanitizer", &_5, 299, &itemValue, &sanitizerName, &sanitizerParams); + ZEPHIR_CALL_METHOD(&_6$$4, this_ptr, "sanitizer", &_5, 300, &itemValue, &sanitizerName, &sanitizerParams); zephir_check_call_status(); zephir_array_update_zval(&arrayValues, &itemKey, &_6$$4, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(NULL, &values, "next", NULL, 0); @@ -855,7 +855,7 @@ PHP_METHOD(Phalcon_Filter_Filter, processValueIsArray) _0 = !noRecursive; } if (_0) { - ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "processarrayvalues", NULL, 298, value, &sanitizerName, &sanitizerParams); + ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "processarrayvalues", NULL, 299, value, &sanitizerName, &sanitizerParams); zephir_check_call_status(); ZEPHIR_CPY_WRT(value, &_1$$3); } @@ -902,7 +902,7 @@ PHP_METHOD(Phalcon_Filter_Filter, processValueIsNotArray) if (Z_TYPE_P(value) != IS_ARRAY) { - ZEPHIR_CALL_METHOD(&_0$$3, this_ptr, "sanitizer", NULL, 299, value, &sanitizerName, &sanitizerParams); + ZEPHIR_CALL_METHOD(&_0$$3, this_ptr, "sanitizer", NULL, 300, value, &sanitizerName, &sanitizerParams); zephir_check_call_status(); ZEPHIR_CPY_WRT(value, &_0$$3); } diff --git a/ext/phalcon/filter/filterfactory.zep.c b/ext/phalcon/filter/filterfactory.zep.c index 0d85b2082d9..920300d3dd2 100644 --- a/ext/phalcon/filter/filterfactory.zep.c +++ b/ext/phalcon/filter/filterfactory.zep.c @@ -59,7 +59,7 @@ PHP_METHOD(Phalcon_Filter_FilterFactory, newInstance) object_init_ex(return_value, phalcon_filter_filter_ce); ZEPHIR_CALL_METHOD(&_0, this_ptr, "getservices", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 303, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 304, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/filter/sanitize/absint.zep.c b/ext/phalcon/filter/sanitize/absint.zep.c index b53d8bf325c..42d0fda9e45 100644 --- a/ext/phalcon/filter/sanitize/absint.zep.c +++ b/ext/phalcon/filter/sanitize/absint.zep.c @@ -66,10 +66,10 @@ PHP_METHOD(Phalcon_Filter_Sanitize_AbsInt, __invoke) ZVAL_LONG(&_0, 519); - ZEPHIR_CALL_FUNCTION(&_1, "filter_var", NULL, 304, input, &_0); + ZEPHIR_CALL_FUNCTION(&_1, "filter_var", NULL, 305, input, &_0); zephir_check_call_status(); ZVAL_LONG(&_0, zephir_get_intval(&_1)); - ZEPHIR_RETURN_CALL_FUNCTION("abs", NULL, 305, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("abs", NULL, 306, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/filter/sanitize/email.zep.c b/ext/phalcon/filter/sanitize/email.zep.c index 01c0d81d11f..62765a92b08 100644 --- a/ext/phalcon/filter/sanitize/email.zep.c +++ b/ext/phalcon/filter/sanitize/email.zep.c @@ -66,7 +66,7 @@ PHP_METHOD(Phalcon_Filter_Sanitize_Email, __invoke) ZVAL_LONG(&_0, 517); ZVAL_LONG(&_1, 1048576); - ZEPHIR_RETURN_CALL_FUNCTION("filter_var", NULL, 304, input, &_0, &_1); + ZEPHIR_RETURN_CALL_FUNCTION("filter_var", NULL, 305, input, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/filter/sanitize/floatval.zep.c b/ext/phalcon/filter/sanitize/floatval.zep.c index bcde7d4da4b..1b2c7e52d9f 100644 --- a/ext/phalcon/filter/sanitize/floatval.zep.c +++ b/ext/phalcon/filter/sanitize/floatval.zep.c @@ -72,7 +72,7 @@ PHP_METHOD(Phalcon_Filter_Sanitize_FloatVal, __invoke) zephir_create_array(&_0, 1, 0); add_assoc_long_ex(&_0, SL("flags"), 4096); ZVAL_LONG(&_1, 520); - ZEPHIR_CALL_FUNCTION(&_2, "filter_var", NULL, 304, input, &_1, &_0); + ZEPHIR_CALL_FUNCTION(&_2, "filter_var", NULL, 305, input, &_1, &_0); zephir_check_call_status(); RETURN_MM_DOUBLE(zephir_get_doubleval(&_2)); } diff --git a/ext/phalcon/filter/sanitize/intval.zep.c b/ext/phalcon/filter/sanitize/intval.zep.c index 2482bcc0fa9..d1f1cfd6154 100644 --- a/ext/phalcon/filter/sanitize/intval.zep.c +++ b/ext/phalcon/filter/sanitize/intval.zep.c @@ -66,7 +66,7 @@ PHP_METHOD(Phalcon_Filter_Sanitize_IntVal, __invoke) ZVAL_LONG(&_0, 519); - ZEPHIR_CALL_FUNCTION(&_1, "filter_var", NULL, 304, input, &_0); + ZEPHIR_CALL_FUNCTION(&_1, "filter_var", NULL, 305, input, &_0); zephir_check_call_status(); RETURN_MM_LONG(zephir_get_intval(&_1)); } diff --git a/ext/phalcon/filter/sanitize/lower.zep.c b/ext/phalcon/filter/sanitize/lower.zep.c index 0e2e316e4c7..fbaf12a35f5 100644 --- a/ext/phalcon/filter/sanitize/lower.zep.c +++ b/ext/phalcon/filter/sanitize/lower.zep.c @@ -87,7 +87,7 @@ PHP_METHOD(Phalcon_Filter_Sanitize_Lower, __invoke) zephir_check_call_status(); RETURN_MM(); } - ZEPHIR_CALL_FUNCTION(&_2, "utf8_decode", NULL, 306, &input); + ZEPHIR_CALL_FUNCTION(&_2, "utf8_decode", NULL, 307, &input); zephir_check_call_status(); zephir_fast_strtolower(return_value, &_2); RETURN_MM(); diff --git a/ext/phalcon/filter/sanitize/special.zep.c b/ext/phalcon/filter/sanitize/special.zep.c index 523a1a3ef64..3dd17e6aae8 100644 --- a/ext/phalcon/filter/sanitize/special.zep.c +++ b/ext/phalcon/filter/sanitize/special.zep.c @@ -64,7 +64,7 @@ PHP_METHOD(Phalcon_Filter_Sanitize_Special, __invoke) ZVAL_LONG(&_0, 515); - ZEPHIR_RETURN_CALL_FUNCTION("filter_var", NULL, 304, input, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("filter_var", NULL, 305, input, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/filter/sanitize/specialfull.zep.c b/ext/phalcon/filter/sanitize/specialfull.zep.c index a26dc9d7269..e71c3a224b7 100644 --- a/ext/phalcon/filter/sanitize/specialfull.zep.c +++ b/ext/phalcon/filter/sanitize/specialfull.zep.c @@ -64,7 +64,7 @@ PHP_METHOD(Phalcon_Filter_Sanitize_SpecialFull, __invoke) ZVAL_LONG(&_0, 522); - ZEPHIR_RETURN_CALL_FUNCTION("filter_var", NULL, 304, input, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("filter_var", NULL, 305, input, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/filter/sanitize/stringval.zep.c b/ext/phalcon/filter/sanitize/stringval.zep.c index 096e271af7b..ad63b73a26c 100644 --- a/ext/phalcon/filter/sanitize/stringval.zep.c +++ b/ext/phalcon/filter/sanitize/stringval.zep.c @@ -64,7 +64,7 @@ PHP_METHOD(Phalcon_Filter_Sanitize_StringVal, __invoke) ZVAL_LONG(&_0, 513); - ZEPHIR_RETURN_CALL_FUNCTION("filter_var", NULL, 304, input, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("filter_var", NULL, 305, input, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/filter/sanitize/striptags.zep.c b/ext/phalcon/filter/sanitize/striptags.zep.c index 1c92b41cd3e..5ca0e8aaa64 100644 --- a/ext/phalcon/filter/sanitize/striptags.zep.c +++ b/ext/phalcon/filter/sanitize/striptags.zep.c @@ -75,7 +75,7 @@ PHP_METHOD(Phalcon_Filter_Sanitize_Striptags, __invoke) } - ZEPHIR_RETURN_CALL_FUNCTION("strip_tags", NULL, 307, &input); + ZEPHIR_RETURN_CALL_FUNCTION("strip_tags", NULL, 308, &input); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/filter/sanitize/upper.zep.c b/ext/phalcon/filter/sanitize/upper.zep.c index e83d9f2ce98..754a1096247 100644 --- a/ext/phalcon/filter/sanitize/upper.zep.c +++ b/ext/phalcon/filter/sanitize/upper.zep.c @@ -87,7 +87,7 @@ PHP_METHOD(Phalcon_Filter_Sanitize_Upper, __invoke) zephir_check_call_status(); RETURN_MM(); } - ZEPHIR_CALL_FUNCTION(&_2, "utf8_decode", NULL, 306, &input); + ZEPHIR_CALL_FUNCTION(&_2, "utf8_decode", NULL, 307, &input); zephir_check_call_status(); zephir_fast_strtoupper(return_value, &_2); RETURN_MM(); diff --git a/ext/phalcon/filter/sanitize/upperwords.zep.c b/ext/phalcon/filter/sanitize/upperwords.zep.c index b3a158857b2..92e90a8cf04 100644 --- a/ext/phalcon/filter/sanitize/upperwords.zep.c +++ b/ext/phalcon/filter/sanitize/upperwords.zep.c @@ -86,9 +86,9 @@ PHP_METHOD(Phalcon_Filter_Sanitize_UpperWords, __invoke) zephir_check_call_status(); RETURN_MM(); } - ZEPHIR_CALL_FUNCTION(&_2, "utf8_decode", NULL, 306, &input); + ZEPHIR_CALL_FUNCTION(&_2, "utf8_decode", NULL, 307, &input); zephir_check_call_status(); - ZEPHIR_RETURN_CALL_FUNCTION("ucwords", NULL, 308, &_2); + ZEPHIR_RETURN_CALL_FUNCTION("ucwords", NULL, 309, &_2); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/filter/sanitize/url.zep.c b/ext/phalcon/filter/sanitize/url.zep.c index 30da13762a2..9e9cb8f4e49 100644 --- a/ext/phalcon/filter/sanitize/url.zep.c +++ b/ext/phalcon/filter/sanitize/url.zep.c @@ -64,7 +64,7 @@ PHP_METHOD(Phalcon_Filter_Sanitize_Url, __invoke) ZVAL_LONG(&_0, 518); - ZEPHIR_RETURN_CALL_FUNCTION("filter_var", NULL, 304, input, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("filter_var", NULL, 305, input, &_0); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/filter/validation.zep.c b/ext/phalcon/filter/validation.zep.c index 30e3610ab57..c770705f3a9 100644 --- a/ext/phalcon/filter/validation.zep.c +++ b/ext/phalcon/filter/validation.zep.c @@ -285,7 +285,7 @@ PHP_METHOD(Phalcon_Filter_Validation, appendMessage) ZEPHIR_CALL_METHOD(NULL, &messages, "__construct", NULL, 8); zephir_check_call_status(); } - ZEPHIR_CALL_METHOD(NULL, &messages, "appendmessage", NULL, 309, message); + ZEPHIR_CALL_METHOD(NULL, &messages, "appendmessage", NULL, 310, message); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("messages"), &messages); RETURN_THIS(); @@ -674,7 +674,7 @@ PHP_METHOD(Phalcon_Filter_Validation, getValue) zephir_camelize(&_6$$13, &field, NULL ); ZEPHIR_INIT_VAR(&method); ZEPHIR_CONCAT_SV(&method, "set", &_6$$13); - ZEPHIR_CALL_FUNCTION(&_7$$13, "property_exists", NULL, 310, &entity, &field); + ZEPHIR_CALL_FUNCTION(&_7$$13, "property_exists", NULL, 311, &entity, &field); zephir_check_call_status(); if ((zephir_method_exists(&entity, &method) == SUCCESS)) { ZEPHIR_CALL_METHOD_ZVAL(NULL, &entity, &method, NULL, 0, &value); @@ -1331,7 +1331,7 @@ PHP_METHOD(Phalcon_Filter_Validation, preChecking) { ZEPHIR_INIT_NVAR(&singleField); ZVAL_COPY(&singleField, _0$$3); - ZEPHIR_CALL_METHOD(&_2$$4, this_ptr, "prechecking", &_3, 311, &singleField, validator); + ZEPHIR_CALL_METHOD(&_2$$4, this_ptr, "prechecking", &_3, 312, &singleField, validator); zephir_check_call_status(); zephir_array_append(&results, &_2$$4, PH_SEPARATE, "phalcon/Filter/Validation.zep", 592); if (zephir_fast_in_array(&__$false, &results)) { @@ -1350,7 +1350,7 @@ PHP_METHOD(Phalcon_Filter_Validation, preChecking) } ZEPHIR_CALL_METHOD(&singleField, field, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_4$$6, this_ptr, "prechecking", &_3, 311, &singleField, validator); + ZEPHIR_CALL_METHOD(&_4$$6, this_ptr, "prechecking", &_3, 312, &singleField, validator); zephir_check_call_status(); zephir_array_append(&results, &_4$$6, PH_SEPARATE, "phalcon/Filter/Validation.zep", 592); if (zephir_fast_in_array(&__$false, &results)) { diff --git a/ext/phalcon/filter/validation/validator/alnum.zep.c b/ext/phalcon/filter/validation/validator/alnum.zep.c index 3ccfc6b6418..4fde0f6f491 100644 --- a/ext/phalcon/filter/validation/validator/alnum.zep.c +++ b/ext/phalcon/filter/validation/validator/alnum.zep.c @@ -149,7 +149,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Alnum, validate) if (zephir_is_true(&_0)) { RETURN_MM_BOOL(1); } - ZEPHIR_CALL_FUNCTION(&_1, "ctype_alnum", NULL, 312, &value); + ZEPHIR_CALL_FUNCTION(&_1, "ctype_alnum", NULL, 313, &value); zephir_check_call_status(); if (!(zephir_is_true(&_1))) { ZEPHIR_CALL_METHOD(&_2$$4, this_ptr, "messagefactory", NULL, 0, validation, field); diff --git a/ext/phalcon/filter/validation/validator/confirmation.zep.c b/ext/phalcon/filter/validation/validator/confirmation.zep.c index 5a45c2c5f0a..9506c13d832 100644 --- a/ext/phalcon/filter/validation/validator/confirmation.zep.c +++ b/ext/phalcon/filter/validation/validator/confirmation.zep.c @@ -169,7 +169,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Confirmation, validate) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&valueWith, validation, "getvalue", NULL, 0, &fieldWith); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_2, this_ptr, "compare", NULL, 313, &value, &valueWith); + ZEPHIR_CALL_METHOD(&_2, this_ptr, "compare", NULL, 314, &value, &valueWith); zephir_check_call_status(); if (!(zephir_is_true(&_2))) { ZEPHIR_INIT_VAR(&_3$$4); @@ -252,7 +252,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Confirmation, compare) zephir_check_call_status(); zephir_get_strval(&b, &_5$$3); } - ZEPHIR_CALL_FUNCTION(&_6, "strcmp", NULL, 314, &a, &b); + ZEPHIR_CALL_FUNCTION(&_6, "strcmp", NULL, 315, &a, &b); zephir_check_call_status(); RETURN_MM_BOOL(ZEPHIR_IS_LONG_IDENTICAL(&_6, 0)); } diff --git a/ext/phalcon/filter/validation/validator/creditcard.zep.c b/ext/phalcon/filter/validation/validator/creditcard.zep.c index 51ac87b2b7b..15dbc2581f6 100644 --- a/ext/phalcon/filter/validation/validator/creditcard.zep.c +++ b/ext/phalcon/filter/validation/validator/creditcard.zep.c @@ -149,7 +149,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_CreditCard, validate) if (zephir_is_true(&_0)) { RETURN_MM_BOOL(1); } - ZEPHIR_CALL_METHOD(&valid, this_ptr, "verifybyluhnalgorithm", NULL, 315, &value); + ZEPHIR_CALL_METHOD(&valid, this_ptr, "verifybyluhnalgorithm", NULL, 316, &value); zephir_check_call_status(); if (!(zephir_is_true(&valid))) { ZEPHIR_CALL_METHOD(&_1$$4, this_ptr, "messagefactory", NULL, 0, validation, field); @@ -205,11 +205,11 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_CreditCard, verifyByLuhnAlgorithm ZEPHIR_INIT_VAR(&hash); ZVAL_STRING(&hash, ""); - ZEPHIR_CALL_FUNCTION(&_0, "str_split", NULL, 115, &number); + ZEPHIR_CALL_FUNCTION(&_0, "str_split", NULL, 117, &number); zephir_check_call_status(); zephir_get_arrval(&_1, &_0); ZEPHIR_CPY_WRT(&digits, &_1); - ZEPHIR_CALL_FUNCTION(&_3, "array_reverse", NULL, 316, &digits); + ZEPHIR_CALL_FUNCTION(&_3, "array_reverse", NULL, 317, &digits); zephir_check_call_status(); zephir_is_iterable(&_3, 0, "phalcon/Filter/Validation/Validator/CreditCard.zep", 109); if (Z_TYPE_P(&_3) == IS_ARRAY) { @@ -259,9 +259,9 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_CreditCard, verifyByLuhnAlgorithm } ZEPHIR_INIT_NVAR(&digit); ZEPHIR_INIT_NVAR(&position); - ZEPHIR_CALL_FUNCTION(&_10, "str_split", NULL, 115, &hash); + ZEPHIR_CALL_FUNCTION(&_10, "str_split", NULL, 117, &hash); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&result, "array_sum", NULL, 317, &_10); + ZEPHIR_CALL_FUNCTION(&result, "array_sum", NULL, 318, &_10); zephir_check_call_status(); RETURN_MM_BOOL((zephir_safe_mod_zval_long(&result, 10) == 0)); } diff --git a/ext/phalcon/filter/validation/validator/date.zep.c b/ext/phalcon/filter/validation/validator/date.zep.c index 5bef94c39c4..9eacf9bc2e2 100644 --- a/ext/phalcon/filter/validation/validator/date.zep.c +++ b/ext/phalcon/filter/validation/validator/date.zep.c @@ -171,7 +171,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Date, validate) ZEPHIR_INIT_NVAR(&format); ZVAL_STRING(&format, "Y-m-d"); } - ZEPHIR_CALL_METHOD(&_3, this_ptr, "checkdate", NULL, 318, &value, &format); + ZEPHIR_CALL_METHOD(&_3, this_ptr, "checkdate", NULL, 319, &value, &format); zephir_check_call_status(); if (!(zephir_is_true(&_3))) { ZEPHIR_CALL_METHOD(&_4$$6, this_ptr, "messagefactory", NULL, 0, validation, field); diff --git a/ext/phalcon/filter/validation/validator/digit.zep.c b/ext/phalcon/filter/validation/validator/digit.zep.c index 239a0a7c01b..ea8f7cbcac0 100644 --- a/ext/phalcon/filter/validation/validator/digit.zep.c +++ b/ext/phalcon/filter/validation/validator/digit.zep.c @@ -152,7 +152,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Digit, validate) } _1 = Z_TYPE_P(&value) == IS_LONG; if (!(_1)) { - ZEPHIR_CALL_FUNCTION(&_2, "ctype_digit", NULL, 319, &value); + ZEPHIR_CALL_FUNCTION(&_2, "ctype_digit", NULL, 320, &value); zephir_check_call_status(); _1 = zephir_is_true(&_2); } diff --git a/ext/phalcon/filter/validation/validator/email.zep.c b/ext/phalcon/filter/validation/validator/email.zep.c index f2ad6a0219b..f2bb0f7d800 100644 --- a/ext/phalcon/filter/validation/validator/email.zep.c +++ b/ext/phalcon/filter/validation/validator/email.zep.c @@ -151,7 +151,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Email, validate) RETURN_MM_BOOL(1); } ZVAL_LONG(&_1, 274); - ZEPHIR_CALL_FUNCTION(&_2, "filter_var", NULL, 304, &value, &_1); + ZEPHIR_CALL_FUNCTION(&_2, "filter_var", NULL, 305, &value, &_1); zephir_check_call_status(); if (!(zephir_is_true(&_2))) { ZEPHIR_CALL_METHOD(&_3$$4, this_ptr, "messagefactory", NULL, 0, validation, field); diff --git a/ext/phalcon/filter/validation/validator/exclusionin.zep.c b/ext/phalcon/filter/validation/validator/exclusionin.zep.c index 6a6aa907eaa..936850c7509 100644 --- a/ext/phalcon/filter/validation/validator/exclusionin.zep.c +++ b/ext/phalcon/filter/validation/validator/exclusionin.zep.c @@ -207,7 +207,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_ExclusionIn, validate) return; } } - ZEPHIR_CALL_FUNCTION(&_5, "in_array", NULL, 320, &value, &domain, &strict); + ZEPHIR_CALL_FUNCTION(&_5, "in_array", NULL, 321, &value, &domain, &strict); zephir_check_call_status(); if (zephir_is_true(&_5)) { ZEPHIR_INIT_VAR(&replacePairs); diff --git a/ext/phalcon/filter/validation/validator/file.zep.c b/ext/phalcon/filter/validation/validator/file.zep.c index c4a6ffa5b0b..42b36b2df9f 100644 --- a/ext/phalcon/filter/validation/validator/file.zep.c +++ b/ext/phalcon/filter/validation/validator/file.zep.c @@ -316,7 +316,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File, __construct) zephir_array_update_string(&_17$$7, SL("size"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_17$$7, SL("message"), &message, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_17$$7, SL("included"), &included, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_18, 321, &_17$$7); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_18, 322, &_17$$7); zephir_check_call_status(); zephir_array_unset_string(&options, SL("messageMinSize"), PH_SEPARATE); zephir_array_unset_string(&options, SL("includedMinSize"), PH_SEPARATE); @@ -336,7 +336,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File, __construct) zephir_array_update_string(&_20$$8, SL("size"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_20$$8, SL("message"), &message, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_20$$8, SL("included"), &included, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_21, 322, &_20$$8); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_21, 323, &_20$$8); zephir_check_call_status(); zephir_array_unset_string(&options, SL("maxSize"), PH_SEPARATE); zephir_array_unset_string(&options, SL("messageSize"), PH_SEPARATE); @@ -352,7 +352,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File, __construct) zephir_create_array(&_23$$9, 2, 0); zephir_array_update_string(&_23$$9, SL("size"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_23$$9, SL("message"), &message, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_24, 323, &_23$$9); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_24, 324, &_23$$9); zephir_check_call_status(); zephir_array_unset_string(&options, SL("equalSize"), PH_SEPARATE); zephir_array_unset_string(&options, SL("messageEqualSize"), PH_SEPARATE); @@ -367,7 +367,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File, __construct) zephir_create_array(&_26$$10, 2, 0); zephir_array_update_string(&_26$$10, SL("types"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_26$$10, SL("message"), &message, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_27, 324, &_26$$10); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_27, 325, &_26$$10); zephir_check_call_status(); zephir_array_unset_string(&options, SL("allowedTypes"), PH_SEPARATE); zephir_array_unset_string(&options, SL("messageType"), PH_SEPARATE); @@ -387,7 +387,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File, __construct) zephir_array_update_string(&_29$$11, SL("resolution"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_29$$11, SL("included"), &included, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_29$$11, SL("message"), &message, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_30, 325, &_29$$11); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_30, 326, &_29$$11); zephir_check_call_status(); zephir_array_unset_string(&options, SL("maxResolution"), PH_SEPARATE); zephir_array_unset_string(&options, SL("includedMaxResolution"), PH_SEPARATE); @@ -408,7 +408,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File, __construct) zephir_array_update_string(&_32$$12, SL("resolution"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_32$$12, SL("included"), &included, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_32$$12, SL("message"), &message, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_33, 326, &_32$$12); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_33, 327, &_32$$12); zephir_check_call_status(); zephir_array_unset_string(&options, SL("minResolution"), PH_SEPARATE); zephir_array_unset_string(&options, SL("includedMinResolution"), PH_SEPARATE); @@ -424,7 +424,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File, __construct) zephir_create_array(&_35$$13, 2, 0); zephir_array_update_string(&_35$$13, SL("resolution"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_35$$13, SL("message"), &message, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_36, 327, &_35$$13); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_36, 328, &_35$$13); zephir_check_call_status(); zephir_array_unset_string(&options, SL("equalResolution"), PH_SEPARATE); zephir_array_unset_string(&options, SL("messageEqualResolution"), PH_SEPARATE); @@ -432,15 +432,15 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File, __construct) continue; } if (Z_TYPE_P(&messageFileEmpty) != IS_NULL) { - ZEPHIR_CALL_METHOD(NULL, &validator, "setmessagefileempty", &_37, 328, &messageFileEmpty); + ZEPHIR_CALL_METHOD(NULL, &validator, "setmessagefileempty", &_37, 329, &messageFileEmpty); zephir_check_call_status(); } if (Z_TYPE_P(&messageIniSize) != IS_NULL) { - ZEPHIR_CALL_METHOD(NULL, &validator, "setmessageinisize", &_38, 329, &messageIniSize); + ZEPHIR_CALL_METHOD(NULL, &validator, "setmessageinisize", &_38, 330, &messageIniSize); zephir_check_call_status(); } if (Z_TYPE_P(&messageValid) != IS_NULL) { - ZEPHIR_CALL_METHOD(NULL, &validator, "setmessagevalid", &_39, 330, &messageValid); + ZEPHIR_CALL_METHOD(NULL, &validator, "setmessagevalid", &_39, 331, &messageValid); zephir_check_call_status(); } zephir_update_property_array_append(this_ptr, SL("validators"), &validator); @@ -502,7 +502,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File, __construct) zephir_array_update_string(&_49$$19, SL("size"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_49$$19, SL("message"), &message, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_49$$19, SL("included"), &included, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_36, 327, &_49$$19); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_36, 328, &_49$$19); zephir_check_call_status(); zephir_array_unset_string(&options, SL("messageMinSize"), PH_SEPARATE); zephir_array_unset_string(&options, SL("includedMinSize"), PH_SEPARATE); @@ -522,7 +522,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File, __construct) zephir_array_update_string(&_51$$20, SL("size"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_51$$20, SL("message"), &message, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_51$$20, SL("included"), &included, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_36, 327, &_51$$20); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_36, 328, &_51$$20); zephir_check_call_status(); zephir_array_unset_string(&options, SL("maxSize"), PH_SEPARATE); zephir_array_unset_string(&options, SL("messageSize"), PH_SEPARATE); @@ -538,7 +538,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File, __construct) zephir_create_array(&_53$$21, 2, 0); zephir_array_update_string(&_53$$21, SL("size"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_53$$21, SL("message"), &message, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_36, 327, &_53$$21); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_36, 328, &_53$$21); zephir_check_call_status(); zephir_array_unset_string(&options, SL("equalSize"), PH_SEPARATE); zephir_array_unset_string(&options, SL("messageEqualSize"), PH_SEPARATE); @@ -553,7 +553,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File, __construct) zephir_create_array(&_55$$22, 2, 0); zephir_array_update_string(&_55$$22, SL("types"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_55$$22, SL("message"), &message, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_36, 327, &_55$$22); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_36, 328, &_55$$22); zephir_check_call_status(); zephir_array_unset_string(&options, SL("allowedTypes"), PH_SEPARATE); zephir_array_unset_string(&options, SL("messageType"), PH_SEPARATE); @@ -573,7 +573,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File, __construct) zephir_array_update_string(&_57$$23, SL("resolution"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_57$$23, SL("included"), &included, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_57$$23, SL("message"), &message, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_36, 327, &_57$$23); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_36, 328, &_57$$23); zephir_check_call_status(); zephir_array_unset_string(&options, SL("maxResolution"), PH_SEPARATE); zephir_array_unset_string(&options, SL("includedMaxResolution"), PH_SEPARATE); @@ -594,7 +594,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File, __construct) zephir_array_update_string(&_59$$24, SL("resolution"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_59$$24, SL("included"), &included, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_59$$24, SL("message"), &message, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_36, 327, &_59$$24); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_36, 328, &_59$$24); zephir_check_call_status(); zephir_array_unset_string(&options, SL("minResolution"), PH_SEPARATE); zephir_array_unset_string(&options, SL("includedMinResolution"), PH_SEPARATE); @@ -610,7 +610,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File, __construct) zephir_create_array(&_61$$25, 2, 0); zephir_array_update_string(&_61$$25, SL("resolution"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_61$$25, SL("message"), &message, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_36, 327, &_61$$25); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_36, 328, &_61$$25); zephir_check_call_status(); zephir_array_unset_string(&options, SL("equalResolution"), PH_SEPARATE); zephir_array_unset_string(&options, SL("messageEqualResolution"), PH_SEPARATE); @@ -618,15 +618,15 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File, __construct) continue; } if (Z_TYPE_P(&messageFileEmpty) != IS_NULL) { - ZEPHIR_CALL_METHOD(NULL, &validator, "setmessagefileempty", &_37, 328, &messageFileEmpty); + ZEPHIR_CALL_METHOD(NULL, &validator, "setmessagefileempty", &_37, 329, &messageFileEmpty); zephir_check_call_status(); } if (Z_TYPE_P(&messageIniSize) != IS_NULL) { - ZEPHIR_CALL_METHOD(NULL, &validator, "setmessageinisize", &_38, 329, &messageIniSize); + ZEPHIR_CALL_METHOD(NULL, &validator, "setmessageinisize", &_38, 330, &messageIniSize); zephir_check_call_status(); } if (Z_TYPE_P(&messageValid) != IS_NULL) { - ZEPHIR_CALL_METHOD(NULL, &validator, "setmessagevalid", &_39, 330, &messageValid); + ZEPHIR_CALL_METHOD(NULL, &validator, "setmessagevalid", &_39, 331, &messageValid); zephir_check_call_status(); } zephir_update_property_array_append(this_ptr, SL("validators"), &validator); diff --git a/ext/phalcon/filter/validation/validator/file/mimetype.zep.c b/ext/phalcon/filter/validation/validator/file/mimetype.zep.c index 7457c6d3417..3994e50d3ef 100644 --- a/ext/phalcon/filter/validation/validator/file/mimetype.zep.c +++ b/ext/phalcon/filter/validation/validator/file/mimetype.zep.c @@ -147,12 +147,12 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File_MimeType, validate) } if ((zephir_function_exists_ex(ZEND_STRL("finfo_open")) == SUCCESS)) { ZVAL_LONG(&_2$$6, 16); - ZEPHIR_CALL_FUNCTION(&tmp, "finfo_open", NULL, 331, &_2$$6); + ZEPHIR_CALL_FUNCTION(&tmp, "finfo_open", NULL, 332, &_2$$6); zephir_check_call_status(); zephir_array_fetch_string(&_3$$6, &value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/Filter/Validation/Validator/File/MimeType.zep", 101); - ZEPHIR_CALL_FUNCTION(&mime, "finfo_file", NULL, 332, &tmp, &_3$$6); + ZEPHIR_CALL_FUNCTION(&mime, "finfo_file", NULL, 333, &tmp, &_3$$6); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(NULL, "finfo_close", NULL, 333, &tmp); + ZEPHIR_CALL_FUNCTION(NULL, "finfo_close", NULL, 334, &tmp); zephir_check_call_status(); } else { ZEPHIR_OBS_NVAR(&mime); diff --git a/ext/phalcon/filter/validation/validator/file/resolution/equal.zep.c b/ext/phalcon/filter/validation/validator/file/resolution/equal.zep.c index 33fc81aa9b3..709e6fe7196 100644 --- a/ext/phalcon/filter/validation/validator/file/resolution/equal.zep.c +++ b/ext/phalcon/filter/validation/validator/file/resolution/equal.zep.c @@ -169,7 +169,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File_Resolution_Equal, validate) ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field); zephir_check_call_status(); zephir_array_fetch_string(&_1, &value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/Filter/Validation/Validator/File/Resolution/Equal.zep", 88); - ZEPHIR_CALL_FUNCTION(&tmp, "getimagesize", NULL, 334, &_1); + ZEPHIR_CALL_FUNCTION(&tmp, "getimagesize", NULL, 335, &_1); zephir_check_call_status(); ZEPHIR_OBS_VAR(&width); zephir_array_fetch_long(&width, &tmp, 0, PH_NOISY, "phalcon/Filter/Validation/Validator/File/Resolution/Equal.zep", 89); diff --git a/ext/phalcon/filter/validation/validator/file/resolution/max.zep.c b/ext/phalcon/filter/validation/validator/file/resolution/max.zep.c index 66c75b1e53a..d38ca47229f 100644 --- a/ext/phalcon/filter/validation/validator/file/resolution/max.zep.c +++ b/ext/phalcon/filter/validation/validator/file/resolution/max.zep.c @@ -180,7 +180,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File_Resolution_Max, validate) ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field); zephir_check_call_status(); zephir_array_fetch_string(&_1, &value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/Filter/Validation/Validator/File/Resolution/Max.zep", 94); - ZEPHIR_CALL_FUNCTION(&tmp, "getimagesize", NULL, 334, &_1); + ZEPHIR_CALL_FUNCTION(&tmp, "getimagesize", NULL, 335, &_1); zephir_check_call_status(); ZEPHIR_OBS_VAR(&width); zephir_array_fetch_long(&width, &tmp, 0, PH_NOISY, "phalcon/Filter/Validation/Validator/File/Resolution/Max.zep", 95); diff --git a/ext/phalcon/filter/validation/validator/file/resolution/min.zep.c b/ext/phalcon/filter/validation/validator/file/resolution/min.zep.c index 7417e9761ca..a636d8f87c0 100644 --- a/ext/phalcon/filter/validation/validator/file/resolution/min.zep.c +++ b/ext/phalcon/filter/validation/validator/file/resolution/min.zep.c @@ -180,7 +180,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_File_Resolution_Min, validate) ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field); zephir_check_call_status(); zephir_array_fetch_string(&_1, &value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/Filter/Validation/Validator/File/Resolution/Min.zep", 94); - ZEPHIR_CALL_FUNCTION(&tmp, "getimagesize", NULL, 334, &_1); + ZEPHIR_CALL_FUNCTION(&tmp, "getimagesize", NULL, 335, &_1); zephir_check_call_status(); ZEPHIR_OBS_VAR(&width); zephir_array_fetch_long(&width, &tmp, 0, PH_NOISY, "phalcon/Filter/Validation/Validator/File/Resolution/Min.zep", 95); diff --git a/ext/phalcon/filter/validation/validator/inclusionin.zep.c b/ext/phalcon/filter/validation/validator/inclusionin.zep.c index fa958d7d559..1137623e688 100644 --- a/ext/phalcon/filter/validation/validator/inclusionin.zep.c +++ b/ext/phalcon/filter/validation/validator/inclusionin.zep.c @@ -201,7 +201,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_InclusionIn, validate) return; } } - ZEPHIR_CALL_FUNCTION(&_5, "in_array", NULL, 320, &value, &domain, &strict); + ZEPHIR_CALL_FUNCTION(&_5, "in_array", NULL, 321, &value, &domain, &strict); zephir_check_call_status(); if (!(zephir_is_true(&_5))) { ZEPHIR_INIT_VAR(&replacePairs); diff --git a/ext/phalcon/filter/validation/validator/ip.zep.c b/ext/phalcon/filter/validation/validator/ip.zep.c index 8ba7961ae80..d3bcb8f7507 100644 --- a/ext/phalcon/filter/validation/validator/ip.zep.c +++ b/ext/phalcon/filter/validation/validator/ip.zep.c @@ -240,7 +240,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Ip, validate) zephir_bitwise_or_function(&_10, &_9, &allowReserved); zephir_array_update_string(&options, SL("flags"), &_10, PH_COPY | PH_SEPARATE); ZVAL_LONG(&_2, 275); - ZEPHIR_CALL_FUNCTION(&_11, "filter_var", NULL, 304, &value, &_2, &options); + ZEPHIR_CALL_FUNCTION(&_11, "filter_var", NULL, 305, &value, &_2, &options); zephir_check_call_status(); if (!(zephir_is_true(&_11))) { ZEPHIR_CALL_METHOD(&_12$$7, this_ptr, "messagefactory", NULL, 0, validation, field); diff --git a/ext/phalcon/filter/validation/validator/stringlength.zep.c b/ext/phalcon/filter/validation/validator/stringlength.zep.c index 9e678c41a8e..4cc2b784564 100644 --- a/ext/phalcon/filter/validation/validator/stringlength.zep.c +++ b/ext/phalcon/filter/validation/validator/stringlength.zep.c @@ -205,7 +205,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_StringLength, __construct) zephir_array_update_string(&_8$$4, SL("min"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_8$$4, SL("message"), &message, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_8$$4, SL("included"), &included, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_9, 335, &_8$$4); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_9, 336, &_8$$4); zephir_check_call_status(); zephir_array_unset_string(&options, SL("min"), PH_SEPARATE); zephir_array_unset_string(&options, SL("message"), PH_SEPARATE); @@ -234,7 +234,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_StringLength, __construct) zephir_array_update_string(&_10$$9, SL("max"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_10$$9, SL("message"), &message, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_10$$9, SL("included"), &included, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_11, 336, &_10$$9); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_11, 337, &_10$$9); zephir_check_call_status(); zephir_array_unset_string(&options, SL("max"), PH_SEPARATE); zephir_array_unset_string(&options, SL("message"), PH_SEPARATE); @@ -289,7 +289,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_StringLength, __construct) zephir_array_update_string(&_15$$16, SL("min"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_15$$16, SL("message"), &message, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_15$$16, SL("included"), &included, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_11, 336, &_15$$16); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_11, 337, &_15$$16); zephir_check_call_status(); zephir_array_unset_string(&options, SL("min"), PH_SEPARATE); zephir_array_unset_string(&options, SL("message"), PH_SEPARATE); @@ -318,7 +318,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_StringLength, __construct) zephir_array_update_string(&_16$$21, SL("max"), &value, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_16$$21, SL("message"), &message, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_16$$21, SL("included"), &included, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_11, 336, &_16$$21); + ZEPHIR_CALL_METHOD(NULL, &validator, "__construct", &_11, 337, &_16$$21); zephir_check_call_status(); zephir_array_unset_string(&options, SL("max"), PH_SEPARATE); zephir_array_unset_string(&options, SL("message"), PH_SEPARATE); diff --git a/ext/phalcon/filter/validation/validator/uniqueness.zep.c b/ext/phalcon/filter/validation/validator/uniqueness.zep.c index 230e12e2106..d16ee19b326 100644 --- a/ext/phalcon/filter/validation/validator/uniqueness.zep.c +++ b/ext/phalcon/filter/validation/validator/uniqueness.zep.c @@ -648,7 +648,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Uniqueness, isUniquenessModel) zephir_array_keys(&_10$$6, &except); ZVAL_LONG(&_11$$6, 0); ZVAL_LONG(&_12$$6, (zephir_fast_count_int(&except) - 1)); - ZEPHIR_CALL_FUNCTION(&_13$$6, "range", &_14, 337, &_11$$6, &_12$$6); + ZEPHIR_CALL_FUNCTION(&_13$$6, "range", &_14, 338, &_11$$6, &_12$$6); zephir_check_call_status(); _9$$6 = !ZEPHIR_IS_IDENTICAL(&_10$$6, &_13$$6); } @@ -1052,7 +1052,7 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Uniqueness, isUniquenessModel) zephir_array_keys(&_88$$37, &except); ZVAL_LONG(&_89$$37, 0); ZVAL_LONG(&_90$$37, (zephir_fast_count_int(&except) - 1)); - ZEPHIR_CALL_FUNCTION(&_91$$37, "range", &_14, 337, &_89$$37, &_90$$37); + ZEPHIR_CALL_FUNCTION(&_91$$37, "range", &_14, 338, &_89$$37, &_90$$37); zephir_check_call_status(); _87$$37 = !ZEPHIR_IS_IDENTICAL(&_88$$37, &_91$$37); } diff --git a/ext/phalcon/filter/validation/validator/url.zep.c b/ext/phalcon/filter/validation/validator/url.zep.c index 3c0022f1684..6b6bcdcf5d9 100644 --- a/ext/phalcon/filter/validation/validator/url.zep.c +++ b/ext/phalcon/filter/validation/validator/url.zep.c @@ -159,11 +159,11 @@ PHP_METHOD(Phalcon_Filter_Validation_Validator_Url, validate) zephir_read_property(&_1, this_ptr, ZEND_STRL("options"), 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, 304, &value, &_2$$4, &options); + ZEPHIR_CALL_FUNCTION(&result, "filter_var", NULL, 305, &value, &_2$$4, &options); zephir_check_call_status(); } else { ZVAL_LONG(&_3$$5, 273); - ZEPHIR_CALL_FUNCTION(&result, "filter_var", NULL, 304, &value, &_3$$5); + ZEPHIR_CALL_FUNCTION(&result, "filter_var", NULL, 305, &value, &_3$$5); zephir_check_call_status(); } if (!(zephir_is_true(&result))) { diff --git a/ext/phalcon/forms/form.zep.c b/ext/phalcon/forms/form.zep.c index de8b9fe7fb0..27aeb9bfa48 100644 --- a/ext/phalcon/forms/form.zep.c +++ b/ext/phalcon/forms/form.zep.c @@ -1408,7 +1408,7 @@ PHP_METHOD(Phalcon_Forms_Form, isValid) if (_7) { ZEPHIR_INIT_NVAR(&validation); object_init_ex(&validation, phalcon_filter_validation_ce); - ZEPHIR_CALL_METHOD(NULL, &validation, "__construct", NULL, 338); + ZEPHIR_CALL_METHOD(NULL, &validation, "__construct", NULL, 339); zephir_check_call_status(); } zephir_read_property(&_8, this_ptr, ZEND_STRL("elements"), PH_NOISY_CC | PH_READONLY); @@ -1431,7 +1431,7 @@ PHP_METHOD(Phalcon_Forms_Form, isValid) { ZEPHIR_INIT_NVAR(&validator); ZVAL_COPY(&validator, _11$$10); - ZEPHIR_CALL_METHOD(NULL, &validation, "add", &_13, 339, &name, &validator); + ZEPHIR_CALL_METHOD(NULL, &validation, "add", &_13, 340, &name, &validator); zephir_check_call_status(); } ZEND_HASH_FOREACH_END(); } else { @@ -1445,7 +1445,7 @@ PHP_METHOD(Phalcon_Forms_Form, isValid) } ZEPHIR_CALL_METHOD(&validator, &validators, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &validation, "add", &_13, 339, &name, &validator); + ZEPHIR_CALL_METHOD(NULL, &validation, "add", &_13, 340, &name, &validator); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &validators, "next", NULL, 0); zephir_check_call_status(); @@ -1455,7 +1455,7 @@ PHP_METHOD(Phalcon_Forms_Form, isValid) ZEPHIR_CALL_METHOD(&filters, &element, "getfilters", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(&filters) == IS_ARRAY) { - ZEPHIR_CALL_METHOD(NULL, &validation, "setfilters", &_14, 340, &name, &filters); + ZEPHIR_CALL_METHOD(NULL, &validation, "setfilters", &_14, 341, &name, &filters); zephir_check_call_status(); } } ZEND_HASH_FOREACH_END(); @@ -1483,7 +1483,7 @@ PHP_METHOD(Phalcon_Forms_Form, isValid) { ZEPHIR_INIT_NVAR(&validator); ZVAL_COPY(&validator, _15$$15); - ZEPHIR_CALL_METHOD(NULL, &validation, "add", &_13, 339, &name, &validator); + ZEPHIR_CALL_METHOD(NULL, &validation, "add", &_13, 340, &name, &validator); zephir_check_call_status(); } ZEND_HASH_FOREACH_END(); } else { @@ -1497,7 +1497,7 @@ PHP_METHOD(Phalcon_Forms_Form, isValid) } ZEPHIR_CALL_METHOD(&validator, &validators, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, &validation, "add", &_13, 339, &name, &validator); + ZEPHIR_CALL_METHOD(NULL, &validation, "add", &_13, 340, &name, &validator); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &validators, "next", NULL, 0); zephir_check_call_status(); @@ -1507,7 +1507,7 @@ PHP_METHOD(Phalcon_Forms_Form, isValid) ZEPHIR_CALL_METHOD(&filters, &element, "getfilters", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(&filters) == IS_ARRAY) { - ZEPHIR_CALL_METHOD(NULL, &validation, "setfilters", &_14, 340, &name, &filters); + ZEPHIR_CALL_METHOD(NULL, &validation, "setfilters", &_14, 341, &name, &filters); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(NULL, &_8, "next", NULL, 0); @@ -1515,7 +1515,7 @@ PHP_METHOD(Phalcon_Forms_Form, isValid) } } ZEPHIR_INIT_NVAR(&element); - ZEPHIR_CALL_METHOD(&messages, &validation, "validate", NULL, 341, data, entity); + ZEPHIR_CALL_METHOD(&messages, &validation, "validate", NULL, 342, data, entity); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_17, &messages, "count", NULL, 0); zephir_check_call_status(); diff --git a/ext/phalcon/forms/manager.zep.c b/ext/phalcon/forms/manager.zep.c index 556b0a83df6..d7b16313ee6 100644 --- a/ext/phalcon/forms/manager.zep.c +++ b/ext/phalcon/forms/manager.zep.c @@ -83,7 +83,7 @@ PHP_METHOD(Phalcon_Forms_Manager, create) ZEPHIR_INIT_VAR(&form); object_init_ex(&form, phalcon_forms_form_ce); - ZEPHIR_CALL_METHOD(NULL, &form, "__construct", NULL, 342, entity); + ZEPHIR_CALL_METHOD(NULL, &form, "__construct", NULL, 343, entity); zephir_check_call_status(); zephir_update_property_array(this_ptr, SL("forms"), &name, &form); RETURN_CCTOR(&form); diff --git a/ext/phalcon/html/attributes.zep.c b/ext/phalcon/html/attributes.zep.c index 09bb057f3db..b158d8909ac 100644 --- a/ext/phalcon/html/attributes.zep.c +++ b/ext/phalcon/html/attributes.zep.c @@ -164,7 +164,7 @@ PHP_METHOD(Phalcon_Html_Attributes, renderAttributes) ZVAL_LONG(&_5$$4, 3); ZEPHIR_INIT_NVAR(&_6$$4); ZVAL_STRING(&_6$$4, "utf-8"); - ZEPHIR_CALL_FUNCTION(&_7$$4, "htmlspecialchars", &_8, 343, &value, &_5$$4, &_6$$4, &__$true); + ZEPHIR_CALL_FUNCTION(&_7$$4, "htmlspecialchars", &_8, 344, &value, &_5$$4, &_6$$4, &__$true); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_9$$4); ZEPHIR_CONCAT_VSVS(&_9$$4, &key, "=\"", &_7$$4, "\" "); @@ -192,7 +192,7 @@ PHP_METHOD(Phalcon_Html_Attributes, renderAttributes) ZVAL_LONG(&_11$$6, 3); ZEPHIR_INIT_NVAR(&_12$$6); ZVAL_STRING(&_12$$6, "utf-8"); - ZEPHIR_CALL_FUNCTION(&_13$$6, "htmlspecialchars", &_8, 343, &value, &_11$$6, &_12$$6, &__$true); + ZEPHIR_CALL_FUNCTION(&_13$$6, "htmlspecialchars", &_8, 344, &value, &_11$$6, &_12$$6, &__$true); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_14$$6); ZEPHIR_CONCAT_VSVS(&_14$$6, &key, "=\"", &_13$$6, "\" "); diff --git a/ext/phalcon/html/breadcrumbs.zep.c b/ext/phalcon/html/breadcrumbs.zep.c index 7e3e7542f13..39903f10425 100644 --- a/ext/phalcon/html/breadcrumbs.zep.c +++ b/ext/phalcon/html/breadcrumbs.zep.c @@ -267,7 +267,7 @@ PHP_METHOD(Phalcon_Html_Breadcrumbs, render) ZEPHIR_INIT_VAR(&urls); zephir_array_keys(&urls, &elements); ZEPHIR_MAKE_REF(&urls); - ZEPHIR_CALL_FUNCTION(&lastUrl, "end", NULL, 344, &urls); + ZEPHIR_CALL_FUNCTION(&lastUrl, "end", NULL, 345, &urls); ZEPHIR_UNREF(&urls); zephir_check_call_status(); ZEPHIR_OBS_VAR(&lastLabel); diff --git a/ext/phalcon/html/escaper.zep.c b/ext/phalcon/html/escaper.zep.c index 0d6c7ac17c1..c5ff4bc5a05 100644 --- a/ext/phalcon/html/escaper.zep.c +++ b/ext/phalcon/html/escaper.zep.c @@ -125,7 +125,7 @@ PHP_METHOD(Phalcon_Html_Escaper, attributes) zephir_read_property(&_0, this_ptr, ZEND_STRL("encoding"), PH_NOISY_CC | PH_READONLY); zephir_read_property(&_1, this_ptr, ZEND_STRL("doubleEncode"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2, 3); - ZEPHIR_RETURN_CALL_FUNCTION("htmlspecialchars", NULL, 343, &input, &_2, &_0, &_1); + ZEPHIR_RETURN_CALL_FUNCTION("htmlspecialchars", NULL, 344, &input, &_2, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -161,9 +161,9 @@ PHP_METHOD(Phalcon_Html_Escaper, css) zephir_get_strval(&input, input_param); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "normalizeencoding", NULL, 345, &input); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "normalizeencoding", NULL, 346, &input); zephir_check_call_status(); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "doescapecss", NULL, 346, &_0); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "doescapecss", NULL, 347, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -236,7 +236,7 @@ PHP_METHOD(Phalcon_Html_Escaper, detectEncoding) { ZEPHIR_INIT_NVAR(&charset); ZVAL_COPY(&charset, _2); - ZEPHIR_CALL_FUNCTION(&_4$$5, "mb_detect_encoding", &_5, 347, &input, &charset, &__$true); + ZEPHIR_CALL_FUNCTION(&_4$$5, "mb_detect_encoding", &_5, 348, &input, &charset, &__$true); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&_4$$5)) { RETURN_CCTOR(&charset); @@ -253,7 +253,7 @@ PHP_METHOD(Phalcon_Html_Escaper, detectEncoding) } ZEPHIR_CALL_METHOD(&charset, &_0, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&_6$$7, "mb_detect_encoding", &_5, 347, &input, &charset, &__$true); + ZEPHIR_CALL_FUNCTION(&_6$$7, "mb_detect_encoding", &_5, 348, &input, &charset, &__$true); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&_6$$7)) { RETURN_CCTOR(&charset); @@ -263,7 +263,7 @@ PHP_METHOD(Phalcon_Html_Escaper, detectEncoding) } } ZEPHIR_INIT_NVAR(&charset); - ZEPHIR_RETURN_CALL_FUNCTION("mb_detect_encoding", &_5, 347, &input); + ZEPHIR_RETURN_CALL_FUNCTION("mb_detect_encoding", &_5, 348, &input); zephir_check_call_status(); RETURN_MM(); } @@ -502,7 +502,7 @@ PHP_METHOD(Phalcon_Html_Escaper, html) zephir_read_property(&_0, this_ptr, ZEND_STRL("flags"), PH_NOISY_CC | PH_READONLY); zephir_read_property(&_1, this_ptr, ZEND_STRL("encoding"), PH_NOISY_CC | PH_READONLY); zephir_read_property(&_2, this_ptr, ZEND_STRL("doubleEncode"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_RETURN_CALL_FUNCTION("htmlspecialchars", NULL, 343, &input, &_0, &_1, &_2); + ZEPHIR_RETURN_CALL_FUNCTION("htmlspecialchars", NULL, 344, &input, &_0, &_1, &_2); zephir_check_call_status(); RETURN_MM(); } @@ -538,9 +538,9 @@ PHP_METHOD(Phalcon_Html_Escaper, js) zephir_get_strval(&input, input_param); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "normalizeencoding", NULL, 345, &input); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "normalizeencoding", NULL, 346, &input); zephir_check_call_status(); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "doescapejs", NULL, 348, &_0); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "doescapejs", NULL, 349, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -576,11 +576,11 @@ PHP_METHOD(Phalcon_Html_Escaper, normalizeEncoding) zephir_get_strval(&input, input_param); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "detectencoding", NULL, 349, &input); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "detectencoding", NULL, 350, &input); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "UTF-32"); - ZEPHIR_RETURN_CALL_FUNCTION("mb_convert_encoding", NULL, 350, &input, &_1, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("mb_convert_encoding", NULL, 351, &input, &_1, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -756,7 +756,7 @@ PHP_METHOD(Phalcon_Html_Escaper, url) zephir_get_strval(&input, input_param); - ZEPHIR_RETURN_CALL_FUNCTION("rawurlencode", NULL, 351, &input); + ZEPHIR_RETURN_CALL_FUNCTION("rawurlencode", NULL, 352, &input); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/html/helper/input/checkbox.zep.c b/ext/phalcon/html/helper/input/checkbox.zep.c index 4aaf36260a8..e7db266991d 100644 --- a/ext/phalcon/html/helper/input/checkbox.zep.c +++ b/ext/phalcon/html/helper/input/checkbox.zep.c @@ -115,9 +115,9 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Checkbox, __toString) ZEPHIR_MM_GROW(); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "processchecked", NULL, 122); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "processchecked", NULL, 123); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&unchecked, this_ptr, "processunchecked", NULL, 123); + ZEPHIR_CALL_METHOD(&unchecked, this_ptr, "processunchecked", NULL, 124); zephir_check_call_status(); ZEPHIR_CALL_PARENT(&element, phalcon_html_helper_input_checkbox_ce, getThis(), "__tostring", &_0, 0); zephir_check_call_status(); diff --git a/ext/phalcon/html/helper/input/select.zep.c b/ext/phalcon/html/helper/input/select.zep.c index e037f3b9571..0b0a2af3bf1 100644 --- a/ext/phalcon/html/helper/input/select.zep.c +++ b/ext/phalcon/html/helper/input/select.zep.c @@ -115,7 +115,7 @@ PHP_METHOD(Phalcon_Html_Helper_Input_Select, add) } - ZEPHIR_CALL_METHOD(&_0, this_ptr, "processvalue", NULL, 352, &attributes, &value); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "processvalue", NULL, 353, &attributes, &value); zephir_check_call_status(); ZEPHIR_CPY_WRT(&attributes, &_0); ZEPHIR_INIT_VAR(&_1); diff --git a/ext/phalcon/html/helper/meta.zep.c b/ext/phalcon/html/helper/meta.zep.c index d69eb02632c..4c25eaf6b93 100644 --- a/ext/phalcon/html/helper/meta.zep.c +++ b/ext/phalcon/html/helper/meta.zep.c @@ -130,7 +130,7 @@ PHP_METHOD(Phalcon_Html_Helper_Meta, addHttp) ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "http-equiv"); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addelement", NULL, 353, &_0, &httpEquiv, &content); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addelement", NULL, 354, &_0, &httpEquiv, &content); zephir_check_call_status(); RETURN_MM(); } @@ -170,7 +170,7 @@ PHP_METHOD(Phalcon_Html_Helper_Meta, addName) ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "name"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "addelement", NULL, 353, &_0, &name, &content); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "addelement", NULL, 354, &_0, &name, &content); zephir_check_call_status(); RETURN_THIS(); } @@ -210,7 +210,7 @@ PHP_METHOD(Phalcon_Html_Helper_Meta, addProperty) ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "property"); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "addelement", NULL, 353, &_0, &name, &content); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "addelement", NULL, 354, &_0, &name, &content); zephir_check_call_status(); RETURN_THIS(); } diff --git a/ext/phalcon/html/helper/title.zep.c b/ext/phalcon/html/helper/title.zep.c index f705e768735..c62afa04769 100644 --- a/ext/phalcon/html/helper/title.zep.c +++ b/ext/phalcon/html/helper/title.zep.c @@ -153,7 +153,7 @@ PHP_METHOD(Phalcon_Html_Helper_Title, __toString) zephir_read_property(&_2, this_ptr, ZEND_STRL("title"), PH_NOISY_CC); zephir_array_fast_append(&_1, &_2); zephir_read_property(&_3, this_ptr, ZEND_STRL("append"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&items, "array_merge", NULL, 354, &_0, &_1, &_3); + ZEPHIR_CALL_FUNCTION(&items, "array_merge", NULL, 355, &_0, &_1, &_3); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_4); zephir_read_property(&_5, this_ptr, ZEND_STRL("indent"), PH_NOISY_CC | PH_READONLY); diff --git a/ext/phalcon/html/link/abstractlink.zep.c b/ext/phalcon/html/link/abstractlink.zep.c new file mode 100644 index 00000000000..71f7ab5f6d8 --- /dev/null +++ b/ext/phalcon/html/link/abstractlink.zep.c @@ -0,0 +1,479 @@ + +#ifdef HAVE_CONFIG_H +#include "../../../ext_config.h" +#endif + +#include +#include "../../../php_ext.h" +#include "../../../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/memory.h" +#include "kernel/fcall.h" +#include "kernel/object.h" +#include "kernel/operators.h" + + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ +/** + * @property array $attributes + * @property string $href + * @property array $rels + * @property bool $templated + */ +ZEPHIR_INIT_CLASS(Phalcon_Html_Link_AbstractLink) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\Html\\Link, AbstractLink, phalcon, html_link_abstractlink, phalcon_html_link_abstractlink_method_entry, ZEND_ACC_EXPLICIT_ABSTRACT_CLASS); + + /** + * @var Collection + */ + zend_declare_property_null(phalcon_html_link_abstractlink_ce, SL("attributes"), ZEND_ACC_PROTECTED); + /** + * @var string + */ + zend_declare_property_string(phalcon_html_link_abstractlink_ce, SL("href"), "", ZEND_ACC_PROTECTED); + /** + * @var Collection + */ + zend_declare_property_null(phalcon_html_link_abstractlink_ce, SL("rels"), ZEND_ACC_PROTECTED); + /** + * @var bool + */ + zend_declare_property_bool(phalcon_html_link_abstractlink_ce, SL("templated"), 0, ZEND_ACC_PROTECTED); + return SUCCESS; +} + +/** + * Link constructor. + * + * @param string $rel + * @param string $href + * @param array $attributes + */ +PHP_METHOD(Phalcon_Html_Link_AbstractLink, __construct) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval attributes; + zval *rel_param = NULL, *href_param = NULL, *attributes_param = NULL, _0, _1, _2, _3$$3, _4$$3; + zval rel, href; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&rel); + ZVAL_UNDEF(&href); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); + ZVAL_UNDEF(&_3$$3); + ZVAL_UNDEF(&_4$$3); + ZVAL_UNDEF(&attributes); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 3) + Z_PARAM_OPTIONAL + Z_PARAM_STR(rel) + Z_PARAM_STR(href) + Z_PARAM_ARRAY(attributes) + ZEND_PARSE_PARAMETERS_END(); +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 0, 3, &rel_param, &href_param, &attributes_param); + if (!rel_param) { + ZEPHIR_INIT_VAR(&rel); + ZVAL_STRING(&rel, ""); + } else { + zephir_get_strval(&rel, rel_param); + } + if (!href_param) { + ZEPHIR_INIT_VAR(&href); + ZVAL_STRING(&href, ""); + } else { + zephir_get_strval(&href, href_param); + } + if (!attributes_param) { + ZEPHIR_INIT_VAR(&attributes); + array_init(&attributes); + } else { + zephir_get_arrval(&attributes, attributes_param); + } + + + ZEPHIR_INIT_VAR(&_0); + object_init_ex(&_0, phalcon_support_collection_ce); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 24, &attributes); + zephir_check_call_status(); + zephir_update_property_zval(this_ptr, ZEND_STRL("attributes"), &_0); + ZEPHIR_INIT_VAR(&_1); + object_init_ex(&_1, phalcon_support_collection_ce); + ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 24); + zephir_check_call_status(); + zephir_update_property_zval(this_ptr, ZEND_STRL("rels"), &_1); + zephir_update_property_zval(this_ptr, ZEND_STRL("href"), &href); + ZEPHIR_CALL_METHOD(&_2, this_ptr, "hrefistemplated", NULL, 0, &href); + zephir_check_call_status(); + zephir_update_property_zval(this_ptr, ZEND_STRL("templated"), &_2); + if (1 != ZEPHIR_IS_EMPTY(&rel)) { + zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("rels"), PH_NOISY_CC | PH_READONLY); + ZVAL_BOOL(&_4$$3, 1); + ZEPHIR_CALL_METHOD(NULL, &_3$$3, "set", NULL, 0, &rel, &_4$$3); + zephir_check_call_status(); + } + ZEPHIR_MM_RESTORE(); +} + +/** + * Returns a list of attributes that describe the target URI. + * + * @return array + * A key-value list of attributes, where the key is a string and the value + * is either a PHP primitive or an array of PHP strings. If no values are + * found an empty array MUST be returned. + */ +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doGetAttributes) +{ + zval _0; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&_0); + + + ZEPHIR_MM_GROW(); + + zephir_read_property(&_0, this_ptr, ZEND_STRL("attributes"), PH_NOISY_CC | PH_READONLY); + ZEPHIR_RETURN_CALL_METHOD(&_0, "toarray", NULL, 0); + zephir_check_call_status(); + RETURN_MM(); +} + +/** + * Returns the target of the link. + * + * The target link must be one of: + * - An absolute URI, as defined by RFC 5988. + * - A relative URI, as defined by RFC 5988. The base of the relative link + * is assumed to be known based on context by the client. + * - A URI template as defined by RFC 6570. + * + * If a URI template is returned, isTemplated() MUST return True. + * + * @return string + */ +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doGetHref) +{ + zval *this_ptr = getThis(); + + + + RETURN_MEMBER(getThis(), "href"); +} + +/** + * Returns the relationship type(s) of the link. + * + * This method returns 0 or more relationship types for a link, expressed + * as an array of strings. + * + * @return string[] + */ +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doGetRels) +{ + zval _0, _1; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + + + ZEPHIR_MM_GROW(); + + zephir_read_property(&_0, this_ptr, ZEND_STRL("rels"), PH_NOISY_CC | PH_READONLY); + ZVAL_BOOL(&_1, 0); + ZEPHIR_RETURN_CALL_METHOD(&_0, "getkeys", NULL, 0, &_1); + zephir_check_call_status(); + RETURN_MM(); +} + +/** + * Returns whether this is a templated link. + * + * @return bool + * True if this link object is templated, False otherwise. + */ +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doIsTemplated) +{ + zval *this_ptr = getThis(); + + + + RETURN_MEMBER(getThis(), "templated"); +} + +/** + * Determines if a href is a templated link or not. + * + * @see https://tools.ietf.org/html/rfc6570 + * + * @param string $href + * + * @return bool + */ +PHP_METHOD(Phalcon_Html_Link_AbstractLink, hrefIsTemplated) +{ + zend_bool _2; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *href_param = NULL, _0, _1, _3; + zval href; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&href); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(href) + ZEND_PARSE_PARAMETERS_END(); +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &href_param); + zephir_get_strval(&href, href_param); + + + ZEPHIR_INIT_VAR(&_0); + ZVAL_STRING(&_0, "{"); + ZEPHIR_CALL_FUNCTION(&_1, "mb_strpos", NULL, 113, &href, &_0); + zephir_check_call_status(); + _2 = !ZEPHIR_IS_FALSE_IDENTICAL(&_1); + if (_2) { + ZEPHIR_INIT_NVAR(&_0); + ZVAL_STRING(&_0, "}"); + ZEPHIR_CALL_FUNCTION(&_3, "mb_strpos", NULL, 113, &href, &_0); + zephir_check_call_status(); + _2 = !ZEPHIR_IS_FALSE_IDENTICAL(&_3); + } + RETURN_MM_BOOL(_2); +} + +/** + * @param string $key + * @param mixed $value + * + * @return mixed + */ +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doWithAttribute) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *key_param = NULL, *value, value_sub, newInstance, _0; + zval key; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&key); + ZVAL_UNDEF(&value_sub); + ZVAL_UNDEF(&newInstance); + ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(key) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 2, 0, &key_param, &value); + zephir_get_strval(&key, key_param); + + + ZEPHIR_INIT_VAR(&newInstance); + if (zephir_clone(&newInstance, this_ptr) == FAILURE) { + RETURN_MM(); + } + zephir_read_property(&_0, &newInstance, ZEND_STRL("attributes"), PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &key, value); + zephir_check_call_status(); + RETURN_CCTOR(&newInstance); +} + +/** + * @param string $href + * + * @return mixed + */ +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doWithHref) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *href_param = NULL, newInstance, _0; + zval href; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&href); + ZVAL_UNDEF(&newInstance); + ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(href) + ZEND_PARSE_PARAMETERS_END(); +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &href_param); + zephir_get_strval(&href, href_param); + + + ZEPHIR_INIT_VAR(&newInstance); + if (zephir_clone(&newInstance, this_ptr) == FAILURE) { + RETURN_MM(); + } + zephir_update_property_zval(&newInstance, ZEND_STRL("href"), &href); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "hrefistemplated", NULL, 0, &href); + zephir_check_call_status(); + zephir_update_property_zval(&newInstance, ZEND_STRL("templated"), &_0); + RETURN_CCTOR(&newInstance); +} + +/** + * @param string $key + * + * @return mixed + */ +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doWithRel) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *key_param = NULL, newInstance, _0, _1; + zval key; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&key); + ZVAL_UNDEF(&newInstance); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(key) + ZEND_PARSE_PARAMETERS_END(); +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &key_param); + zephir_get_strval(&key, key_param); + + + ZEPHIR_INIT_VAR(&newInstance); + if (zephir_clone(&newInstance, this_ptr) == FAILURE) { + RETURN_MM(); + } + zephir_read_property(&_0, &newInstance, ZEND_STRL("rels"), PH_NOISY_CC | PH_READONLY); + ZVAL_BOOL(&_1, 1); + ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, &key, &_1); + zephir_check_call_status(); + RETURN_CCTOR(&newInstance); +} + +/** + * @param string $key + * + * @return mixed + */ +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doWithoutAttribute) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *key_param = NULL, newInstance, _0; + zval key; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&key); + ZVAL_UNDEF(&newInstance); + ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(key) + ZEND_PARSE_PARAMETERS_END(); +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &key_param); + zephir_get_strval(&key, key_param); + + + ZEPHIR_INIT_VAR(&newInstance); + if (zephir_clone(&newInstance, this_ptr) == FAILURE) { + RETURN_MM(); + } + zephir_read_property(&_0, &newInstance, ZEND_STRL("attributes"), PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(NULL, &_0, "remove", NULL, 0, &key); + zephir_check_call_status(); + RETURN_CCTOR(&newInstance); +} + +/** + * @param string $key + * + * @return mixed + */ +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doWithoutRel) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *key_param = NULL, newInstance, _0; + zval key; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&key); + ZVAL_UNDEF(&newInstance); + ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(key) + ZEND_PARSE_PARAMETERS_END(); +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &key_param); + zephir_get_strval(&key, key_param); + + + ZEPHIR_INIT_VAR(&newInstance); + if (zephir_clone(&newInstance, this_ptr) == FAILURE) { + RETURN_MM(); + } + zephir_read_property(&_0, &newInstance, ZEND_STRL("rels"), PH_NOISY_CC | PH_READONLY); + ZEPHIR_CALL_METHOD(NULL, &_0, "remove", NULL, 0, &key); + zephir_check_call_status(); + RETURN_CCTOR(&newInstance); +} + diff --git a/ext/phalcon/html/link/abstractlink.zep.h b/ext/phalcon/html/link/abstractlink.zep.h new file mode 100644 index 00000000000..9a2094a9098 --- /dev/null +++ b/ext/phalcon/html/link/abstractlink.zep.h @@ -0,0 +1,78 @@ + +extern zend_class_entry *phalcon_html_link_abstractlink_ce; + +ZEPHIR_INIT_CLASS(Phalcon_Html_Link_AbstractLink); + +PHP_METHOD(Phalcon_Html_Link_AbstractLink, __construct); +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doGetAttributes); +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doGetHref); +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doGetRels); +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doIsTemplated); +PHP_METHOD(Phalcon_Html_Link_AbstractLink, hrefIsTemplated); +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doWithAttribute); +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doWithHref); +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doWithRel); +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doWithoutAttribute); +PHP_METHOD(Phalcon_Html_Link_AbstractLink, doWithoutRel); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_abstractlink___construct, 0, 0, 0) + ZEND_ARG_TYPE_INFO(0, rel, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, href, IS_STRING, 0) +#if PHP_VERSION_ID >= 80000 + ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, attributes, IS_ARRAY, 0, "[]") +#else + ZEND_ARG_ARRAY_INFO(0, attributes, 0) +#endif +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_abstractlink_dogetattributes, 0, 0, IS_ARRAY, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_abstractlink_dogethref, 0, 0, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_abstractlink_dogetrels, 0, 0, IS_ARRAY, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_abstractlink_doistemplated, 0, 0, _IS_BOOL, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_abstractlink_hrefistemplated, 0, 1, _IS_BOOL, 0) + ZEND_ARG_TYPE_INFO(0, href, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_abstractlink_dowithattribute, 0, 0, 2) + ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0) + ZEND_ARG_INFO(0, value) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_abstractlink_dowithhref, 0, 0, 1) + ZEND_ARG_TYPE_INFO(0, href, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_abstractlink_dowithrel, 0, 0, 1) + ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_abstractlink_dowithoutattribute, 0, 0, 1) + ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_abstractlink_dowithoutrel, 0, 0, 1) + ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_html_link_abstractlink_method_entry) { + PHP_ME(Phalcon_Html_Link_AbstractLink, __construct, arginfo_phalcon_html_link_abstractlink___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) + PHP_ME(Phalcon_Html_Link_AbstractLink, doGetAttributes, arginfo_phalcon_html_link_abstractlink_dogetattributes, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_Html_Link_AbstractLink, doGetHref, arginfo_phalcon_html_link_abstractlink_dogethref, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_Html_Link_AbstractLink, doGetRels, arginfo_phalcon_html_link_abstractlink_dogetrels, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_Html_Link_AbstractLink, doIsTemplated, arginfo_phalcon_html_link_abstractlink_doistemplated, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_Html_Link_AbstractLink, hrefIsTemplated, arginfo_phalcon_html_link_abstractlink_hrefistemplated, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_Html_Link_AbstractLink, doWithAttribute, arginfo_phalcon_html_link_abstractlink_dowithattribute, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_Html_Link_AbstractLink, doWithHref, arginfo_phalcon_html_link_abstractlink_dowithhref, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_Html_Link_AbstractLink, doWithRel, arginfo_phalcon_html_link_abstractlink_dowithrel, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_Html_Link_AbstractLink, doWithoutAttribute, arginfo_phalcon_html_link_abstractlink_dowithoutattribute, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_Html_Link_AbstractLink, doWithoutRel, arginfo_phalcon_html_link_abstractlink_dowithoutrel, ZEND_ACC_PROTECTED) + PHP_FE_END +}; diff --git a/ext/phalcon/html/link/abstractlinkprovider.zep.c b/ext/phalcon/html/link/abstractlinkprovider.zep.c new file mode 100644 index 00000000000..43a80e73511 --- /dev/null +++ b/ext/phalcon/html/link/abstractlinkprovider.zep.c @@ -0,0 +1,390 @@ + +#ifdef HAVE_CONFIG_H +#include "../../../ext_config.h" +#endif + +#include +#include "../../../php_ext.h" +#include "../../../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/fcall.h" +#include "kernel/memory.h" +#include "kernel/operators.h" +#include "kernel/object.h" +#include "kernel/array.h" + + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ +/** + * @property array $links + */ +ZEPHIR_INIT_CLASS(Phalcon_Html_Link_AbstractLinkProvider) +{ + ZEPHIR_REGISTER_CLASS(Phalcon\\Html\\Link, AbstractLinkProvider, phalcon, html_link_abstractlinkprovider, phalcon_html_link_abstractlinkprovider_method_entry, ZEND_ACC_EXPLICIT_ABSTRACT_CLASS); + + /** + * @var array + */ + zend_declare_property_null(phalcon_html_link_abstractlinkprovider_ce, SL("links"), ZEND_ACC_PROTECTED); + phalcon_html_link_abstractlinkprovider_ce->create_object = zephir_init_properties_Phalcon_Html_Link_AbstractLinkProvider; + + return SUCCESS; +} + +/** + * LinkProvider constructor. + * + * @param array $links + */ +PHP_METHOD(Phalcon_Html_Link_AbstractLinkProvider, __construct) +{ + zend_bool _5$$3, _11$$5; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zephir_fcall_cache_entry *_4 = NULL, *_8 = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *links_param = NULL, link, *_0, _1, _2$$3, _3$$3, _6$$3, _7$$4, _9$$5, _10$$5, _12$$5, _13$$6; + zval links; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&links); + ZVAL_UNDEF(&link); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2$$3); + ZVAL_UNDEF(&_3$$3); + ZVAL_UNDEF(&_6$$3); + ZVAL_UNDEF(&_7$$4); + ZVAL_UNDEF(&_9$$5); + ZVAL_UNDEF(&_10$$5); + ZVAL_UNDEF(&_12$$5); + ZVAL_UNDEF(&_13$$6); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_ARRAY(links) + ZEND_PARSE_PARAMETERS_END(); +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 0, 1, &links_param); + if (!links_param) { + ZEPHIR_INIT_VAR(&links); + array_init(&links); + } else { + zephir_get_arrval(&links, links_param); + } + + + zephir_is_iterable(&links, 0, "phalcon/Html/Link/AbstractLinkProvider.zep", 42); + if (Z_TYPE_P(&links) == IS_ARRAY) { + ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&links), _0) + { + ZEPHIR_INIT_NVAR(&link); + ZVAL_COPY(&link, _0); + ZEPHIR_INIT_NVAR(&_2$$3); + ZVAL_STRING(&_2$$3, "Phalcon\\Html\\Link\\Interfaces\\LinkInterface"); + ZEPHIR_CALL_FUNCTION(&_3$$3, "is_a", &_4, 114, &link, &_2$$3); + zephir_check_call_status(); + _5$$3 = ZEPHIR_IS_TRUE_IDENTICAL(&_3$$3); + if (!(_5$$3)) { + ZEPHIR_INIT_NVAR(&_2$$3); + ZVAL_STRING(&_2$$3, "Psr\\Link\\LinkInterface"); + ZEPHIR_CALL_FUNCTION(&_6$$3, "is_a", &_4, 114, &link, &_2$$3); + zephir_check_call_status(); + _5$$3 = ZEPHIR_IS_TRUE_IDENTICAL(&_6$$3); + } + if (_5$$3) { + ZEPHIR_CALL_METHOD(&_7$$4, this_ptr, "getkey", &_8, 0, &link); + zephir_check_call_status(); + zephir_update_property_array(this_ptr, SL("links"), &_7$$4, &link); + } + } ZEND_HASH_FOREACH_END(); + } else { + ZEPHIR_CALL_METHOD(NULL, &links, "rewind", NULL, 0); + zephir_check_call_status(); + while (1) { + ZEPHIR_CALL_METHOD(&_1, &links, "valid", NULL, 0); + zephir_check_call_status(); + if (!zend_is_true(&_1)) { + break; + } + ZEPHIR_CALL_METHOD(&link, &links, "current", NULL, 0); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_9$$5); + ZVAL_STRING(&_9$$5, "Phalcon\\Html\\Link\\Interfaces\\LinkInterface"); + ZEPHIR_CALL_FUNCTION(&_10$$5, "is_a", &_4, 114, &link, &_9$$5); + zephir_check_call_status(); + _11$$5 = ZEPHIR_IS_TRUE_IDENTICAL(&_10$$5); + if (!(_11$$5)) { + ZEPHIR_INIT_NVAR(&_9$$5); + ZVAL_STRING(&_9$$5, "Psr\\Link\\LinkInterface"); + ZEPHIR_CALL_FUNCTION(&_12$$5, "is_a", &_4, 114, &link, &_9$$5); + zephir_check_call_status(); + _11$$5 = ZEPHIR_IS_TRUE_IDENTICAL(&_12$$5); + } + if (_11$$5) { + ZEPHIR_CALL_METHOD(&_13$$6, this_ptr, "getkey", &_8, 0, &link); + zephir_check_call_status(); + zephir_update_property_array(this_ptr, SL("links"), &_13$$6, &link); + } + ZEPHIR_CALL_METHOD(NULL, &links, "next", NULL, 0); + zephir_check_call_status(); + } + } + ZEPHIR_INIT_NVAR(&link); + ZEPHIR_MM_RESTORE(); +} + +/** + * Returns an iterable of LinkInterface objects. + * + * The iterable may be an array or any PHP \Traversable object. If no links + * are available, an empty array or \Traversable MUST be returned. + * + * @return array + */ +PHP_METHOD(Phalcon_Html_Link_AbstractLinkProvider, doGetLinks) +{ + zval *this_ptr = getThis(); + + + + RETURN_MEMBER(getThis(), "links"); +} + +/** + * Returns an iterable of LinkInterface objects that have a specific + * relationship. + * + * The iterable may be an array or any PHP \Traversable object. If no links + * with that relationship are available, an empty array or \Traversable + * MUST be returned. + * + * @return array + */ +PHP_METHOD(Phalcon_Html_Link_AbstractLinkProvider, doGetLinksByRel) +{ + zval filtered; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *rel_param = NULL, link, rels, _0, *_1, _2; + zval rel; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&rel); + ZVAL_UNDEF(&link); + ZVAL_UNDEF(&rels); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_2); + ZVAL_UNDEF(&filtered); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(rel) + ZEND_PARSE_PARAMETERS_END(); +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &rel_param); + zephir_get_strval(&rel, rel_param); + + + ZEPHIR_INIT_VAR(&filtered); + array_init(&filtered); + zephir_read_property(&_0, this_ptr, ZEND_STRL("links"), PH_NOISY_CC | PH_READONLY); + zephir_is_iterable(&_0, 0, "phalcon/Html/Link/AbstractLinkProvider.zep", 80); + if (Z_TYPE_P(&_0) == IS_ARRAY) { + ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1) + { + ZEPHIR_INIT_NVAR(&link); + ZVAL_COPY(&link, _1); + ZEPHIR_CALL_METHOD(&rels, &link, "getrels", NULL, 0); + zephir_check_call_status(); + if (1 == zephir_fast_in_array(&rel, &rels)) { + zephir_array_append(&filtered, &link, PH_SEPARATE, "phalcon/Html/Link/AbstractLinkProvider.zep", 76); + } + } ZEND_HASH_FOREACH_END(); + } else { + ZEPHIR_CALL_METHOD(NULL, &_0, "rewind", NULL, 0); + zephir_check_call_status(); + while (1) { + ZEPHIR_CALL_METHOD(&_2, &_0, "valid", NULL, 0); + zephir_check_call_status(); + if (!zend_is_true(&_2)) { + break; + } + ZEPHIR_CALL_METHOD(&link, &_0, "current", NULL, 0); + zephir_check_call_status(); + ZEPHIR_CALL_METHOD(&rels, &link, "getrels", NULL, 0); + zephir_check_call_status(); + if (1 == zephir_fast_in_array(&rel, &rels)) { + zephir_array_append(&filtered, &link, PH_SEPARATE, "phalcon/Html/Link/AbstractLinkProvider.zep", 76); + } + ZEPHIR_CALL_METHOD(NULL, &_0, "next", NULL, 0); + zephir_check_call_status(); + } + } + ZEPHIR_INIT_NVAR(&link); + RETURN_CTOR(&filtered); +} + +/** + * Returns an instance with the specified link included. + * + * If the specified link is already present, this method MUST return + * normally without errors. The link is present if $link is === identical + * to a link object already in the collection. + * + * @param mixed $link A link object that should be included in this + * collection. + * + * @return $this + */ +PHP_METHOD(Phalcon_Html_Link_AbstractLinkProvider, doWithLink) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *link, link_sub, key, newInstance; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&link_sub); + ZVAL_UNDEF(&key); + ZVAL_UNDEF(&newInstance); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(link) + ZEND_PARSE_PARAMETERS_END(); +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &link); + + + ZEPHIR_CALL_METHOD(&key, this_ptr, "getkey", NULL, 0, link); + zephir_check_call_status(); + ZEPHIR_INIT_VAR(&newInstance); + if (zephir_clone(&newInstance, this_ptr) == FAILURE) { + RETURN_MM(); + } + zephir_update_property_array(&newInstance, SL("links"), &key, link); + RETURN_CCTOR(&newInstance); +} + +/** + * Returns an instance with the specified link removed. + * + * If the specified link is not present, this method MUST return normally + * without errors. The link is present if $link is === identical to a link + * object already in the collection. + * + * @param mixed $link The link to remove. + * + * @return $this + */ +PHP_METHOD(Phalcon_Html_Link_AbstractLinkProvider, doWithoutLink) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *link, link_sub, key, newInstance, _0; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&link_sub); + ZVAL_UNDEF(&key); + ZVAL_UNDEF(&newInstance); + ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(link) + ZEND_PARSE_PARAMETERS_END(); +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &link); + + + ZEPHIR_CALL_METHOD(&key, this_ptr, "getkey", NULL, 0, link); + zephir_check_call_status(); + ZEPHIR_INIT_VAR(&newInstance); + if (zephir_clone(&newInstance, this_ptr) == FAILURE) { + RETURN_MM(); + } + zephir_unset_property_array(&newInstance, ZEND_STRL("links"), &key); + zephir_read_property(&_0, &newInstance, ZEND_STRL("links"), PH_NOISY_CC | PH_READONLY); + zephir_array_unset(&_0, &key, PH_SEPARATE); + RETURN_CCTOR(&newInstance); +} + +/** + * Returns the object hash key + * + * @param mixed link + * + * @return string + */ +PHP_METHOD(Phalcon_Html_Link_AbstractLinkProvider, getKey) +{ + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *link, link_sub; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&link_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(link) + ZEND_PARSE_PARAMETERS_END(); +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &link); + + + ZEPHIR_RETURN_CALL_FUNCTION("spl_object_hash", NULL, 108, link); + zephir_check_call_status(); + RETURN_MM(); +} + +zend_object *zephir_init_properties_Phalcon_Html_Link_AbstractLinkProvider(zend_class_entry *class_type) +{ + zval _0, _1$$3; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1$$3); + + + ZEPHIR_MM_GROW(); + + { + zval local_this_ptr, *this_ptr = &local_this_ptr; + ZEPHIR_CREATE_OBJECT(this_ptr, class_type); + zephir_read_property_ex(&_0, this_ptr, ZEND_STRL("links"), PH_NOISY_CC | PH_READONLY); + if (Z_TYPE_P(&_0) == IS_NULL) { + ZEPHIR_INIT_VAR(&_1$$3); + array_init(&_1$$3); + zephir_update_property_zval_ex(this_ptr, ZEND_STRL("links"), &_1$$3); + } + ZEPHIR_MM_RESTORE(); + return Z_OBJ_P(this_ptr); + } +} + diff --git a/ext/phalcon/html/link/abstractlinkprovider.zep.h b/ext/phalcon/html/link/abstractlinkprovider.zep.h new file mode 100644 index 00000000000..070c526435a --- /dev/null +++ b/ext/phalcon/html/link/abstractlinkprovider.zep.h @@ -0,0 +1,52 @@ + +extern zend_class_entry *phalcon_html_link_abstractlinkprovider_ce; + +ZEPHIR_INIT_CLASS(Phalcon_Html_Link_AbstractLinkProvider); + +PHP_METHOD(Phalcon_Html_Link_AbstractLinkProvider, __construct); +PHP_METHOD(Phalcon_Html_Link_AbstractLinkProvider, doGetLinks); +PHP_METHOD(Phalcon_Html_Link_AbstractLinkProvider, doGetLinksByRel); +PHP_METHOD(Phalcon_Html_Link_AbstractLinkProvider, doWithLink); +PHP_METHOD(Phalcon_Html_Link_AbstractLinkProvider, doWithoutLink); +PHP_METHOD(Phalcon_Html_Link_AbstractLinkProvider, getKey); +zend_object *zephir_init_properties_Phalcon_Html_Link_AbstractLinkProvider(zend_class_entry *class_type); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_abstractlinkprovider___construct, 0, 0, 0) +#if PHP_VERSION_ID >= 80000 + ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, links, IS_ARRAY, 0, "[]") +#else + ZEND_ARG_ARRAY_INFO(0, links, 0) +#endif +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_abstractlinkprovider_dogetlinks, 0, 0, IS_ARRAY, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_abstractlinkprovider_dogetlinksbyrel, 0, 1, IS_ARRAY, 0) + ZEND_ARG_TYPE_INFO(0, rel, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_abstractlinkprovider_dowithlink, 0, 0, 1) + ZEND_ARG_INFO(0, link) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_abstractlinkprovider_dowithoutlink, 0, 0, 1) + ZEND_ARG_INFO(0, link) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_abstractlinkprovider_getkey, 0, 1, IS_STRING, 0) + ZEND_ARG_INFO(0, link) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_abstractlinkprovider_zephir_init_properties_phalcon_html_link_abstractlinkprovider, 0, 0, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_html_link_abstractlinkprovider_method_entry) { + PHP_ME(Phalcon_Html_Link_AbstractLinkProvider, __construct, arginfo_phalcon_html_link_abstractlinkprovider___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) + PHP_ME(Phalcon_Html_Link_AbstractLinkProvider, doGetLinks, arginfo_phalcon_html_link_abstractlinkprovider_dogetlinks, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_Html_Link_AbstractLinkProvider, doGetLinksByRel, arginfo_phalcon_html_link_abstractlinkprovider_dogetlinksbyrel, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_Html_Link_AbstractLinkProvider, doWithLink, arginfo_phalcon_html_link_abstractlinkprovider_dowithlink, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_Html_Link_AbstractLinkProvider, doWithoutLink, arginfo_phalcon_html_link_abstractlinkprovider_dowithoutlink, ZEND_ACC_PROTECTED) + PHP_ME(Phalcon_Html_Link_AbstractLinkProvider, getKey, arginfo_phalcon_html_link_abstractlinkprovider_getkey, ZEND_ACC_PROTECTED) + PHP_FE_END +}; diff --git a/ext/phalcon/html/link/evolvablelink.zep.c b/ext/phalcon/html/link/evolvablelink.zep.c index 5575cb70d90..178a16812f1 100644 --- a/ext/phalcon/html/link/evolvablelink.zep.c +++ b/ext/phalcon/html/link/evolvablelink.zep.c @@ -12,9 +12,10 @@ #include #include "kernel/main.h" -#include "kernel/object.h" -#include "kernel/memory.h" #include "kernel/fcall.h" +#include "kernel/memory.h" +#include "kernel/object.h" +#include "kernel/operators.h" /** @@ -37,7 +38,7 @@ ZEPHIR_INIT_CLASS(Phalcon_Html_Link_EvolvableLink) { ZEPHIR_REGISTER_CLASS_EX(Phalcon\\Html\\Link, EvolvableLink, phalcon, html_link_evolvablelink, phalcon_html_link_link_ce, phalcon_html_link_evolvablelink_method_entry, 0); - zend_class_implements(phalcon_html_link_evolvablelink_ce, 1, zephir_get_internal_ce(SL("psr\\link\\evolvablelinkinterface"))); + zend_class_implements(phalcon_html_link_evolvablelink_ce, 1, phalcon_html_link_interfaces_evolvablelinkinterface_ce); return SUCCESS; } @@ -47,22 +48,18 @@ ZEPHIR_INIT_CLASS(Phalcon_Html_Link_EvolvableLink) * If the specified attribute is already present, it will be overwritten * with the new value. * - * @param string attribute The attribute to include. - * @param string value The value of the attribute to set. - * - * @return static + * @param string $attribute The attribute to include. + * @param string $value The value of the attribute to set. */ PHP_METHOD(Phalcon_Html_Link_EvolvableLink, withAttribute) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *attribute, attribute_sub, *value, value_sub, newInstance, _0; + zval *attribute, attribute_sub, *value, value_sub; zval *this_ptr = getThis(); ZVAL_UNDEF(&attribute_sub); ZVAL_UNDEF(&value_sub); - ZVAL_UNDEF(&newInstance); - ZVAL_UNDEF(&_0); #if PHP_VERSION_ID >= 80000 bool is_null_true = 1; ZEND_PARSE_PARAMETERS_START(2, 2) @@ -76,14 +73,9 @@ PHP_METHOD(Phalcon_Html_Link_EvolvableLink, withAttribute) zephir_fetch_params(1, 2, 0, &attribute, &value); - ZEPHIR_INIT_VAR(&newInstance); - if (zephir_clone(&newInstance, this_ptr) == FAILURE) { - RETURN_MM(); - } - zephir_read_property(&_0, &newInstance, ZEND_STRL("attributes"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, attribute, value); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dowithattribute", NULL, 0, attribute, value); zephir_check_call_status(); - RETURN_CCTOR(&newInstance); + RETURN_MM(); } /** @@ -101,39 +93,33 @@ PHP_METHOD(Phalcon_Html_Link_EvolvableLink, withAttribute) * An implementing library SHOULD evaluate a passed object to a string * immediately rather than waiting for it to be returned later. * - * @return static + * @param string $rel The relationship value to add. */ PHP_METHOD(Phalcon_Html_Link_EvolvableLink, withHref) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *href, href_sub, newInstance, _0; + zval *href_param = NULL; + zval href; zval *this_ptr = getThis(); - ZVAL_UNDEF(&href_sub); - ZVAL_UNDEF(&newInstance); - ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&href); #if PHP_VERSION_ID >= 80000 bool is_null_true = 1; ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_ZVAL(href) + Z_PARAM_STR(href) ZEND_PARSE_PARAMETERS_END(); #endif ZEPHIR_MM_GROW(); - zephir_fetch_params(1, 1, 0, &href); + zephir_fetch_params(1, 1, 0, &href_param); + zephir_get_strval(&href, href_param); - ZEPHIR_INIT_VAR(&newInstance); - if (zephir_clone(&newInstance, this_ptr) == FAILURE) { - RETURN_MM(); - } - zephir_update_property_zval(&newInstance, ZEND_STRL("href"), href); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "hrefistemplated", NULL, 0, href); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dowithhref", NULL, 0, &href); zephir_check_call_status(); - zephir_update_property_zval(&newInstance, ZEND_STRL("templated"), &_0); - RETURN_CCTOR(&newInstance); + RETURN_MM(); } /** @@ -142,43 +128,33 @@ PHP_METHOD(Phalcon_Html_Link_EvolvableLink, withHref) * If the specified rel is already present, this method MUST return * normally without errors, but without adding the rel a second time. * - * @param string rel - * The relationship value to add. - * - * @return static + * @param string $rel The relationship value to add. */ PHP_METHOD(Phalcon_Html_Link_EvolvableLink, withRel) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *rel, rel_sub, newInstance, _0, _1; + zval *rel_param = NULL; + zval rel; zval *this_ptr = getThis(); - ZVAL_UNDEF(&rel_sub); - ZVAL_UNDEF(&newInstance); - ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&rel); #if PHP_VERSION_ID >= 80000 bool is_null_true = 1; ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_ZVAL(rel) + Z_PARAM_STR(rel) ZEND_PARSE_PARAMETERS_END(); #endif ZEPHIR_MM_GROW(); - zephir_fetch_params(1, 1, 0, &rel); + zephir_fetch_params(1, 1, 0, &rel_param); + zephir_get_strval(&rel, rel_param); - ZEPHIR_INIT_VAR(&newInstance); - if (zephir_clone(&newInstance, this_ptr) == FAILURE) { - RETURN_MM(); - } - zephir_read_property(&_0, &newInstance, ZEND_STRL("rels"), PH_NOISY_CC | PH_READONLY); - ZVAL_BOOL(&_1, 1); - ZEPHIR_CALL_METHOD(NULL, &_0, "set", NULL, 0, rel, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dowithrel", NULL, 0, &rel); zephir_check_call_status(); - RETURN_CCTOR(&newInstance); + RETURN_MM(); } /** @@ -187,41 +163,33 @@ PHP_METHOD(Phalcon_Html_Link_EvolvableLink, withRel) * If the specified attribute is not present, this method MUST return * normally without errors. * - * @param string attribute - * The attribute to remove. - * - * @return static + * @param string $attribute The attribute to remove. */ PHP_METHOD(Phalcon_Html_Link_EvolvableLink, withoutAttribute) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *attribute, attribute_sub, newInstance, _0; + zval *attribute_param = NULL; + zval attribute; zval *this_ptr = getThis(); - ZVAL_UNDEF(&attribute_sub); - ZVAL_UNDEF(&newInstance); - ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&attribute); #if PHP_VERSION_ID >= 80000 bool is_null_true = 1; ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_ZVAL(attribute) + Z_PARAM_STR(attribute) ZEND_PARSE_PARAMETERS_END(); #endif ZEPHIR_MM_GROW(); - zephir_fetch_params(1, 1, 0, &attribute); + zephir_fetch_params(1, 1, 0, &attribute_param); + zephir_get_strval(&attribute, attribute_param); - ZEPHIR_INIT_VAR(&newInstance); - if (zephir_clone(&newInstance, this_ptr) == FAILURE) { - RETURN_MM(); - } - zephir_read_property(&_0, &newInstance, ZEND_STRL("attributes"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(NULL, &_0, "remove", NULL, 0, attribute); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dowithoutattribute", NULL, 0, &attribute); zephir_check_call_status(); - RETURN_CCTOR(&newInstance); + RETURN_MM(); } /** @@ -230,40 +198,32 @@ PHP_METHOD(Phalcon_Html_Link_EvolvableLink, withoutAttribute) * If the specified rel is not present, this method MUST return * normally without errors. * - * @param string rel - * The relationship value to exclude. - * - * @return static + * @param string $rel The relationship value to exclude. */ PHP_METHOD(Phalcon_Html_Link_EvolvableLink, withoutRel) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *rel, rel_sub, newInstance, _0; + zval *rel_param = NULL; + zval rel; zval *this_ptr = getThis(); - ZVAL_UNDEF(&rel_sub); - ZVAL_UNDEF(&newInstance); - ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&rel); #if PHP_VERSION_ID >= 80000 bool is_null_true = 1; ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_ZVAL(rel) + Z_PARAM_STR(rel) ZEND_PARSE_PARAMETERS_END(); #endif ZEPHIR_MM_GROW(); - zephir_fetch_params(1, 1, 0, &rel); + zephir_fetch_params(1, 1, 0, &rel_param); + zephir_get_strval(&rel, rel_param); - ZEPHIR_INIT_VAR(&newInstance); - if (zephir_clone(&newInstance, this_ptr) == FAILURE) { - RETURN_MM(); - } - zephir_read_property(&_0, &newInstance, ZEND_STRL("rels"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(NULL, &_0, "remove", NULL, 0, rel); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dowithoutrel", NULL, 0, &rel); zephir_check_call_status(); - RETURN_CCTOR(&newInstance); + RETURN_MM(); } diff --git a/ext/phalcon/html/link/evolvablelink.zep.h b/ext/phalcon/html/link/evolvablelink.zep.h index e1170bcffac..988cb13dd60 100644 --- a/ext/phalcon/html/link/evolvablelink.zep.h +++ b/ext/phalcon/html/link/evolvablelink.zep.h @@ -9,25 +9,25 @@ PHP_METHOD(Phalcon_Html_Link_EvolvableLink, withRel); PHP_METHOD(Phalcon_Html_Link_EvolvableLink, withoutAttribute); PHP_METHOD(Phalcon_Html_Link_EvolvableLink, withoutRel); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_evolvablelink_withattribute, 0, 0, 2) +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_html_link_evolvablelink_withattribute, 0, 2, Phalcon\\Html\\Link\\Interfaces\\EvolvableLinkInterface, 0) ZEND_ARG_INFO(0, attribute) ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_evolvablelink_withhref, 0, 0, 1) - ZEND_ARG_INFO(0, href) +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_html_link_evolvablelink_withhref, 0, 1, Phalcon\\Html\\Link\\Interfaces\\EvolvableLinkInterface, 0) + ZEND_ARG_TYPE_INFO(0, href, IS_STRING, 0) ZEND_END_ARG_INFO() -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_evolvablelink_withrel, 0, 0, 1) - ZEND_ARG_INFO(0, rel) +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_html_link_evolvablelink_withrel, 0, 1, Phalcon\\Html\\Link\\Interfaces\\EvolvableLinkInterface, 0) + ZEND_ARG_TYPE_INFO(0, rel, IS_STRING, 0) ZEND_END_ARG_INFO() -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_evolvablelink_withoutattribute, 0, 0, 1) - ZEND_ARG_INFO(0, attribute) +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_html_link_evolvablelink_withoutattribute, 0, 1, Phalcon\\Html\\Link\\Interfaces\\EvolvableLinkInterface, 0) + ZEND_ARG_TYPE_INFO(0, attribute, IS_STRING, 0) ZEND_END_ARG_INFO() -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_evolvablelink_withoutrel, 0, 0, 1) - ZEND_ARG_INFO(0, rel) +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_html_link_evolvablelink_withoutrel, 0, 1, Phalcon\\Html\\Link\\Interfaces\\EvolvableLinkInterface, 0) + ZEND_ARG_TYPE_INFO(0, rel, IS_STRING, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_html_link_evolvablelink_method_entry) { diff --git a/ext/phalcon/html/link/evolvablelinkprovider.zep.c b/ext/phalcon/html/link/evolvablelinkprovider.zep.c index 0ea82dcd006..50d7cedffbd 100644 --- a/ext/phalcon/html/link/evolvablelinkprovider.zep.c +++ b/ext/phalcon/html/link/evolvablelinkprovider.zep.c @@ -13,9 +13,8 @@ #include "kernel/main.h" #include "kernel/fcall.h" -#include "kernel/object.h" #include "kernel/memory.h" -#include "kernel/array.h" +#include "kernel/object.h" /** @@ -35,7 +34,7 @@ ZEPHIR_INIT_CLASS(Phalcon_Html_Link_EvolvableLinkProvider) { ZEPHIR_REGISTER_CLASS_EX(Phalcon\\Html\\Link, EvolvableLinkProvider, phalcon, html_link_evolvablelinkprovider, phalcon_html_link_linkprovider_ce, phalcon_html_link_evolvablelinkprovider_method_entry, 0); - zend_class_implements(phalcon_html_link_evolvablelinkprovider_ce, 1, zephir_get_internal_ce(SL("psr\\link\\evolvablelinkproviderinterface"))); + zend_class_implements(phalcon_html_link_evolvablelinkprovider_ce, 1, phalcon_html_link_interfaces_evolvablelinkproviderinterface_ce); return SUCCESS; } @@ -55,16 +54,14 @@ PHP_METHOD(Phalcon_Html_Link_EvolvableLinkProvider, withLink) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *link, link_sub, key, newInstance; + zval *link, link_sub; zval *this_ptr = getThis(); ZVAL_UNDEF(&link_sub); - ZVAL_UNDEF(&key); - ZVAL_UNDEF(&newInstance); #if PHP_VERSION_ID >= 80000 bool is_null_true = 1; ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_OBJECT_OF_CLASS(link, zephir_get_internal_ce(SL("psr\\link\\linkinterface"))) + Z_PARAM_OBJECT_OF_CLASS(link, phalcon_html_link_interfaces_linkinterface_ce) ZEND_PARSE_PARAMETERS_END(); #endif @@ -73,14 +70,9 @@ PHP_METHOD(Phalcon_Html_Link_EvolvableLinkProvider, withLink) zephir_fetch_params(1, 1, 0, &link); - ZEPHIR_CALL_METHOD(&key, this_ptr, "getkey", NULL, 0, link); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dowithlink", NULL, 0, link); zephir_check_call_status(); - ZEPHIR_INIT_VAR(&newInstance); - if (zephir_clone(&newInstance, this_ptr) == FAILURE) { - RETURN_MM(); - } - zephir_update_property_array(&newInstance, SL("links"), &key, link); - RETURN_CCTOR(&newInstance); + RETURN_MM(); } /** @@ -99,18 +91,14 @@ PHP_METHOD(Phalcon_Html_Link_EvolvableLinkProvider, withoutLink) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *link, link_sub, key, links, newInstance, _0; + zval *link, link_sub; zval *this_ptr = getThis(); ZVAL_UNDEF(&link_sub); - ZVAL_UNDEF(&key); - ZVAL_UNDEF(&links); - ZVAL_UNDEF(&newInstance); - ZVAL_UNDEF(&_0); #if PHP_VERSION_ID >= 80000 bool is_null_true = 1; ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_OBJECT_OF_CLASS(link, zephir_get_internal_ce(SL("psr\\link\\linkinterface"))) + Z_PARAM_OBJECT_OF_CLASS(link, phalcon_html_link_interfaces_linkinterface_ce) ZEND_PARSE_PARAMETERS_END(); #endif @@ -119,16 +107,8 @@ PHP_METHOD(Phalcon_Html_Link_EvolvableLinkProvider, withoutLink) zephir_fetch_params(1, 1, 0, &link); - ZEPHIR_CALL_METHOD(&key, this_ptr, "getkey", NULL, 0, link); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dowithoutlink", NULL, 0, link); zephir_check_call_status(); - ZEPHIR_INIT_VAR(&newInstance); - if (zephir_clone(&newInstance, this_ptr) == FAILURE) { - RETURN_MM(); - } - zephir_read_property(&_0, this_ptr, ZEND_STRL("links"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CPY_WRT(&links, &_0); - zephir_array_unset(&links, &key, PH_SEPARATE); - zephir_update_property_zval(&newInstance, ZEND_STRL("links"), &links); - RETURN_CCTOR(&newInstance); + RETURN_MM(); } diff --git a/ext/phalcon/html/link/evolvablelinkprovider.zep.h b/ext/phalcon/html/link/evolvablelinkprovider.zep.h index 89c2836fc50..873cfbf7e70 100644 --- a/ext/phalcon/html/link/evolvablelinkprovider.zep.h +++ b/ext/phalcon/html/link/evolvablelinkprovider.zep.h @@ -6,12 +6,12 @@ ZEPHIR_INIT_CLASS(Phalcon_Html_Link_EvolvableLinkProvider); PHP_METHOD(Phalcon_Html_Link_EvolvableLinkProvider, withLink); PHP_METHOD(Phalcon_Html_Link_EvolvableLinkProvider, withoutLink); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_evolvablelinkprovider_withlink, 0, 0, 1) - ZEND_ARG_OBJ_INFO(0, link, Psr\\Link\\LinkInterface, 0) +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_html_link_evolvablelinkprovider_withlink, 0, 1, Phalcon\\Html\\Link\\Interfaces\\EvolvableLinkProviderInterface, 0) + ZEND_ARG_OBJ_INFO(0, link, Phalcon\\Html\\Link\\Interfaces\\LinkInterface, 0) ZEND_END_ARG_INFO() -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_evolvablelinkprovider_withoutlink, 0, 0, 1) - ZEND_ARG_OBJ_INFO(0, link, Psr\\Link\\LinkInterface, 0) +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_html_link_evolvablelinkprovider_withoutlink, 0, 1, Phalcon\\Html\\Link\\Interfaces\\EvolvableLinkProviderInterface, 0) + ZEND_ARG_OBJ_INFO(0, link, Phalcon\\Html\\Link\\Interfaces\\LinkInterface, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_html_link_evolvablelinkprovider_method_entry) { diff --git a/ext/phalcon/html/link/interfaces/evolvablelinkinterface.zep.c b/ext/phalcon/html/link/interfaces/evolvablelinkinterface.zep.c new file mode 100644 index 00000000000..7f0bfebed1e --- /dev/null +++ b/ext/phalcon/html/link/interfaces/evolvablelinkinterface.zep.c @@ -0,0 +1,86 @@ + +#ifdef HAVE_CONFIG_H +#include "../../../../ext_config.h" +#endif + +#include +#include "../../../../php_ext.h" +#include "../../../../ext.h" + +#include + +#include "kernel/main.h" + + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ +/** + * An evolvable link value object. + */ +ZEPHIR_INIT_CLASS(Phalcon_Html_Link_Interfaces_EvolvableLinkInterface) +{ + ZEPHIR_REGISTER_INTERFACE(Phalcon\\Html\\Link\\Interfaces, EvolvableLinkInterface, phalcon, html_link_interfaces_evolvablelinkinterface, phalcon_html_link_interfaces_evolvablelinkinterface_method_entry); + + zend_class_implements(phalcon_html_link_interfaces_evolvablelinkinterface_ce, 1, phalcon_html_link_interfaces_linkinterface_ce); + return SUCCESS; +} + +/** + * Returns an instance with the specified href. + * + * @param string $href + * The href value to include. It must be one of: + * - An absolute URI, as defined by RFC 5988. + * - A relative URI, as defined by RFC 5988. The base of the relative + * link is assumed to be known based on context by the client. + * - A URI template as defined by RFC 6570. + * - An object implementing __toString() that produces one of the + * above values. + * + * An implementing library SHOULD evaluate a passed object to a string + * immediately rather than waiting for it to be returned later. + */ +ZEPHIR_DOC_METHOD(Phalcon_Html_Link_Interfaces_EvolvableLinkInterface, withHref); +/** + * Returns an instance with the specified relationship included. + * + * If the specified rel is already present, this method MUST return + * normally without errors, but without adding the rel a second time. + * + * @param string $rel The relationship value to add. + */ +ZEPHIR_DOC_METHOD(Phalcon_Html_Link_Interfaces_EvolvableLinkInterface, withRel); +/** + * Returns an instance with the specified relationship excluded. + * + * If the specified rel is already not present, this method MUST return + * normally without errors. + * + * @param string $rel The relationship value to exclude. + */ +ZEPHIR_DOC_METHOD(Phalcon_Html_Link_Interfaces_EvolvableLinkInterface, withoutRel); +/** + * Returns an instance with the specified attribute added. + * + * If the specified attribute is already present, it will be overwritten + * with the new value. + * + * @param string $attribute The attribute to include. + * @param string $value The value of the attribute to set. + */ +ZEPHIR_DOC_METHOD(Phalcon_Html_Link_Interfaces_EvolvableLinkInterface, withAttribute); +/** + * Returns an instance with the specified attribute excluded. + * + * If the specified attribute is not present, this method MUST return + * normally without errors. + * + * @param string $attribute The attribute to remove. + */ +ZEPHIR_DOC_METHOD(Phalcon_Html_Link_Interfaces_EvolvableLinkInterface, withoutAttribute); diff --git a/ext/phalcon/html/link/interfaces/evolvablelinkinterface.zep.h b/ext/phalcon/html/link/interfaces/evolvablelinkinterface.zep.h new file mode 100644 index 00000000000..1bb97542bd8 --- /dev/null +++ b/ext/phalcon/html/link/interfaces/evolvablelinkinterface.zep.h @@ -0,0 +1,34 @@ + +extern zend_class_entry *phalcon_html_link_interfaces_evolvablelinkinterface_ce; + +ZEPHIR_INIT_CLASS(Phalcon_Html_Link_Interfaces_EvolvableLinkInterface); + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_html_link_interfaces_evolvablelinkinterface_withhref, 0, 1, Phalcon\\Html\\Link\\Interfaces\\EvolvableLinkInterface, 0) + ZEND_ARG_TYPE_INFO(0, href, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_html_link_interfaces_evolvablelinkinterface_withrel, 0, 1, Phalcon\\Html\\Link\\Interfaces\\EvolvableLinkInterface, 0) + ZEND_ARG_TYPE_INFO(0, rel, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_html_link_interfaces_evolvablelinkinterface_withoutrel, 0, 1, Phalcon\\Html\\Link\\Interfaces\\EvolvableLinkInterface, 0) + ZEND_ARG_TYPE_INFO(0, rel, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_html_link_interfaces_evolvablelinkinterface_withattribute, 0, 2, Phalcon\\Html\\Link\\Interfaces\\EvolvableLinkInterface, 0) + ZEND_ARG_TYPE_INFO(0, attribute, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, value, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_html_link_interfaces_evolvablelinkinterface_withoutattribute, 0, 1, Phalcon\\Html\\Link\\Interfaces\\EvolvableLinkInterface, 0) + ZEND_ARG_TYPE_INFO(0, attribute, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_html_link_interfaces_evolvablelinkinterface_method_entry) { + PHP_ABSTRACT_ME(Phalcon_Html_Link_Interfaces_EvolvableLinkInterface, withHref, arginfo_phalcon_html_link_interfaces_evolvablelinkinterface_withhref) + PHP_ABSTRACT_ME(Phalcon_Html_Link_Interfaces_EvolvableLinkInterface, withRel, arginfo_phalcon_html_link_interfaces_evolvablelinkinterface_withrel) + PHP_ABSTRACT_ME(Phalcon_Html_Link_Interfaces_EvolvableLinkInterface, withoutRel, arginfo_phalcon_html_link_interfaces_evolvablelinkinterface_withoutrel) + PHP_ABSTRACT_ME(Phalcon_Html_Link_Interfaces_EvolvableLinkInterface, withAttribute, arginfo_phalcon_html_link_interfaces_evolvablelinkinterface_withattribute) + PHP_ABSTRACT_ME(Phalcon_Html_Link_Interfaces_EvolvableLinkInterface, withoutAttribute, arginfo_phalcon_html_link_interfaces_evolvablelinkinterface_withoutattribute) + PHP_FE_END +}; diff --git a/ext/phalcon/html/link/interfaces/evolvablelinkproviderinterface.zep.c b/ext/phalcon/html/link/interfaces/evolvablelinkproviderinterface.zep.c new file mode 100644 index 00000000000..66dae102178 --- /dev/null +++ b/ext/phalcon/html/link/interfaces/evolvablelinkproviderinterface.zep.c @@ -0,0 +1,53 @@ + +#ifdef HAVE_CONFIG_H +#include "../../../../ext_config.h" +#endif + +#include +#include "../../../../php_ext.h" +#include "../../../../ext.h" + +#include + +#include "kernel/main.h" + + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ +/** + * An evolvable link provider value object. + */ +ZEPHIR_INIT_CLASS(Phalcon_Html_Link_Interfaces_EvolvableLinkProviderInterface) +{ + ZEPHIR_REGISTER_INTERFACE(Phalcon\\Html\\Link\\Interfaces, EvolvableLinkProviderInterface, phalcon, html_link_interfaces_evolvablelinkproviderinterface, phalcon_html_link_interfaces_evolvablelinkproviderinterface_method_entry); + + zend_class_implements(phalcon_html_link_interfaces_evolvablelinkproviderinterface_ce, 1, phalcon_html_link_interfaces_linkproviderinterface_ce); + return SUCCESS; +} + +/** + * Returns an instance with the specified link included. + * + * If the specified link is already present, this method MUST return + * normally without errors. The link is present if $link is === identical + * to a link object already in the collection. + * + * @param LinkInterface $link A link object that should be included in this collection. + */ +ZEPHIR_DOC_METHOD(Phalcon_Html_Link_Interfaces_EvolvableLinkProviderInterface, withLink); +/** + * Returns an instance with the specifed link removed. + * + * If the specified link is not present, this method MUST return normally + * without errors. The link is present if $link is === identical to a link + * object already in the collection. + * + * @param LinkInterface $link The link to remove. + */ +ZEPHIR_DOC_METHOD(Phalcon_Html_Link_Interfaces_EvolvableLinkProviderInterface, withoutLink); diff --git a/ext/phalcon/html/link/interfaces/evolvablelinkproviderinterface.zep.h b/ext/phalcon/html/link/interfaces/evolvablelinkproviderinterface.zep.h new file mode 100644 index 00000000000..5c5dcee00a3 --- /dev/null +++ b/ext/phalcon/html/link/interfaces/evolvablelinkproviderinterface.zep.h @@ -0,0 +1,18 @@ + +extern zend_class_entry *phalcon_html_link_interfaces_evolvablelinkproviderinterface_ce; + +ZEPHIR_INIT_CLASS(Phalcon_Html_Link_Interfaces_EvolvableLinkProviderInterface); + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_html_link_interfaces_evolvablelinkproviderinterface_withlink, 0, 1, Phalcon\\Html\\Link\\Interfaces\\EvolvableLinkProviderInterface, 0) + ZEND_ARG_OBJ_INFO(0, link, Phalcon\\Html\\Link\\Interfaces\\LinkInterface, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_phalcon_html_link_interfaces_evolvablelinkproviderinterface_withoutlink, 0, 1, Phalcon\\Html\\Link\\Interfaces\\EvolvableLinkProviderInterface, 0) + ZEND_ARG_OBJ_INFO(0, link, Phalcon\\Html\\Link\\Interfaces\\LinkInterface, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_html_link_interfaces_evolvablelinkproviderinterface_method_entry) { + PHP_ABSTRACT_ME(Phalcon_Html_Link_Interfaces_EvolvableLinkProviderInterface, withLink, arginfo_phalcon_html_link_interfaces_evolvablelinkproviderinterface_withlink) + PHP_ABSTRACT_ME(Phalcon_Html_Link_Interfaces_EvolvableLinkProviderInterface, withoutLink, arginfo_phalcon_html_link_interfaces_evolvablelinkproviderinterface_withoutlink) + PHP_FE_END +}; diff --git a/ext/phalcon/html/link/interfaces/linkinterface.zep.c b/ext/phalcon/html/link/interfaces/linkinterface.zep.c new file mode 100644 index 00000000000..16b8cf68091 --- /dev/null +++ b/ext/phalcon/html/link/interfaces/linkinterface.zep.c @@ -0,0 +1,71 @@ + +#ifdef HAVE_CONFIG_H +#include "../../../../ext_config.h" +#endif + +#include +#include "../../../../php_ext.h" +#include "../../../../ext.h" + +#include + +#include "kernel/main.h" + + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ +/** + * A readable link object. + */ +ZEPHIR_INIT_CLASS(Phalcon_Html_Link_Interfaces_LinkInterface) +{ + ZEPHIR_REGISTER_INTERFACE(Phalcon\\Html\\Link\\Interfaces, LinkInterface, phalcon, html_link_interfaces_linkinterface, phalcon_html_link_interfaces_linkinterface_method_entry); + + return SUCCESS; +} + +/** + * Returns a list of attributes that describe the target URI. + * + * @return array + * A key-value list of attributes, where the key is a string and the value + * is either a PHP primitive or an array of PHP strings. If no values are + * found an empty array MUST be returned. + */ +ZEPHIR_DOC_METHOD(Phalcon_Html_Link_Interfaces_LinkInterface, getAttributes); +/** + * Returns the target of the link. + * + * The target link must be one of: + * - An absolute URI, as defined by RFC 5988. + * - A relative URI, as defined by RFC 5988. The base of the relative link + * is assumed to be known based on context by the client. + * - A URI template as defined by RFC 6570. + * + * If a URI template is returned, isTemplated() MUST return True. + * + * @return string + */ +ZEPHIR_DOC_METHOD(Phalcon_Html_Link_Interfaces_LinkInterface, getHref); +/** + * Returns the relationship type(s) of the link. + * + * This method returns 0 or more relationship types for a link, expressed + * as an array of strings. + * + * @return string[] + */ +ZEPHIR_DOC_METHOD(Phalcon_Html_Link_Interfaces_LinkInterface, getRels); +/** + * Returns whether this is a templated link. + * + * @return bool + * True if this link object is templated, False otherwise. + */ +ZEPHIR_DOC_METHOD(Phalcon_Html_Link_Interfaces_LinkInterface, isTemplated); diff --git a/ext/phalcon/html/link/interfaces/linkinterface.zep.h b/ext/phalcon/html/link/interfaces/linkinterface.zep.h new file mode 100644 index 00000000000..d4af118adeb --- /dev/null +++ b/ext/phalcon/html/link/interfaces/linkinterface.zep.h @@ -0,0 +1,24 @@ + +extern zend_class_entry *phalcon_html_link_interfaces_linkinterface_ce; + +ZEPHIR_INIT_CLASS(Phalcon_Html_Link_Interfaces_LinkInterface); + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_interfaces_linkinterface_getattributes, 0, 0, IS_ARRAY, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_interfaces_linkinterface_gethref, 0, 0, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_interfaces_linkinterface_getrels, 0, 0, IS_ARRAY, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_interfaces_linkinterface_istemplated, 0, 0, _IS_BOOL, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_html_link_interfaces_linkinterface_method_entry) { + PHP_ABSTRACT_ME(Phalcon_Html_Link_Interfaces_LinkInterface, getAttributes, arginfo_phalcon_html_link_interfaces_linkinterface_getattributes) + PHP_ABSTRACT_ME(Phalcon_Html_Link_Interfaces_LinkInterface, getHref, arginfo_phalcon_html_link_interfaces_linkinterface_gethref) + PHP_ABSTRACT_ME(Phalcon_Html_Link_Interfaces_LinkInterface, getRels, arginfo_phalcon_html_link_interfaces_linkinterface_getrels) + PHP_ABSTRACT_ME(Phalcon_Html_Link_Interfaces_LinkInterface, isTemplated, arginfo_phalcon_html_link_interfaces_linkinterface_istemplated) + PHP_FE_END +}; diff --git a/ext/phalcon/html/link/interfaces/linkproviderinterface.zep.c b/ext/phalcon/html/link/interfaces/linkproviderinterface.zep.c new file mode 100644 index 00000000000..51e801e97ad --- /dev/null +++ b/ext/phalcon/html/link/interfaces/linkproviderinterface.zep.c @@ -0,0 +1,45 @@ + +#ifdef HAVE_CONFIG_H +#include "../../../../ext_config.h" +#endif + +#include +#include "../../../../php_ext.h" +#include "../../../../ext.h" + +#include + +#include "kernel/main.h" + + +/** + * This file is part of the Phalcon Framework. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE.txt + * file that was distributed with this source code. + */ +/** + * A link provider object. + */ +ZEPHIR_INIT_CLASS(Phalcon_Html_Link_Interfaces_LinkProviderInterface) +{ + ZEPHIR_REGISTER_INTERFACE(Phalcon\\Html\\Link\\Interfaces, LinkProviderInterface, phalcon, html_link_interfaces_linkproviderinterface, phalcon_html_link_interfaces_linkproviderinterface_method_entry); + + return SUCCESS; +} + +/** + * Returns an array of LinkInterface objects. + * + * @return LinkInterface[] + */ +ZEPHIR_DOC_METHOD(Phalcon_Html_Link_Interfaces_LinkProviderInterface, getLinks); +/** + * Returns an array of LinkInterface objects that have a specific + * relationship. + * + * @return LinkInterface[] + */ +ZEPHIR_DOC_METHOD(Phalcon_Html_Link_Interfaces_LinkProviderInterface, getLinksByRel); diff --git a/ext/phalcon/html/link/interfaces/linkproviderinterface.zep.h b/ext/phalcon/html/link/interfaces/linkproviderinterface.zep.h new file mode 100644 index 00000000000..1fdc360455f --- /dev/null +++ b/ext/phalcon/html/link/interfaces/linkproviderinterface.zep.h @@ -0,0 +1,17 @@ + +extern zend_class_entry *phalcon_html_link_interfaces_linkproviderinterface_ce; + +ZEPHIR_INIT_CLASS(Phalcon_Html_Link_Interfaces_LinkProviderInterface); + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_interfaces_linkproviderinterface_getlinks, 0, 0, IS_ARRAY, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_interfaces_linkproviderinterface_getlinksbyrel, 0, 1, IS_ARRAY, 0) + ZEND_ARG_TYPE_INFO(0, rel, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(phalcon_html_link_interfaces_linkproviderinterface_method_entry) { + PHP_ABSTRACT_ME(Phalcon_Html_Link_Interfaces_LinkProviderInterface, getLinks, arginfo_phalcon_html_link_interfaces_linkproviderinterface_getlinks) + PHP_ABSTRACT_ME(Phalcon_Html_Link_Interfaces_LinkProviderInterface, getLinksByRel, arginfo_phalcon_html_link_interfaces_linkproviderinterface_getlinksbyrel) + PHP_FE_END +}; diff --git a/ext/phalcon/html/link/link.zep.c b/ext/phalcon/html/link/link.zep.c index 868729a549e..b8cdf262683 100644 --- a/ext/phalcon/html/link/link.zep.c +++ b/ext/phalcon/html/link/link.zep.c @@ -12,11 +12,9 @@ #include #include "kernel/main.h" -#include "kernel/memory.h" #include "kernel/fcall.h" #include "kernel/object.h" -#include "kernel/operators.h" -#include "kernel/string.h" +#include "kernel/memory.h" /** @@ -37,107 +35,12 @@ */ ZEPHIR_INIT_CLASS(Phalcon_Html_Link_Link) { - ZEPHIR_REGISTER_CLASS(Phalcon\\Html\\Link, Link, phalcon, html_link_link, phalcon_html_link_link_method_entry, 0); + ZEPHIR_REGISTER_CLASS_EX(Phalcon\\Html\\Link, Link, phalcon, html_link_link, phalcon_html_link_abstractlink_ce, phalcon_html_link_link_method_entry, 0); - /** - * @var Collection|CollectionInterface - */ - zend_declare_property_null(phalcon_html_link_link_ce, SL("attributes"), ZEND_ACC_PROTECTED); - /** - * @var string - */ - zend_declare_property_string(phalcon_html_link_link_ce, SL("href"), "", ZEND_ACC_PROTECTED); - /** - * @var Collection|CollectionInterface - */ - zend_declare_property_null(phalcon_html_link_link_ce, SL("rels"), ZEND_ACC_PROTECTED); - /** - * @var bool - */ - zend_declare_property_bool(phalcon_html_link_link_ce, SL("templated"), 0, ZEND_ACC_PROTECTED); - zend_class_implements(phalcon_html_link_link_ce, 1, zephir_get_internal_ce(SL("psr\\link\\linkinterface"))); + zend_class_implements(phalcon_html_link_link_ce, 1, phalcon_html_link_interfaces_linkinterface_ce); return SUCCESS; } -/** - * Link constructor. - * - * @param string rel - * @param string href - */ -PHP_METHOD(Phalcon_Html_Link_Link, __construct) -{ - zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; - zend_long ZEPHIR_LAST_CALL_STATUS; - zval attributes; - zval *rel_param = NULL, *href_param = NULL, *attributes_param = NULL, _0, _1, _2, _3$$3, _4$$3; - zval rel, href; - zval *this_ptr = getThis(); - - ZVAL_UNDEF(&rel); - ZVAL_UNDEF(&href); - ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_1); - ZVAL_UNDEF(&_2); - ZVAL_UNDEF(&_3$$3); - ZVAL_UNDEF(&_4$$3); - ZVAL_UNDEF(&attributes); -#if PHP_VERSION_ID >= 80000 - bool is_null_true = 1; - ZEND_PARSE_PARAMETERS_START(0, 3) - Z_PARAM_OPTIONAL - Z_PARAM_STR(rel) - Z_PARAM_STR(href) - Z_PARAM_ARRAY(attributes) - ZEND_PARSE_PARAMETERS_END(); -#endif - - - ZEPHIR_MM_GROW(); - zephir_fetch_params(1, 0, 3, &rel_param, &href_param, &attributes_param); - if (!rel_param) { - ZEPHIR_INIT_VAR(&rel); - ZVAL_STRING(&rel, ""); - } else { - zephir_get_strval(&rel, rel_param); - } - if (!href_param) { - ZEPHIR_INIT_VAR(&href); - ZVAL_STRING(&href, ""); - } else { - zephir_get_strval(&href, href_param); - } - if (!attributes_param) { - ZEPHIR_INIT_VAR(&attributes); - array_init(&attributes); - } else { - zephir_get_arrval(&attributes, attributes_param); - } - - - ZEPHIR_INIT_VAR(&_0); - object_init_ex(&_0, phalcon_support_collection_ce); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 24); - zephir_check_call_status(); - zephir_update_property_zval(this_ptr, ZEND_STRL("rels"), &_0); - ZEPHIR_INIT_VAR(&_1); - object_init_ex(&_1, phalcon_support_collection_ce); - ZEPHIR_CALL_METHOD(NULL, &_1, "__construct", NULL, 24, &attributes); - zephir_check_call_status(); - zephir_update_property_zval(this_ptr, ZEND_STRL("attributes"), &_1); - zephir_update_property_zval(this_ptr, ZEND_STRL("href"), &href); - ZEPHIR_CALL_METHOD(&_2, this_ptr, "hrefistemplated", NULL, 0, &href); - zephir_check_call_status(); - zephir_update_property_zval(this_ptr, ZEND_STRL("templated"), &_2); - if (!(ZEPHIR_IS_EMPTY(&rel))) { - zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("rels"), PH_NOISY_CC | PH_READONLY); - ZVAL_BOOL(&_4$$3, 1); - ZEPHIR_CALL_METHOD(NULL, &_3$$3, "set", NULL, 0, &rel, &_4$$3); - zephir_check_call_status(); - } - ZEPHIR_MM_RESTORE(); -} - /** * Returns a list of attributes that describe the target URI. * @@ -148,18 +51,15 @@ PHP_METHOD(Phalcon_Html_Link_Link, __construct) */ PHP_METHOD(Phalcon_Html_Link_Link, getAttributes) { - zval _0; zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zval *this_ptr = getThis(); - ZVAL_UNDEF(&_0); ZEPHIR_MM_GROW(); - zephir_read_property(&_0, this_ptr, ZEND_STRL("attributes"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_RETURN_CALL_METHOD(&_0, "toarray", NULL, 0); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dogetattributes", NULL, 0); zephir_check_call_status(); RETURN_MM(); } @@ -179,11 +79,17 @@ PHP_METHOD(Phalcon_Html_Link_Link, getAttributes) */ PHP_METHOD(Phalcon_Html_Link_Link, getHref) { + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; zval *this_ptr = getThis(); - RETURN_MEMBER(getThis(), "href"); + ZEPHIR_MM_GROW(); + + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dogethref", NULL, 0); + zephir_check_call_status(); + RETURN_MM(); } /** @@ -196,20 +102,15 @@ PHP_METHOD(Phalcon_Html_Link_Link, getHref) */ PHP_METHOD(Phalcon_Html_Link_Link, getRels) { - zval _0, _1; zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zval *this_ptr = getThis(); - ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_1); ZEPHIR_MM_GROW(); - zephir_read_property(&_0, this_ptr, ZEND_STRL("rels"), PH_NOISY_CC | PH_READONLY); - ZVAL_BOOL(&_1, 0); - ZEPHIR_RETURN_CALL_METHOD(&_0, "getkeys", NULL, 0, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dogetrels", NULL, 0); zephir_check_call_status(); RETURN_MM(); } @@ -221,61 +122,16 @@ PHP_METHOD(Phalcon_Html_Link_Link, getRels) */ PHP_METHOD(Phalcon_Html_Link_Link, isTemplated) { - zval *this_ptr = getThis(); - - - - RETURN_MEMBER(getThis(), "templated"); -} - -/** - * Determines if a href is a templated link or not. - * - * @see https://tools.ietf.org/html/rfc6570 - * - * @param string href - * - * @return bool - */ -PHP_METHOD(Phalcon_Html_Link_Link, hrefIsTemplated) -{ - zend_bool _2; zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *href_param = NULL, _0, _1, _3, _4; - zval href; zval *this_ptr = getThis(); - ZVAL_UNDEF(&href); - ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_1); - ZVAL_UNDEF(&_3); - ZVAL_UNDEF(&_4); -#if PHP_VERSION_ID >= 80000 - bool is_null_true = 1; - ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_STR(href) - ZEND_PARSE_PARAMETERS_END(); -#endif ZEPHIR_MM_GROW(); - zephir_fetch_params(1, 1, 0, &href_param); - zephir_get_strval(&href, href_param); - - ZEPHIR_INIT_VAR(&_0); - ZVAL_STRING(&_0, "{"); - ZEPHIR_INIT_VAR(&_1); - zephir_fast_strpos(&_1, &href, &_0, 0 ); - _2 = !ZEPHIR_IS_FALSE_IDENTICAL(&_1); - if (_2) { - ZEPHIR_INIT_VAR(&_3); - ZVAL_STRING(&_3, "}"); - ZEPHIR_CALL_FUNCTION(&_4, "strrpos", NULL, 124, &href, &_3); - zephir_check_call_status(); - _2 = !ZEPHIR_IS_FALSE_IDENTICAL(&_4); - } - RETURN_MM_BOOL(_2); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "doistemplated", NULL, 0); + zephir_check_call_status(); + RETURN_MM(); } diff --git a/ext/phalcon/html/link/link.zep.h b/ext/phalcon/html/link/link.zep.h index 876552603de..06859f7b3e7 100644 --- a/ext/phalcon/html/link/link.zep.h +++ b/ext/phalcon/html/link/link.zep.h @@ -3,61 +3,27 @@ extern zend_class_entry *phalcon_html_link_link_ce; ZEPHIR_INIT_CLASS(Phalcon_Html_Link_Link); -PHP_METHOD(Phalcon_Html_Link_Link, __construct); PHP_METHOD(Phalcon_Html_Link_Link, getAttributes); PHP_METHOD(Phalcon_Html_Link_Link, getHref); PHP_METHOD(Phalcon_Html_Link_Link, getRels); PHP_METHOD(Phalcon_Html_Link_Link, isTemplated); -PHP_METHOD(Phalcon_Html_Link_Link, hrefIsTemplated); - -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_link___construct, 0, 0, 0) - ZEND_ARG_TYPE_INFO(0, rel, IS_STRING, 0) - ZEND_ARG_TYPE_INFO(0, href, IS_STRING, 0) -#if PHP_VERSION_ID >= 80000 - ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, attributes, IS_ARRAY, 0, "[]") -#else - ZEND_ARG_ARRAY_INFO(0, attributes, 0) -#endif -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_link_getattributes, 0, 0, 0) -ZEND_END_ARG_INFO() -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_link_gethref, 0, 0, 0) +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_link_getattributes, 0, 0, IS_ARRAY, 0) ZEND_END_ARG_INFO() -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_link_getrels, 0, 0, 0) +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_link_gethref, 0, 0, IS_STRING, 0) ZEND_END_ARG_INFO() -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_link_istemplated, 0, 0, 0) +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_link_getrels, 0, 0, IS_ARRAY, 0) ZEND_END_ARG_INFO() -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_link_hrefistemplated, 0, 1, _IS_BOOL, 0) - ZEND_ARG_TYPE_INFO(0, href, IS_STRING, 0) +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_link_istemplated, 0, 0, _IS_BOOL, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(phalcon_html_link_link_method_entry) { - PHP_ME(Phalcon_Html_Link_Link, __construct, arginfo_phalcon_html_link_link___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) -#if PHP_VERSION_ID >= 80000 PHP_ME(Phalcon_Html_Link_Link, getAttributes, arginfo_phalcon_html_link_link_getattributes, ZEND_ACC_PUBLIC) -#else - PHP_ME(Phalcon_Html_Link_Link, getAttributes, NULL, ZEND_ACC_PUBLIC) -#endif -#if PHP_VERSION_ID >= 80000 PHP_ME(Phalcon_Html_Link_Link, getHref, arginfo_phalcon_html_link_link_gethref, ZEND_ACC_PUBLIC) -#else - PHP_ME(Phalcon_Html_Link_Link, getHref, NULL, ZEND_ACC_PUBLIC) -#endif -#if PHP_VERSION_ID >= 80000 PHP_ME(Phalcon_Html_Link_Link, getRels, arginfo_phalcon_html_link_link_getrels, ZEND_ACC_PUBLIC) -#else - PHP_ME(Phalcon_Html_Link_Link, getRels, NULL, ZEND_ACC_PUBLIC) -#endif -#if PHP_VERSION_ID >= 80000 PHP_ME(Phalcon_Html_Link_Link, isTemplated, arginfo_phalcon_html_link_link_istemplated, ZEND_ACC_PUBLIC) -#else - PHP_ME(Phalcon_Html_Link_Link, isTemplated, NULL, ZEND_ACC_PUBLIC) -#endif - PHP_ME(Phalcon_Html_Link_Link, hrefIsTemplated, arginfo_phalcon_html_link_link_hrefistemplated, ZEND_ACC_PROTECTED) PHP_FE_END }; diff --git a/ext/phalcon/html/link/linkprovider.zep.c b/ext/phalcon/html/link/linkprovider.zep.c index a594168aeaf..85b48ccc3fb 100644 --- a/ext/phalcon/html/link/linkprovider.zep.c +++ b/ext/phalcon/html/link/linkprovider.zep.c @@ -13,10 +13,8 @@ #include "kernel/main.h" #include "kernel/fcall.h" -#include "kernel/memory.h" #include "kernel/object.h" -#include "kernel/operators.h" -#include "kernel/array.h" +#include "kernel/memory.h" /** @@ -32,92 +30,12 @@ */ ZEPHIR_INIT_CLASS(Phalcon_Html_Link_LinkProvider) { - ZEPHIR_REGISTER_CLASS(Phalcon\\Html\\Link, LinkProvider, phalcon, html_link_linkprovider, phalcon_html_link_linkprovider_method_entry, 0); + ZEPHIR_REGISTER_CLASS_EX(Phalcon\\Html\\Link, LinkProvider, phalcon, html_link_linkprovider, phalcon_html_link_abstractlinkprovider_ce, phalcon_html_link_linkprovider_method_entry, 0); - /** - * @var LinkInterface[] - */ - zend_declare_property_null(phalcon_html_link_linkprovider_ce, SL("links"), ZEND_ACC_PROTECTED); - phalcon_html_link_linkprovider_ce->create_object = zephir_init_properties_Phalcon_Html_Link_LinkProvider; - - zend_class_implements(phalcon_html_link_linkprovider_ce, 1, zephir_get_internal_ce(SL("psr\\link\\linkproviderinterface"))); + zend_class_implements(phalcon_html_link_linkprovider_ce, 1, phalcon_html_link_interfaces_linkproviderinterface_ce); return SUCCESS; } -/** - * LinkProvider constructor. - * - * @param array links - */ -PHP_METHOD(Phalcon_Html_Link_LinkProvider, __construct) -{ - zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; - zephir_fcall_cache_entry *_3 = NULL; - zend_long ZEPHIR_LAST_CALL_STATUS; - zval *links_param = NULL, link, *_0, _1, _2$$4, _4$$6; - zval links; - zval *this_ptr = getThis(); - - ZVAL_UNDEF(&links); - ZVAL_UNDEF(&link); - ZVAL_UNDEF(&_1); - ZVAL_UNDEF(&_2$$4); - ZVAL_UNDEF(&_4$$6); -#if PHP_VERSION_ID >= 80000 - bool is_null_true = 1; - ZEND_PARSE_PARAMETERS_START(0, 1) - Z_PARAM_OPTIONAL - Z_PARAM_ARRAY(links) - ZEND_PARSE_PARAMETERS_END(); -#endif - - - ZEPHIR_MM_GROW(); - zephir_fetch_params(1, 0, 1, &links_param); - if (!links_param) { - ZEPHIR_INIT_VAR(&links); - array_init(&links); - } else { - zephir_get_arrval(&links, links_param); - } - - - zephir_is_iterable(&links, 0, "phalcon/Html/Link/LinkProvider.zep", 40); - if (Z_TYPE_P(&links) == IS_ARRAY) { - ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&links), _0) - { - ZEPHIR_INIT_NVAR(&link); - ZVAL_COPY(&link, _0); - if (zephir_is_instance_of(&link, SL("Psr\\Link\\LinkInterface"))) { - ZEPHIR_CALL_METHOD(&_2$$4, this_ptr, "getkey", &_3, 0, &link); - zephir_check_call_status(); - zephir_update_property_array(this_ptr, SL("links"), &_2$$4, &link); - } - } ZEND_HASH_FOREACH_END(); - } else { - ZEPHIR_CALL_METHOD(NULL, &links, "rewind", NULL, 0); - zephir_check_call_status(); - while (1) { - ZEPHIR_CALL_METHOD(&_1, &links, "valid", NULL, 0); - zephir_check_call_status(); - if (!zend_is_true(&_1)) { - break; - } - ZEPHIR_CALL_METHOD(&link, &links, "current", NULL, 0); - zephir_check_call_status(); - if (zephir_is_instance_of(&link, SL("Psr\\Link\\LinkInterface"))) { - ZEPHIR_CALL_METHOD(&_4$$6, this_ptr, "getkey", &_3, 0, &link); - zephir_check_call_status(); - zephir_update_property_array(this_ptr, SL("links"), &_4$$6, &link); - } - ZEPHIR_CALL_METHOD(NULL, &links, "next", NULL, 0); - zephir_check_call_status(); - } - } - ZEPHIR_INIT_NVAR(&link); - ZEPHIR_MM_RESTORE(); -} - /** * Returns an iterable of LinkInterface objects. * @@ -128,11 +46,17 @@ PHP_METHOD(Phalcon_Html_Link_LinkProvider, __construct) */ PHP_METHOD(Phalcon_Html_Link_LinkProvider, getLinks) { + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; zval *this_ptr = getThis(); - RETURN_MEMBER(getThis(), "links"); + ZEPHIR_MM_GROW(); + + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dogetlinks", NULL, 0); + zephir_check_call_status(); + RETURN_MM(); } /** @@ -149,15 +73,10 @@ PHP_METHOD(Phalcon_Html_Link_LinkProvider, getLinksByRel) { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; - zval *rel, rel_sub, link, links, rels, _0, *_1, _2; + zval *rel, rel_sub; zval *this_ptr = getThis(); ZVAL_UNDEF(&rel_sub); - ZVAL_UNDEF(&link); - ZVAL_UNDEF(&links); - ZVAL_UNDEF(&rels); - ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_2); #if PHP_VERSION_ID >= 80000 bool is_null_true = 1; ZEND_PARSE_PARAMETERS_START(1, 1) @@ -170,98 +89,8 @@ PHP_METHOD(Phalcon_Html_Link_LinkProvider, getLinksByRel) zephir_fetch_params(1, 1, 0, &rel); - ZEPHIR_INIT_VAR(&links); - array_init(&links); - zephir_read_property(&_0, this_ptr, ZEND_STRL("links"), PH_NOISY_CC | PH_READONLY); - zephir_is_iterable(&_0, 0, "phalcon/Html/Link/LinkProvider.zep", 77); - if (Z_TYPE_P(&_0) == IS_ARRAY) { - ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1) - { - ZEPHIR_INIT_NVAR(&link); - ZVAL_COPY(&link, _1); - ZEPHIR_CALL_METHOD(&rels, &link, "getrels", NULL, 0); - zephir_check_call_status(); - if (1 == zephir_fast_in_array(rel, &rels)) { - zephir_array_append(&links, &link, PH_SEPARATE, "phalcon/Html/Link/LinkProvider.zep", 73); - } - } ZEND_HASH_FOREACH_END(); - } else { - ZEPHIR_CALL_METHOD(NULL, &_0, "rewind", NULL, 0); - zephir_check_call_status(); - while (1) { - ZEPHIR_CALL_METHOD(&_2, &_0, "valid", NULL, 0); - zephir_check_call_status(); - if (!zend_is_true(&_2)) { - break; - } - ZEPHIR_CALL_METHOD(&link, &_0, "current", NULL, 0); - zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&rels, &link, "getrels", NULL, 0); - zephir_check_call_status(); - if (1 == zephir_fast_in_array(rel, &rels)) { - zephir_array_append(&links, &link, PH_SEPARATE, "phalcon/Html/Link/LinkProvider.zep", 73); - } - ZEPHIR_CALL_METHOD(NULL, &_0, "next", NULL, 0); - zephir_check_call_status(); - } - } - ZEPHIR_INIT_NVAR(&link); - RETURN_CCTOR(&links); -} - -/** - * Returns the object hash key - * - * @param LinkInterface link - * - * @return string - */ -PHP_METHOD(Phalcon_Html_Link_LinkProvider, getKey) -{ - zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; - zend_long ZEPHIR_LAST_CALL_STATUS; - zval *link, link_sub; - zval *this_ptr = getThis(); - - ZVAL_UNDEF(&link_sub); -#if PHP_VERSION_ID >= 80000 - bool is_null_true = 1; - ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_OBJECT_OF_CLASS(link, zephir_get_internal_ce(SL("psr\\link\\linkinterface"))) - ZEND_PARSE_PARAMETERS_END(); -#endif - - - ZEPHIR_MM_GROW(); - zephir_fetch_params(1, 1, 0, &link); - - - ZEPHIR_RETURN_CALL_FUNCTION("spl_object_hash", NULL, 108, link); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "dogetlinksbyrel", NULL, 0, rel); zephir_check_call_status(); RETURN_MM(); } -zend_object *zephir_init_properties_Phalcon_Html_Link_LinkProvider(zend_class_entry *class_type) -{ - zval _0, _1$$3; - zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; - ZVAL_UNDEF(&_0); - ZVAL_UNDEF(&_1$$3); - - - ZEPHIR_MM_GROW(); - - { - zval local_this_ptr, *this_ptr = &local_this_ptr; - ZEPHIR_CREATE_OBJECT(this_ptr, class_type); - zephir_read_property_ex(&_0, this_ptr, ZEND_STRL("links"), PH_NOISY_CC | PH_READONLY); - if (Z_TYPE_P(&_0) == IS_NULL) { - ZEPHIR_INIT_VAR(&_1$$3); - array_init(&_1$$3); - zephir_update_property_zval_ex(this_ptr, ZEND_STRL("links"), &_1$$3); - } - ZEPHIR_MM_RESTORE(); - return Z_OBJ_P(this_ptr); - } -} - diff --git a/ext/phalcon/html/link/linkprovider.zep.h b/ext/phalcon/html/link/linkprovider.zep.h index a5503012ac8..bb2f6220c42 100644 --- a/ext/phalcon/html/link/linkprovider.zep.h +++ b/ext/phalcon/html/link/linkprovider.zep.h @@ -3,42 +3,18 @@ extern zend_class_entry *phalcon_html_link_linkprovider_ce; ZEPHIR_INIT_CLASS(Phalcon_Html_Link_LinkProvider); -PHP_METHOD(Phalcon_Html_Link_LinkProvider, __construct); PHP_METHOD(Phalcon_Html_Link_LinkProvider, getLinks); PHP_METHOD(Phalcon_Html_Link_LinkProvider, getLinksByRel); -PHP_METHOD(Phalcon_Html_Link_LinkProvider, getKey); -zend_object *zephir_init_properties_Phalcon_Html_Link_LinkProvider(zend_class_entry *class_type); -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_linkprovider___construct, 0, 0, 0) -#if PHP_VERSION_ID >= 80000 - ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, links, IS_ARRAY, 0, "[]") -#else - ZEND_ARG_ARRAY_INFO(0, links, 0) -#endif +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_linkprovider_getlinks, 0, 0, IS_ARRAY, 0) ZEND_END_ARG_INFO() -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_linkprovider_getlinks, 0, 0, 0) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_linkprovider_getlinksbyrel, 0, 0, 1) +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_linkprovider_getlinksbyrel, 0, 1, IS_ARRAY, 0) ZEND_ARG_INFO(0, rel) ZEND_END_ARG_INFO() -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phalcon_html_link_linkprovider_getkey, 0, 1, IS_STRING, 0) - ZEND_ARG_OBJ_INFO(0, link, Psr\\Link\\LinkInterface, 0) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_html_link_linkprovider_zephir_init_properties_phalcon_html_link_linkprovider, 0, 0, 0) -ZEND_END_ARG_INFO() - ZEPHIR_INIT_FUNCS(phalcon_html_link_linkprovider_method_entry) { - PHP_ME(Phalcon_Html_Link_LinkProvider, __construct, arginfo_phalcon_html_link_linkprovider___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) -#if PHP_VERSION_ID >= 80000 PHP_ME(Phalcon_Html_Link_LinkProvider, getLinks, arginfo_phalcon_html_link_linkprovider_getlinks, ZEND_ACC_PUBLIC) -#else - PHP_ME(Phalcon_Html_Link_LinkProvider, getLinks, NULL, ZEND_ACC_PUBLIC) -#endif PHP_ME(Phalcon_Html_Link_LinkProvider, getLinksByRel, arginfo_phalcon_html_link_linkprovider_getlinksbyrel, ZEND_ACC_PUBLIC) - PHP_ME(Phalcon_Html_Link_LinkProvider, getKey, arginfo_phalcon_html_link_linkprovider_getkey, ZEND_ACC_PROTECTED) PHP_FE_END }; diff --git a/ext/phalcon/http/cookie.zep.c b/ext/phalcon/http/cookie.zep.c index 8b9268cf0db..dfbed0fe6ad 100644 --- a/ext/phalcon/http/cookie.zep.c +++ b/ext/phalcon/http/cookie.zep.c @@ -311,30 +311,30 @@ PHP_METHOD(Phalcon_Http_Cookie, delete) ZEPHIR_INIT_VAR(&_8); ZVAL_STRING(&_8, "expires"); ZVAL_LONG(&_0, (zephir_get_numberval(&_3) - 691200)); - ZEPHIR_CALL_METHOD(&_7, this_ptr, "getarrval", NULL, 355, &options, &_8, &_0); + ZEPHIR_CALL_METHOD(&_7, this_ptr, "getarrval", NULL, 356, &options, &_8, &_0); zephir_check_call_status(); zephir_array_update_string(&options, SL("expires"), &_7, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_8); ZVAL_STRING(&_8, "domain"); - ZEPHIR_CALL_METHOD(&_9, this_ptr, "getarrval", NULL, 355, &options, &_8, &domain); + ZEPHIR_CALL_METHOD(&_9, this_ptr, "getarrval", NULL, 356, &options, &_8, &domain); zephir_check_call_status(); zephir_array_update_string(&options, SL("domain"), &_9, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_8); ZVAL_STRING(&_8, "path"); - ZEPHIR_CALL_METHOD(&_10, this_ptr, "getarrval", NULL, 355, &options, &_8, &path); + ZEPHIR_CALL_METHOD(&_10, this_ptr, "getarrval", NULL, 356, &options, &_8, &path); zephir_check_call_status(); zephir_array_update_string(&options, SL("path"), &_10, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_8); ZVAL_STRING(&_8, "secure"); - ZEPHIR_CALL_METHOD(&_11, this_ptr, "getarrval", NULL, 355, &options, &_8, &secure); + ZEPHIR_CALL_METHOD(&_11, this_ptr, "getarrval", NULL, 356, &options, &_8, &secure); zephir_check_call_status(); zephir_array_update_string(&options, SL("secure"), &_11, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_8); ZVAL_STRING(&_8, "httponly"); - ZEPHIR_CALL_METHOD(&_12, this_ptr, "getarrval", NULL, 355, &options, &_8, &httpOnly); + ZEPHIR_CALL_METHOD(&_12, this_ptr, "getarrval", NULL, 356, &options, &_8, &httpOnly); zephir_check_call_status(); zephir_array_update_string(&options, SL("httponly"), &_12, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_FUNCTION(NULL, "setcookie", NULL, 356, &name, &__$null, &options); + ZEPHIR_CALL_FUNCTION(NULL, "setcookie", NULL, 357, &name, &__$null, &options); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); } @@ -855,30 +855,30 @@ PHP_METHOD(Phalcon_Http_Cookie, send) } ZEPHIR_INIT_NVAR(&_3); ZVAL_STRING(&_3, "expires"); - ZEPHIR_CALL_METHOD(&_13, this_ptr, "getarrval", NULL, 355, &options, &_3, &expire); + ZEPHIR_CALL_METHOD(&_13, this_ptr, "getarrval", NULL, 356, &options, &_3, &expire); zephir_check_call_status(); zephir_array_update_string(&options, SL("expires"), &_13, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_3); ZVAL_STRING(&_3, "domain"); - ZEPHIR_CALL_METHOD(&_14, this_ptr, "getarrval", NULL, 355, &options, &_3, &domain); + ZEPHIR_CALL_METHOD(&_14, this_ptr, "getarrval", NULL, 356, &options, &_3, &domain); zephir_check_call_status(); zephir_array_update_string(&options, SL("domain"), &_14, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_3); ZVAL_STRING(&_3, "path"); - ZEPHIR_CALL_METHOD(&_15, this_ptr, "getarrval", NULL, 355, &options, &_3, &path); + ZEPHIR_CALL_METHOD(&_15, this_ptr, "getarrval", NULL, 356, &options, &_3, &path); zephir_check_call_status(); zephir_array_update_string(&options, SL("path"), &_15, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_3); ZVAL_STRING(&_3, "secure"); - ZEPHIR_CALL_METHOD(&_16, this_ptr, "getarrval", NULL, 355, &options, &_3, &secure); + ZEPHIR_CALL_METHOD(&_16, this_ptr, "getarrval", NULL, 356, &options, &_3, &secure); zephir_check_call_status(); zephir_array_update_string(&options, SL("secure"), &_16, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_NVAR(&_3); ZVAL_STRING(&_3, "httponly"); - ZEPHIR_CALL_METHOD(&_17, this_ptr, "getarrval", NULL, 355, &options, &_3, &httpOnly); + ZEPHIR_CALL_METHOD(&_17, this_ptr, "getarrval", NULL, 356, &options, &_3, &httpOnly); zephir_check_call_status(); zephir_array_update_string(&options, SL("httponly"), &_17, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_FUNCTION(NULL, "setcookie", NULL, 356, &name, &encryptValue, &options); + ZEPHIR_CALL_FUNCTION(NULL, "setcookie", NULL, 357, &name, &encryptValue, &options); zephir_check_call_status(); RETURN_THIS(); } diff --git a/ext/phalcon/http/message/abstractrequest.zep.c b/ext/phalcon/http/message/abstractrequest.zep.c index 53001b60c13..297ea792de3 100644 --- a/ext/phalcon/http/message/abstractrequest.zep.c +++ b/ext/phalcon/http/message/abstractrequest.zep.c @@ -189,7 +189,7 @@ PHP_METHOD(Phalcon_Http_Message_AbstractRequest, withMethod) zephir_fetch_params(1, 1, 0, &method); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "processmethod", NULL, 113, method); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "processmethod", NULL, 115, method); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "method"); @@ -462,13 +462,13 @@ PHP_METHOD(Phalcon_Http_Message_AbstractRequest, processUri) } if (EXPECTED(Z_TYPE_P(uri) == IS_STRING)) { object_init_ex(return_value, phalcon_http_message_uri_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 114, uri); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 116, uri); zephir_check_call_status(); RETURN_MM(); } if (Z_TYPE_P(uri) == IS_NULL) { object_init_ex(return_value, phalcon_http_message_uri_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 114); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 116); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/http/message/request.zep.c b/ext/phalcon/http/message/request.zep.c index 2fd21bd253b..c67cc641fa7 100644 --- a/ext/phalcon/http/message/request.zep.c +++ b/ext/phalcon/http/message/request.zep.c @@ -111,16 +111,16 @@ PHP_METHOD(Phalcon_Http_Message_Request, __construct) if (UNEXPECTED(ZEPHIR_IS_IDENTICAL(&_0, body))) { ZEPHIR_INIT_NVAR(body); object_init_ex(body, phalcon_http_message_stream_input_ce); - ZEPHIR_CALL_METHOD(NULL, body, "__construct", NULL, 357); + ZEPHIR_CALL_METHOD(NULL, body, "__construct", NULL, 358); zephir_check_call_status(); } - ZEPHIR_CALL_METHOD(&_1, this_ptr, "processuri", NULL, 358, uri); + ZEPHIR_CALL_METHOD(&_1, this_ptr, "processuri", NULL, 359, uri); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("uri"), &_1); - ZEPHIR_CALL_METHOD(&_2, this_ptr, "processheaders", NULL, 359, headers); + ZEPHIR_CALL_METHOD(&_2, this_ptr, "processheaders", NULL, 360, headers); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("headers"), &_2); - ZEPHIR_CALL_METHOD(&_3, this_ptr, "processmethod", NULL, 113, &method); + ZEPHIR_CALL_METHOD(&_3, this_ptr, "processmethod", NULL, 115, &method); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("method"), &_3); ZEPHIR_INIT_VAR(&_5); diff --git a/ext/phalcon/http/message/requestfactory.zep.c b/ext/phalcon/http/message/requestfactory.zep.c index d462f6bc1e0..376eeabe638 100644 --- a/ext/phalcon/http/message/requestfactory.zep.c +++ b/ext/phalcon/http/message/requestfactory.zep.c @@ -84,7 +84,7 @@ PHP_METHOD(Phalcon_Http_Message_RequestFactory, createRequest) object_init_ex(return_value, phalcon_http_message_request_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 360, &method, uri); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 361, &method, uri); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/http/message/response.zep.c b/ext/phalcon/http/message/response.zep.c index 1b4605dfa0f..ce874b8be3f 100644 --- a/ext/phalcon/http/message/response.zep.c +++ b/ext/phalcon/http/message/response.zep.c @@ -161,9 +161,9 @@ PHP_METHOD(Phalcon_Http_Message_Response, __construct) ZVAL_LONG(&_0, code); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "processcode", NULL, 361, &_0); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "processcode", NULL, 362, &_0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_1, this_ptr, "processheaders", NULL, 359, &headers); + ZEPHIR_CALL_METHOD(&_1, this_ptr, "processheaders", NULL, 360, &headers); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("headers"), &_1); ZEPHIR_INIT_VAR(&_3); @@ -373,14 +373,14 @@ PHP_METHOD(Phalcon_Http_Message_Response, processCode) } - ZEPHIR_CALL_METHOD(&phrases, this_ptr, "getphrases", NULL, 362); + ZEPHIR_CALL_METHOD(&phrases, this_ptr, "getphrases", NULL, 363); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkcodetype", NULL, 363, code); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkcodetype", NULL, 364, code); zephir_check_call_status(); _0 = zephir_get_intval(code); ZEPHIR_INIT_NVAR(code); ZVAL_LONG(code, _0); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkcodevalue", NULL, 364, code); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkcodevalue", NULL, 365, code); zephir_check_call_status(); if (UNEXPECTED(Z_TYPE_P(phrase) != IS_STRING)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_message_exception_invalidargumentexception_ce, "Invalid response reason", "phalcon/Http/Message/Response.zep", 225); @@ -470,7 +470,7 @@ PHP_METHOD(Phalcon_Http_Message_Response, checkCodeValue) ZVAL_LONG(&_1, code); ZVAL_LONG(&_2, 100); ZVAL_LONG(&_3, 599); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "isbetween", NULL, 365, &_1, &_2, &_3); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "isbetween", NULL, 366, &_1, &_2, &_3); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_0)) { ZEPHIR_INIT_VAR(&_4$$3); diff --git a/ext/phalcon/http/message/responsefactory.zep.c b/ext/phalcon/http/message/responsefactory.zep.c index d021975dd81..d6e38781201 100644 --- a/ext/phalcon/http/message/responsefactory.zep.c +++ b/ext/phalcon/http/message/responsefactory.zep.c @@ -90,10 +90,10 @@ PHP_METHOD(Phalcon_Http_Message_ResponseFactory, createResponse) ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, phalcon_http_message_response_ce); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 366); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 367); zephir_check_call_status(); ZVAL_LONG(&_1, code); - ZEPHIR_RETURN_CALL_METHOD(&_0, "withstatus", NULL, 367, &_1, &reasonPhrase); + ZEPHIR_RETURN_CALL_METHOD(&_0, "withstatus", NULL, 368, &_1, &reasonPhrase); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/http/message/serverrequest.zep.c b/ext/phalcon/http/message/serverrequest.zep.c index 086e4f6197c..22317052e46 100644 --- a/ext/phalcon/http/message/serverrequest.zep.c +++ b/ext/phalcon/http/message/serverrequest.zep.c @@ -334,21 +334,21 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequest, __construct) if (UNEXPECTED(ZEPHIR_IS_IDENTICAL(&_0, body))) { ZEPHIR_INIT_NVAR(body); object_init_ex(body, phalcon_http_message_stream_input_ce); - ZEPHIR_CALL_METHOD(NULL, body, "__construct", NULL, 357); + ZEPHIR_CALL_METHOD(NULL, body, "__construct", NULL, 358); zephir_check_call_status(); } - ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkuploadedfiles", NULL, 368, &uploadFiles); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkuploadedfiles", NULL, 369, &uploadFiles); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_1, this_ptr, "processprotocol", NULL, 38, &protocol); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("protocolVersion"), &_1); - ZEPHIR_CALL_METHOD(&_2, this_ptr, "processmethod", NULL, 113, &method); + ZEPHIR_CALL_METHOD(&_2, this_ptr, "processmethod", NULL, 115, &method); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("method"), &_2); - ZEPHIR_CALL_METHOD(&_3, this_ptr, "processheaders", NULL, 359, headers); + ZEPHIR_CALL_METHOD(&_3, this_ptr, "processheaders", NULL, 360, headers); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("headers"), &_3); - ZEPHIR_CALL_METHOD(&_4, this_ptr, "processuri", NULL, 358, uri); + ZEPHIR_CALL_METHOD(&_4, this_ptr, "processuri", NULL, 359, uri); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("uri"), &_4); ZEPHIR_INIT_VAR(&_6); @@ -696,7 +696,7 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequest, withUploadedFiles) zephir_get_arrval(&uploadedFiles, uploadedFiles_param); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkuploadedfiles", NULL, 368, &uploadedFiles); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkuploadedfiles", NULL, 369, &uploadedFiles); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "uploadedFiles"); @@ -796,7 +796,7 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequest, checkUploadedFiles) ZEPHIR_INIT_NVAR(&file); ZVAL_COPY(&file, _0); if (UNEXPECTED(Z_TYPE_P(&file) == IS_ARRAY)) { - ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkuploadedfiles", &_2, 368, &file); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkuploadedfiles", &_2, 369, &file); zephir_check_call_status(); } else { _3$$5 = Z_TYPE_P(&file) == IS_OBJECT; @@ -821,7 +821,7 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequest, checkUploadedFiles) ZEPHIR_CALL_METHOD(&file, &files, "current", NULL, 0); zephir_check_call_status(); if (UNEXPECTED(Z_TYPE_P(&file) == IS_ARRAY)) { - ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkuploadedfiles", &_2, 368, &file); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkuploadedfiles", &_2, 369, &file); zephir_check_call_status(); } else { _4$$9 = Z_TYPE_P(&file) == IS_OBJECT; diff --git a/ext/phalcon/http/message/serverrequestfactory.zep.c b/ext/phalcon/http/message/serverrequestfactory.zep.c index c75be05e4f3..2b4363ece8b 100644 --- a/ext/phalcon/http/message/serverrequestfactory.zep.c +++ b/ext/phalcon/http/message/serverrequestfactory.zep.c @@ -102,7 +102,7 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequestFactory, createServerRequest) object_init_ex(return_value, phalcon_http_message_serverrequest_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 369, &method, uri, &serverParams); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 370, &method, uri, &serverParams); zephir_check_call_status(); RETURN_MM(); } @@ -238,22 +238,22 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequestFactory, load) if (!(ZEPHIR_IS_EMPTY(&_SERVER))) { ZEPHIR_CPY_WRT(&globalServer, &_SERVER); } - ZEPHIR_CALL_METHOD(&_0, this_ptr, "checknullarray", NULL, 370, &server, &globalServer); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "checknullarray", NULL, 371, &server, &globalServer); zephir_check_call_status(); ZEPHIR_CPY_WRT(&server, &_0); - ZEPHIR_CALL_METHOD(&_1, this_ptr, "checknullarray", NULL, 370, &files, &globalFiles); + ZEPHIR_CALL_METHOD(&_1, this_ptr, "checknullarray", NULL, 371, &files, &globalFiles); zephir_check_call_status(); ZEPHIR_CPY_WRT(&files, &_1); - ZEPHIR_CALL_METHOD(&_2, this_ptr, "checknullarray", NULL, 370, &cookies, &globalCookies); + ZEPHIR_CALL_METHOD(&_2, this_ptr, "checknullarray", NULL, 371, &cookies, &globalCookies); zephir_check_call_status(); ZEPHIR_CPY_WRT(&cookies, &_2); - ZEPHIR_CALL_METHOD(&_3, this_ptr, "checknullarray", NULL, 370, &get, &globalGet); + ZEPHIR_CALL_METHOD(&_3, this_ptr, "checknullarray", NULL, 371, &get, &globalGet); zephir_check_call_status(); ZEPHIR_CPY_WRT(&get, &_3); - ZEPHIR_CALL_METHOD(&_4, this_ptr, "checknullarray", NULL, 370, &post, &globalPost); + ZEPHIR_CALL_METHOD(&_4, this_ptr, "checknullarray", NULL, 371, &post, &globalPost); zephir_check_call_status(); ZEPHIR_CPY_WRT(&post, &_4); - ZEPHIR_CALL_METHOD(&serverCollection, this_ptr, "parseserver", NULL, 371, &server); + ZEPHIR_CALL_METHOD(&serverCollection, this_ptr, "parseserver", NULL, 372, &server); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_5); ZVAL_STRING(&_5, "REQUEST_METHOD"); @@ -261,11 +261,11 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequestFactory, load) ZVAL_STRING(&_6, "GET"); ZEPHIR_CALL_METHOD(&method, &serverCollection, "get", NULL, 0, &_5, &_6); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&protocol, this_ptr, "parseprotocol", NULL, 372, &serverCollection); + ZEPHIR_CALL_METHOD(&protocol, this_ptr, "parseprotocol", NULL, 373, &serverCollection); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&headers, this_ptr, "parseheaders", NULL, 373, &serverCollection); + ZEPHIR_CALL_METHOD(&headers, this_ptr, "parseheaders", NULL, 374, &serverCollection); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&filesCollection, this_ptr, "parseuploadedfiles", NULL, 374, &files); + ZEPHIR_CALL_METHOD(&filesCollection, this_ptr, "parseuploadedfiles", NULL, 375, &files); zephir_check_call_status(); ZEPHIR_CPY_WRT(&cookiesCollection, &cookies); _7 = ZEPHIR_IS_EMPTY(&cookies); @@ -281,11 +281,11 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequestFactory, load) ZVAL_STRING(&_10$$8, "cookie"); ZEPHIR_CALL_METHOD(&_9$$8, &headers, "get", NULL, 0, &_10$$8); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&cookiesCollection, this_ptr, "parsecookieheader", NULL, 375, &_9$$8); + ZEPHIR_CALL_METHOD(&cookiesCollection, this_ptr, "parsecookieheader", NULL, 376, &_9$$8); zephir_check_call_status(); } object_init_ex(return_value, phalcon_http_message_serverrequest_ce); - ZEPHIR_CALL_METHOD(&_11, this_ptr, "parseuri", NULL, 376, &serverCollection, &headers); + ZEPHIR_CALL_METHOD(&_11, this_ptr, "parseuri", NULL, 377, &serverCollection, &headers); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_12, &serverCollection, "toarray", NULL, 0); zephir_check_call_status(); @@ -295,7 +295,7 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequestFactory, load) zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_5); ZVAL_STRING(&_5, "php://input"); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 369, &method, &_11, &_12, &_5, &_13, &cookiesCollection, &get, &_14, &post, &protocol); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 370, &method, &_11, &_12, &_5, &_13, &cookiesCollection, &get, &_14, &post, &protocol); zephir_check_call_status(); RETURN_MM(); } @@ -316,7 +316,7 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequestFactory, getHeaders) ZEPHIR_MM_GROW(); if (EXPECTED((zephir_function_exists_ex(ZEND_STRL("apache_request_headers")) == SUCCESS))) { - ZEPHIR_RETURN_CALL_FUNCTION("apache_request_headers", NULL, 377); + ZEPHIR_RETURN_CALL_FUNCTION("apache_request_headers", NULL, 378); zephir_check_call_status(); RETURN_MM(); } @@ -372,14 +372,14 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequestFactory, calculateUriHost) ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "host"); ZVAL_BOOL(&_2, 0); - ZEPHIR_CALL_METHOD(&_1, this_ptr, "getheader", NULL, 378, headers, &_0, &_2); + ZEPHIR_CALL_METHOD(&_1, this_ptr, "getheader", NULL, 379, headers, &_0, &_2); zephir_check_call_status(); if (UNEXPECTED(zephir_is_true(&_1))) { ZEPHIR_INIT_VAR(&_3$$3); ZVAL_STRING(&_3$$3, "host"); - ZEPHIR_CALL_METHOD(&host, this_ptr, "getheader", NULL, 378, headers, &_3$$3); + ZEPHIR_CALL_METHOD(&host, this_ptr, "getheader", NULL, 379, headers, &_3$$3); zephir_check_call_status(); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "calculateurihostfromheader", NULL, 379, &host); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "calculateurihostfromheader", NULL, 380, &host); zephir_check_call_status(); RETURN_MM(); } @@ -669,7 +669,7 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequestFactory, calculateUriScheme) ZVAL_STRING(&_1, "x-forwarded-proto"); ZEPHIR_INIT_VAR(&_8); ZVAL_STRING(&_8, "https"); - ZEPHIR_CALL_METHOD(&header, this_ptr, "getheader", NULL, 378, headers, &_1, &_8); + ZEPHIR_CALL_METHOD(&header, this_ptr, "getheader", NULL, 379, headers, &_1, &_8); zephir_check_call_status(); _9 = !zephir_is_true(&isHttps); if (!(_9)) { @@ -795,7 +795,7 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequestFactory, createUploadedFile) zephir_array_fetch_string(&_4, &file, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/Http/Message/ServerRequestFactory.zep", 325); zephir_array_fetch_string(&_5, &file, SL("size"), PH_NOISY | PH_READONLY, "phalcon/Http/Message/ServerRequestFactory.zep", 326); zephir_array_fetch_string(&_6, &file, SL("error"), PH_NOISY | PH_READONLY, "phalcon/Http/Message/ServerRequestFactory.zep", 327); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 380, &_4, &_5, &_6, &name, &type); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 381, &_4, &_5, &_6, &name, &type); zephir_check_call_status(); RETURN_MM(); } @@ -897,7 +897,7 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequestFactory, parseCookieHeader) ZEPHIR_CALL_FUNCTION(&_1, "strtr", NULL, 5, &cookieHeader, &_0); zephir_check_call_status(); ZEPHIR_MAKE_REF(&cookies); - ZEPHIR_CALL_FUNCTION(NULL, "parse_str", NULL, 381, &_1, &cookies); + ZEPHIR_CALL_FUNCTION(NULL, "parse_str", NULL, 382, &_1, &cookies); ZEPHIR_UNREF(&cookies); zephir_check_call_status(); RETURN_CCTOR(&cookies); @@ -1278,7 +1278,7 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequestFactory, parseServer) zephir_check_call_status(); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "HTTP_AUTHORIZATION"); - ZEPHIR_CALL_METHOD(&_0, &collection, "has", NULL, 382, &_1); + ZEPHIR_CALL_METHOD(&_0, &collection, "has", NULL, 383, &_1); zephir_check_call_status(); _2 = !zephir_is_true(&_0); if (_2) { @@ -1291,12 +1291,12 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequestFactory, parseServer) zephir_check_call_status(); ZEPHIR_INIT_VAR(&_4$$3); ZVAL_STRING(&_4$$3, "Authorization"); - ZEPHIR_CALL_METHOD(&_3$$3, &headersCollection, "has", NULL, 382, &_4$$3); + ZEPHIR_CALL_METHOD(&_3$$3, &headersCollection, "has", NULL, 383, &_4$$3); zephir_check_call_status(); if (UNEXPECTED(zephir_is_true(&_3$$3))) { ZEPHIR_INIT_VAR(&_6$$4); ZVAL_STRING(&_6$$4, "Authorization"); - ZEPHIR_CALL_METHOD(&_5$$4, &headersCollection, "get", NULL, 383, &_6$$4); + ZEPHIR_CALL_METHOD(&_5$$4, &headersCollection, "get", NULL, 384, &_6$$4); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_6$$4); ZVAL_STRING(&_6$$4, "HTTP_AUTHORIZATION"); @@ -1385,14 +1385,14 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequestFactory, parseUploadedFiles) _7$$3 = zephir_array_isset_string(&file, SL("tmp_name")); } if (EXPECTED(_7$$3)) { - ZEPHIR_CALL_METHOD(&_8$$5, this_ptr, "createuploadedfile", &_9, 384, &file); + ZEPHIR_CALL_METHOD(&_8$$5, this_ptr, "createuploadedfile", &_9, 385, &file); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &collection, "set", &_6, 42, &key, &_8$$5); zephir_check_call_status(); continue; } if (UNEXPECTED(Z_TYPE_P(&file) == IS_ARRAY)) { - ZEPHIR_CALL_METHOD(&data, this_ptr, "parseuploadedfiles", &_10, 374, &file); + ZEPHIR_CALL_METHOD(&data, this_ptr, "parseuploadedfiles", &_10, 375, &file); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_11$$6, &data, "toarray", NULL, 0); zephir_check_call_status(); @@ -1430,14 +1430,14 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequestFactory, parseUploadedFiles) _14$$7 = zephir_array_isset_string(&file, SL("tmp_name")); } if (EXPECTED(_14$$7)) { - ZEPHIR_CALL_METHOD(&_15$$9, this_ptr, "createuploadedfile", &_9, 384, &file); + ZEPHIR_CALL_METHOD(&_15$$9, this_ptr, "createuploadedfile", &_9, 385, &file); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &collection, "set", &_6, 42, &key, &_15$$9); zephir_check_call_status(); continue; } if (UNEXPECTED(Z_TYPE_P(&file) == IS_ARRAY)) { - ZEPHIR_CALL_METHOD(&data, this_ptr, "parseuploadedfiles", &_10, 374, &file); + ZEPHIR_CALL_METHOD(&data, this_ptr, "parseuploadedfiles", &_10, 375, &file); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_16$$10, &data, "toarray", NULL, 0); zephir_check_call_status(); @@ -1502,32 +1502,32 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequestFactory, parseUri) ZEPHIR_INIT_VAR(&uri); object_init_ex(&uri, phalcon_http_message_uri_ce); - ZEPHIR_CALL_METHOD(NULL, &uri, "__construct", NULL, 114); + ZEPHIR_CALL_METHOD(NULL, &uri, "__construct", NULL, 116); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&scheme, this_ptr, "calculateurischeme", NULL, 385, server, headers); + ZEPHIR_CALL_METHOD(&scheme, this_ptr, "calculateurischeme", NULL, 386, server, headers); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_0, &uri, "withscheme", NULL, 386, &scheme); + ZEPHIR_CALL_METHOD(&_0, &uri, "withscheme", NULL, 387, &scheme); zephir_check_call_status(); ZEPHIR_CPY_WRT(&uri, &_0); - ZEPHIR_CALL_METHOD(&split, this_ptr, "calculateurihost", NULL, 387, server, headers); + ZEPHIR_CALL_METHOD(&split, this_ptr, "calculateurihost", NULL, 388, server, headers); zephir_check_call_status(); ZEPHIR_OBS_VAR(&_1); zephir_array_fetch_long(&_1, &split, 0, PH_NOISY, "phalcon/Http/Message/ServerRequestFactory.zep", 585); if (EXPECTED(!(ZEPHIR_IS_EMPTY(&_1)))) { zephir_array_fetch_long(&_3$$3, &split, 0, PH_NOISY | PH_READONLY, "phalcon/Http/Message/ServerRequestFactory.zep", 586); - ZEPHIR_CALL_METHOD(&_2$$3, &uri, "withhost", NULL, 388, &_3$$3); + ZEPHIR_CALL_METHOD(&_2$$3, &uri, "withhost", NULL, 389, &_3$$3); zephir_check_call_status(); ZEPHIR_CPY_WRT(&uri, &_2$$3); ZEPHIR_OBS_VAR(&_4$$3); zephir_array_fetch_long(&_4$$3, &split, 1, PH_NOISY, "phalcon/Http/Message/ServerRequestFactory.zep", 587); if (UNEXPECTED(!(ZEPHIR_IS_EMPTY(&_4$$3)))) { zephir_array_fetch_long(&_6$$4, &split, 1, PH_NOISY | PH_READONLY, "phalcon/Http/Message/ServerRequestFactory.zep", 588); - ZEPHIR_CALL_METHOD(&_5$$4, &uri, "withport", NULL, 389, &_6$$4); + ZEPHIR_CALL_METHOD(&_5$$4, &uri, "withport", NULL, 390, &_6$$4); zephir_check_call_status(); ZEPHIR_CPY_WRT(&uri, &_5$$4); } } - ZEPHIR_CALL_METHOD(&path, this_ptr, "calculateuripath", NULL, 390, server); + ZEPHIR_CALL_METHOD(&path, this_ptr, "calculateuripath", NULL, 391, server); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&split); zephir_fast_explode_str(&split, SL("#"), &path, LONG_MAX); @@ -1535,18 +1535,18 @@ PHP_METHOD(Phalcon_Http_Message_ServerRequestFactory, parseUri) ZEPHIR_INIT_NVAR(&path); zephir_fast_explode_str(&path, SL("?"), &_7, LONG_MAX); zephir_array_fetch_long(&_8, &path, 0, PH_NOISY | PH_READONLY, "phalcon/Http/Message/ServerRequestFactory.zep", 598); - ZEPHIR_CALL_METHOD(&_0, &uri, "withpath", NULL, 391, &_8); + ZEPHIR_CALL_METHOD(&_0, &uri, "withpath", NULL, 392, &_8); zephir_check_call_status(); ZEPHIR_CPY_WRT(&uri, &_0); if (UNEXPECTED(zephir_fast_count_int(&split) > 1)) { zephir_array_fetch_long(&_10$$5, &split, 1, PH_NOISY | PH_READONLY, "phalcon/Http/Message/ServerRequestFactory.zep", 601); - ZEPHIR_CALL_METHOD(&_9$$5, &uri, "withfragment", NULL, 392, &_10$$5); + ZEPHIR_CALL_METHOD(&_9$$5, &uri, "withfragment", NULL, 393, &_10$$5); zephir_check_call_status(); ZEPHIR_CPY_WRT(&uri, &_9$$5); } - ZEPHIR_CALL_METHOD(&query, this_ptr, "calculateuriquery", NULL, 393, server); + ZEPHIR_CALL_METHOD(&query, this_ptr, "calculateuriquery", NULL, 394, server); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_0, &uri, "withquery", NULL, 394, &query); + ZEPHIR_CALL_METHOD(&_0, &uri, "withquery", NULL, 395, &query); zephir_check_call_status(); ZEPHIR_CPY_WRT(&uri, &_0); RETURN_CCTOR(&uri); diff --git a/ext/phalcon/http/message/streamfactory.zep.c b/ext/phalcon/http/message/streamfactory.zep.c index b47ab5443cc..ba2fab1f6b9 100644 --- a/ext/phalcon/http/message/streamfactory.zep.c +++ b/ext/phalcon/http/message/streamfactory.zep.c @@ -103,9 +103,9 @@ PHP_METHOD(Phalcon_Http_Message_StreamFactory, createStream) return; } zephir_fwrite(NULL, &handle, &content); - ZEPHIR_CALL_FUNCTION(NULL, "rewind", NULL, 395, &handle); + ZEPHIR_CALL_FUNCTION(NULL, "rewind", NULL, 396, &handle); zephir_check_call_status(); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "createstreamfromresource", NULL, 396, &handle); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "createstreamfromresource", NULL, 397, &handle); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/http/message/uploadedfile.zep.c b/ext/phalcon/http/message/uploadedfile.zep.c index 8c9f6e103af..e245e7f0b8d 100644 --- a/ext/phalcon/http/message/uploadedfile.zep.c +++ b/ext/phalcon/http/message/uploadedfile.zep.c @@ -256,10 +256,10 @@ PHP_METHOD(Phalcon_Http_Message_UploadedFile, __construct) ZVAL_LONG(&_0, error); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkstream", NULL, 397, stream, &_0); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkstream", NULL, 398, stream, &_0); zephir_check_call_status(); ZVAL_LONG(&_0, error); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkerror", NULL, 398, &_0); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkerror", NULL, 399, &_0); zephir_check_call_status(); ZEPHIR_INIT_ZVAL_NREF(_0); ZVAL_LONG(&_0, size); @@ -308,7 +308,7 @@ PHP_METHOD(Phalcon_Http_Message_UploadedFile, getStream) ZEPHIR_INIT_VAR(&_1$$3); object_init_ex(&_1$$3, phalcon_http_message_exception_invalidargumentexception_ce); zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("error"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "geterrordescription", NULL, 399, &_3$$3); + ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "geterrordescription", NULL, 400, &_3$$3); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 40, &_2$$3); zephir_check_call_status(); @@ -415,7 +415,7 @@ PHP_METHOD(Phalcon_Http_Message_UploadedFile, moveTo) ZEPHIR_INIT_VAR(&_2$$4); object_init_ex(&_2$$4, phalcon_http_message_exception_invalidargumentexception_ce); zephir_read_property(&_4$$4, this_ptr, ZEND_STRL("error"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_METHOD(&_3$$4, this_ptr, "geterrordescription", NULL, 399, &_4$$4); + ZEPHIR_CALL_METHOD(&_3$$4, this_ptr, "geterrordescription", NULL, 400, &_4$$4); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &_2$$4, "__construct", NULL, 40, &_3$$4); zephir_check_call_status(); @@ -429,7 +429,7 @@ PHP_METHOD(Phalcon_Http_Message_UploadedFile, moveTo) } _6 = _5; if (_6) { - ZEPHIR_CALL_FUNCTION(&_7, "dirname", NULL, 400, targetPath); + ZEPHIR_CALL_FUNCTION(&_7, "dirname", NULL, 401, targetPath); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&_8, "is_dir", NULL, 160, &_7); zephir_check_call_status(); @@ -437,9 +437,9 @@ PHP_METHOD(Phalcon_Http_Message_UploadedFile, moveTo) } _9 = _6; if (_9) { - ZEPHIR_CALL_FUNCTION(&_10, "dirname", NULL, 400, targetPath); + ZEPHIR_CALL_FUNCTION(&_10, "dirname", NULL, 401, targetPath); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&_11, "is_writable", NULL, 401, &_10); + ZEPHIR_CALL_FUNCTION(&_11, "is_writable", NULL, 402, &_10); zephir_check_call_status(); _9 = zephir_is_true(&_11); } @@ -466,11 +466,11 @@ PHP_METHOD(Phalcon_Http_Message_UploadedFile, moveTo) _16 = zephir_start_with_str(&sapi, SL("phpdbg")); } if (UNEXPECTED(_16)) { - ZEPHIR_CALL_METHOD(NULL, this_ptr, "storefile", NULL, 402, targetPath); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "storefile", NULL, 403, targetPath); zephir_check_call_status(); } else { zephir_read_property(&_17$$7, this_ptr, ZEND_STRL("fileName"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_18$$7, "move_uploaded_file", NULL, 403, &_17$$7, targetPath); + ZEPHIR_CALL_FUNCTION(&_18$$7, "move_uploaded_file", NULL, 404, &_17$$7, targetPath); zephir_check_call_status(); if (!ZEPHIR_IS_TRUE_IDENTICAL(&_18$$7)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_message_exception_invalidargumentexception_ce, "The file cannot be moved to the target folder", "phalcon/Http/Message/UploadedFile.zep", 243); @@ -517,7 +517,7 @@ PHP_METHOD(Phalcon_Http_Message_UploadedFile, checkError) ZVAL_LONG(&_1, error); ZVAL_LONG(&_2, 0); ZVAL_LONG(&_3, 8); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "isbetween", NULL, 404, &_1, &_2, &_3); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "isbetween", NULL, 405, &_1, &_2, &_3); zephir_check_call_status(); if (UNEXPECTED(!ZEPHIR_IS_TRUE_IDENTICAL(&_0))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_message_exception_invalidargumentexception_ce, "Invalid error. Must be one of the UPLOAD_ERR_* constants", "phalcon/Http/Message/UploadedFile.zep", 260); @@ -675,7 +675,7 @@ PHP_METHOD(Phalcon_Http_Message_UploadedFile, storeFile) ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_message_exception_invalidargumentexception_ce, "Cannot write to file.", "phalcon/Http/Message/UploadedFile.zep", 331); return; } - ZEPHIR_CALL_METHOD(&stream, this_ptr, "getstream", NULL, 405); + ZEPHIR_CALL_METHOD(&stream, this_ptr, "getstream", NULL, 406); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, &stream, "rewind", NULL, 0); zephir_check_call_status(); diff --git a/ext/phalcon/http/message/uploadedfilefactory.zep.c b/ext/phalcon/http/message/uploadedfilefactory.zep.c index 84330283db2..697c6313e11 100644 --- a/ext/phalcon/http/message/uploadedfilefactory.zep.c +++ b/ext/phalcon/http/message/uploadedfilefactory.zep.c @@ -112,7 +112,7 @@ PHP_METHOD(Phalcon_Http_Message_UploadedFileFactory, createUploadedFile) object_init_ex(return_value, phalcon_http_message_uploadedfile_ce); ZVAL_LONG(&_0, size); ZVAL_LONG(&_1, error); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 380, stream, &_0, &_1, &clientFilename, &clientMediaType); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 381, stream, &_0, &_1, &clientFilename, &clientMediaType); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/http/message/uri.zep.c b/ext/phalcon/http/message/uri.zep.c index 1e5fdff358d..221f4840c88 100644 --- a/ext/phalcon/http/message/uri.zep.c +++ b/ext/phalcon/http/message/uri.zep.c @@ -293,9 +293,9 @@ PHP_METHOD(Phalcon_Http_Message_Uri, __construct) ZVAL_STRING(&_3$$3, "fragment"); ZEPHIR_INIT_VAR(&_4$$3); ZVAL_STRING(&_4$$3, ""); - ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "getarrval", NULL, 406, &urlParts, &_3$$3, &_4$$3); + ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "getarrval", NULL, 407, &urlParts, &_3$$3, &_4$$3); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "filterfragment", NULL, 407, &_2$$3); + ZEPHIR_CALL_METHOD(&_1$$3, this_ptr, "filterfragment", NULL, 408, &_2$$3); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("fragment"), &_1$$3); ZEPHIR_INIT_NVAR(&_3$$3); @@ -303,7 +303,7 @@ PHP_METHOD(Phalcon_Http_Message_Uri, __construct) ZVAL_STRING(&_4$$3, "host"); ZEPHIR_INIT_VAR(&_6$$3); ZVAL_STRING(&_6$$3, ""); - ZEPHIR_CALL_METHOD(&_5$$3, this_ptr, "getarrval", NULL, 406, &urlParts, &_4$$3, &_6$$3); + ZEPHIR_CALL_METHOD(&_5$$3, this_ptr, "getarrval", NULL, 407, &urlParts, &_4$$3, &_6$$3); zephir_check_call_status(); zephir_fast_strtolower(&_3$$3, &_5$$3); zephir_update_property_zval(this_ptr, ZEND_STRL("host"), &_3$$3); @@ -311,53 +311,53 @@ PHP_METHOD(Phalcon_Http_Message_Uri, __construct) ZVAL_STRING(&_4$$3, "pass"); ZEPHIR_INIT_NVAR(&_6$$3); ZVAL_STRING(&_6$$3, ""); - ZEPHIR_CALL_METHOD(&_7$$3, this_ptr, "getarrval", NULL, 406, &urlParts, &_4$$3, &_6$$3); + ZEPHIR_CALL_METHOD(&_7$$3, this_ptr, "getarrval", NULL, 407, &urlParts, &_4$$3, &_6$$3); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&_8$$3, "rawurlencode", NULL, 351, &_7$$3); + ZEPHIR_CALL_FUNCTION(&_8$$3, "rawurlencode", NULL, 352, &_7$$3); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("pass"), &_8$$3); ZEPHIR_INIT_NVAR(&_4$$3); ZVAL_STRING(&_4$$3, "path"); ZEPHIR_INIT_NVAR(&_6$$3); ZVAL_STRING(&_6$$3, ""); - ZEPHIR_CALL_METHOD(&_10$$3, this_ptr, "getarrval", NULL, 406, &urlParts, &_4$$3, &_6$$3); + ZEPHIR_CALL_METHOD(&_10$$3, this_ptr, "getarrval", NULL, 407, &urlParts, &_4$$3, &_6$$3); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_9$$3, this_ptr, "filterpath", NULL, 408, &_10$$3); + ZEPHIR_CALL_METHOD(&_9$$3, this_ptr, "filterpath", NULL, 409, &_10$$3); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("path"), &_9$$3); ZEPHIR_INIT_NVAR(&_4$$3); ZVAL_STRING(&_4$$3, "port"); ZVAL_NULL(&_13$$3); - ZEPHIR_CALL_METHOD(&_12$$3, this_ptr, "getarrval", NULL, 406, &urlParts, &_4$$3, &_13$$3); + ZEPHIR_CALL_METHOD(&_12$$3, this_ptr, "getarrval", NULL, 407, &urlParts, &_4$$3, &_13$$3); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_11$$3, this_ptr, "filterport", NULL, 409, &_12$$3); + ZEPHIR_CALL_METHOD(&_11$$3, this_ptr, "filterport", NULL, 410, &_12$$3); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("port"), &_11$$3); ZEPHIR_INIT_NVAR(&_4$$3); ZVAL_STRING(&_4$$3, "query"); ZEPHIR_INIT_NVAR(&_6$$3); ZVAL_STRING(&_6$$3, ""); - ZEPHIR_CALL_METHOD(&_15$$3, this_ptr, "getarrval", NULL, 406, &urlParts, &_4$$3, &_6$$3); + ZEPHIR_CALL_METHOD(&_15$$3, this_ptr, "getarrval", NULL, 407, &urlParts, &_4$$3, &_6$$3); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_14$$3, this_ptr, "filterquery", NULL, 410, &_15$$3); + ZEPHIR_CALL_METHOD(&_14$$3, this_ptr, "filterquery", NULL, 411, &_15$$3); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("query"), &_14$$3); ZEPHIR_INIT_NVAR(&_4$$3); ZVAL_STRING(&_4$$3, "scheme"); ZEPHIR_INIT_NVAR(&_6$$3); ZVAL_STRING(&_6$$3, ""); - ZEPHIR_CALL_METHOD(&_17$$3, this_ptr, "getarrval", NULL, 406, &urlParts, &_4$$3, &_6$$3); + ZEPHIR_CALL_METHOD(&_17$$3, this_ptr, "getarrval", NULL, 407, &urlParts, &_4$$3, &_6$$3); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_16$$3, this_ptr, "filterscheme", NULL, 411, &_17$$3); + ZEPHIR_CALL_METHOD(&_16$$3, this_ptr, "filterscheme", NULL, 412, &_17$$3); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("scheme"), &_16$$3); ZEPHIR_INIT_NVAR(&_4$$3); ZVAL_STRING(&_4$$3, "user"); ZEPHIR_INIT_NVAR(&_6$$3); ZVAL_STRING(&_6$$3, ""); - ZEPHIR_CALL_METHOD(&_18$$3, this_ptr, "getarrval", NULL, 406, &urlParts, &_4$$3, &_6$$3); + ZEPHIR_CALL_METHOD(&_18$$3, this_ptr, "getarrval", NULL, 407, &urlParts, &_4$$3, &_6$$3); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&_19$$3, "rawurlencode", NULL, 351, &_18$$3); + ZEPHIR_CALL_FUNCTION(&_19$$3, "rawurlencode", NULL, 352, &_18$$3); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("user"), &_19$$3); } @@ -401,7 +401,7 @@ PHP_METHOD(Phalcon_Http_Message_Uri, __toString) ZEPHIR_MM_GROW(); - ZEPHIR_CALL_METHOD(&authority, this_ptr, "getauthority", NULL, 412); + ZEPHIR_CALL_METHOD(&authority, this_ptr, "getauthority", NULL, 413); zephir_check_call_status(); zephir_read_property(&_0, this_ptr, ZEND_STRL("path"), PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&path, &_0); @@ -427,21 +427,21 @@ PHP_METHOD(Phalcon_Http_Message_Uri, __toString) ZVAL_STRING(&_7, ""); ZEPHIR_INIT_VAR(&_8); ZVAL_STRING(&_8, ":"); - ZEPHIR_CALL_METHOD(&_6, this_ptr, "checkvalue", NULL, 413, &_0, &_7, &_8); + ZEPHIR_CALL_METHOD(&_6, this_ptr, "checkvalue", NULL, 414, &_0, &_7, &_8); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_7); ZVAL_STRING(&_7, "//"); - ZEPHIR_CALL_METHOD(&_9, this_ptr, "checkvalue", NULL, 413, &authority, &_7); + ZEPHIR_CALL_METHOD(&_9, this_ptr, "checkvalue", NULL, 414, &authority, &_7); zephir_check_call_status(); zephir_read_property(&_11, this_ptr, ZEND_STRL("query"), PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_7); ZVAL_STRING(&_7, "?"); - ZEPHIR_CALL_METHOD(&_10, this_ptr, "checkvalue", NULL, 413, &_11, &_7); + ZEPHIR_CALL_METHOD(&_10, this_ptr, "checkvalue", NULL, 414, &_11, &_7); zephir_check_call_status(); zephir_read_property(&_13, this_ptr, ZEND_STRL("fragment"), PH_NOISY_CC | PH_READONLY); ZEPHIR_INIT_NVAR(&_7); ZVAL_STRING(&_7, "#"); - ZEPHIR_CALL_METHOD(&_12, this_ptr, "checkvalue", NULL, 413, &_13, &_7); + ZEPHIR_CALL_METHOD(&_12, this_ptr, "checkvalue", NULL, 414, &_13, &_7); zephir_check_call_status(); ZEPHIR_INIT_VAR(&uri); ZEPHIR_CONCAT_VVVVV(&uri, &_6, &_9, &path, &_10, &_12); @@ -481,7 +481,7 @@ PHP_METHOD(Phalcon_Http_Message_Uri, getAuthority) } ZEPHIR_OBS_VAR(&authority); zephir_read_property(&authority, this_ptr, ZEND_STRL("host"), PH_NOISY_CC); - ZEPHIR_CALL_METHOD(&userInfo, this_ptr, "getuserinfo", NULL, 414); + ZEPHIR_CALL_METHOD(&userInfo, this_ptr, "getuserinfo", NULL, 415); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, ""); @@ -579,7 +579,7 @@ PHP_METHOD(Phalcon_Http_Message_Uri, withFragment) ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkstringparameter", NULL, 20, fragment); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "filterfragment", NULL, 407, fragment); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "filterfragment", NULL, 408, fragment); zephir_check_call_status(); ZEPHIR_CPY_WRT(fragment, &_0); ZEPHIR_INIT_VAR(&_1); @@ -658,7 +658,7 @@ PHP_METHOD(Phalcon_Http_Message_Uri, withPath) ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_message_exception_invalidargumentexception_ce, "Path cannot contain a query string or fragment", "phalcon/Http/Message/Uri.zep", 288); return; } - ZEPHIR_CALL_METHOD(&_5, this_ptr, "filterpath", NULL, 408, path); + ZEPHIR_CALL_METHOD(&_5, this_ptr, "filterpath", NULL, 409, path); zephir_check_call_status(); ZEPHIR_CPY_WRT(path, &_5); ZEPHIR_INIT_VAR(&_6); @@ -710,7 +710,7 @@ PHP_METHOD(Phalcon_Http_Message_Uri, withPort) if (UNEXPECTED(Z_TYPE_P(port) != IS_NULL)) { - ZEPHIR_CALL_METHOD(&_0$$3, this_ptr, "filterport", NULL, 409, port); + ZEPHIR_CALL_METHOD(&_0$$3, this_ptr, "filterport", NULL, 410, port); zephir_check_call_status(); ZEPHIR_CPY_WRT(port, &_0$$3); _1$$3 = Z_TYPE_P(port) != IS_NULL; @@ -784,7 +784,7 @@ PHP_METHOD(Phalcon_Http_Message_Uri, withQuery) ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_message_exception_invalidargumentexception_ce, "Query cannot contain a query fragment", "phalcon/Http/Message/Uri.zep", 351); return; } - ZEPHIR_CALL_METHOD(&_2, this_ptr, "filterquery", NULL, 410, query); + ZEPHIR_CALL_METHOD(&_2, this_ptr, "filterquery", NULL, 411, query); zephir_check_call_status(); ZEPHIR_CPY_WRT(query, &_2); ZEPHIR_INIT_VAR(&_3); @@ -836,12 +836,12 @@ PHP_METHOD(Phalcon_Http_Message_Uri, withScheme) ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkstringparameter", NULL, 20, scheme); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "filterscheme", NULL, 411, scheme); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "filterscheme", NULL, 412, scheme); zephir_check_call_status(); ZEPHIR_CPY_WRT(scheme, &_0); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "scheme"); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processwith", NULL, 415, scheme, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processwith", NULL, 416, scheme, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -895,11 +895,11 @@ PHP_METHOD(Phalcon_Http_Message_Uri, withUserInfo) ZEPHIR_CALL_METHOD(NULL, this_ptr, "checkstringparameter", NULL, 20, user); zephir_check_call_status(); } - ZEPHIR_CALL_FUNCTION(&_0, "rawurlencode", NULL, 351, user); + ZEPHIR_CALL_FUNCTION(&_0, "rawurlencode", NULL, 352, user); zephir_check_call_status(); ZEPHIR_CPY_WRT(user, &_0); if (UNEXPECTED(Z_TYPE_P(password) != IS_NULL)) { - ZEPHIR_CALL_FUNCTION(&_1$$4, "rawurlencode", NULL, 351, password); + ZEPHIR_CALL_FUNCTION(&_1$$4, "rawurlencode", NULL, 352, password); zephir_check_call_status(); ZEPHIR_CPY_WRT(password, &_1$$4); } @@ -948,7 +948,7 @@ PHP_METHOD(Phalcon_Http_Message_Uri, withHost) ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "host"); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processwith", NULL, 415, host, &_0); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "processwith", NULL, 416, host, &_0); zephir_check_call_status(); RETURN_MM(); } @@ -1084,7 +1084,7 @@ PHP_METHOD(Phalcon_Http_Message_Uri, filterFragment) } - ZEPHIR_RETURN_CALL_FUNCTION("rawurlencode", NULL, 351, &fragment); + ZEPHIR_RETURN_CALL_FUNCTION("rawurlencode", NULL, 352, &fragment); zephir_check_call_status(); RETURN_MM(); } @@ -1182,7 +1182,7 @@ PHP_METHOD(Phalcon_Http_Message_Uri, filterPath) } ZEPHIR_INIT_NVAR(&element); ZVAL_COPY(&element, _2); - ZEPHIR_CALL_FUNCTION(&_6$$4, "rawurlencode", &_7, 351, &element); + ZEPHIR_CALL_FUNCTION(&_6$$4, "rawurlencode", &_7, 352, &element); zephir_check_call_status(); zephir_array_update_zval(&parts, &key, &_6$$4, PH_COPY | PH_SEPARATE); } ZEND_HASH_FOREACH_END(); @@ -1199,7 +1199,7 @@ PHP_METHOD(Phalcon_Http_Message_Uri, filterPath) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&element, &parts, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&_8$$5, "rawurlencode", &_7, 351, &element); + ZEPHIR_CALL_FUNCTION(&_8$$5, "rawurlencode", &_7, 352, &element); zephir_check_call_status(); zephir_array_update_zval(&parts, &key, &_8$$5, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(NULL, &parts, "next", NULL, 0); @@ -1359,21 +1359,21 @@ PHP_METHOD(Phalcon_Http_Message_Uri, filterQuery) } ZEPHIR_INIT_NVAR(&part); ZVAL_COPY(&part, _3); - ZEPHIR_CALL_METHOD(&split, this_ptr, "splitqueryvalue", &_7, 416, &part); + ZEPHIR_CALL_METHOD(&split, this_ptr, "splitqueryvalue", &_7, 417, &part); zephir_check_call_status(); zephir_array_fetch_long(&_8$$4, &split, 1, PH_NOISY | PH_READONLY, "phalcon/Http/Message/Uri.zep", 587); if (UNEXPECTED(Z_TYPE_P(&_8$$4) == IS_NULL)) { zephir_array_fetch_long(&_9$$5, &split, 0, PH_NOISY | PH_READONLY, "phalcon/Http/Message/Uri.zep", 588); - ZEPHIR_CALL_FUNCTION(&_10$$5, "rawurlencode", &_11, 351, &_9$$5); + ZEPHIR_CALL_FUNCTION(&_10$$5, "rawurlencode", &_11, 352, &_9$$5); zephir_check_call_status(); zephir_array_update_zval(&parts, &index, &_10$$5, PH_COPY | PH_SEPARATE); continue; } zephir_array_fetch_long(&_12$$4, &split, 0, PH_NOISY | PH_READONLY, "phalcon/Http/Message/Uri.zep", 592); - ZEPHIR_CALL_FUNCTION(&_13$$4, "rawurlencode", &_11, 351, &_12$$4); + ZEPHIR_CALL_FUNCTION(&_13$$4, "rawurlencode", &_11, 352, &_12$$4); zephir_check_call_status(); zephir_array_fetch_long(&_14$$4, &split, 1, PH_NOISY | PH_READONLY, "phalcon/Http/Message/Uri.zep", 592); - ZEPHIR_CALL_FUNCTION(&_15$$4, "rawurlencode", &_11, 351, &_14$$4); + ZEPHIR_CALL_FUNCTION(&_15$$4, "rawurlencode", &_11, 352, &_14$$4); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_16$$4); ZEPHIR_CONCAT_VSV(&_16$$4, &_13$$4, "=", &_15$$4); @@ -1392,21 +1392,21 @@ PHP_METHOD(Phalcon_Http_Message_Uri, filterQuery) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&part, &parts, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(&split, this_ptr, "splitqueryvalue", &_7, 416, &part); + ZEPHIR_CALL_METHOD(&split, this_ptr, "splitqueryvalue", &_7, 417, &part); zephir_check_call_status(); zephir_array_fetch_long(&_17$$6, &split, 1, PH_NOISY | PH_READONLY, "phalcon/Http/Message/Uri.zep", 587); if (UNEXPECTED(Z_TYPE_P(&_17$$6) == IS_NULL)) { zephir_array_fetch_long(&_18$$7, &split, 0, PH_NOISY | PH_READONLY, "phalcon/Http/Message/Uri.zep", 588); - ZEPHIR_CALL_FUNCTION(&_19$$7, "rawurlencode", &_11, 351, &_18$$7); + ZEPHIR_CALL_FUNCTION(&_19$$7, "rawurlencode", &_11, 352, &_18$$7); zephir_check_call_status(); zephir_array_update_zval(&parts, &index, &_19$$7, PH_COPY | PH_SEPARATE); continue; } zephir_array_fetch_long(&_20$$6, &split, 0, PH_NOISY | PH_READONLY, "phalcon/Http/Message/Uri.zep", 592); - ZEPHIR_CALL_FUNCTION(&_21$$6, "rawurlencode", &_11, 351, &_20$$6); + ZEPHIR_CALL_FUNCTION(&_21$$6, "rawurlencode", &_11, 352, &_20$$6); zephir_check_call_status(); zephir_array_fetch_long(&_22$$6, &split, 1, PH_NOISY | PH_READONLY, "phalcon/Http/Message/Uri.zep", 592); - ZEPHIR_CALL_FUNCTION(&_23$$6, "rawurlencode", &_11, 351, &_22$$6); + ZEPHIR_CALL_FUNCTION(&_23$$6, "rawurlencode", &_11, 352, &_22$$6); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_24$$6); ZEPHIR_CONCAT_VSV(&_24$$6, &_21$$6, "=", &_23$$6); diff --git a/ext/phalcon/http/message/urifactory.zep.c b/ext/phalcon/http/message/urifactory.zep.c index a944ce204a3..d9ff60152d2 100644 --- a/ext/phalcon/http/message/urifactory.zep.c +++ b/ext/phalcon/http/message/urifactory.zep.c @@ -84,7 +84,7 @@ PHP_METHOD(Phalcon_Http_Message_UriFactory, createUri) object_init_ex(return_value, phalcon_http_message_uri_ce); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 114, &uri); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 116, &uri); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/http/request.zep.c b/ext/phalcon/http/request.zep.c index 449c6eceb80..055b93a1728 100644 --- a/ext/phalcon/http/request.zep.c +++ b/ext/phalcon/http/request.zep.c @@ -221,7 +221,7 @@ PHP_METHOD(Phalcon_Http_Request, get) } else { ZVAL_BOOL(&_1, 0); } - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "gethelper", NULL, 417, &_REQUEST, &name, filters, defaultValue, &_0, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "gethelper", NULL, 418, &_REQUEST, &name, filters, defaultValue, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -247,7 +247,7 @@ PHP_METHOD(Phalcon_Http_Request, getAcceptableContent) ZVAL_STRING(&_0, "HTTP_ACCEPT"); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "accept"); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getqualityheader", NULL, 418, &_0, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getqualityheader", NULL, 419, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -274,13 +274,13 @@ PHP_METHOD(Phalcon_Http_Request, getBasicAuth) ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "PHP_AUTH_USER"); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "hasserver", NULL, 419, &_1); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "hasserver", NULL, 420, &_1); zephir_check_call_status(); _2 = !zephir_is_true(&_0); if (!(_2)) { ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "PHP_AUTH_PW"); - ZEPHIR_CALL_METHOD(&_3, this_ptr, "hasserver", NULL, 419, &_1); + ZEPHIR_CALL_METHOD(&_3, this_ptr, "hasserver", NULL, 420, &_1); zephir_check_call_status(); _2 = !zephir_is_true(&_3); } @@ -322,7 +322,7 @@ PHP_METHOD(Phalcon_Http_Request, getBestAccept) zephir_check_call_status(); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "accept"); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getbestquality", NULL, 420, &_0, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getbestquality", NULL, 421, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -348,7 +348,7 @@ PHP_METHOD(Phalcon_Http_Request, getBestCharset) zephir_check_call_status(); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "charset"); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getbestquality", NULL, 420, &_0, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getbestquality", NULL, 421, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -374,7 +374,7 @@ PHP_METHOD(Phalcon_Http_Request, getBestLanguage) zephir_check_call_status(); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "language"); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getbestquality", NULL, 420, &_0, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getbestquality", NULL, 421, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -463,7 +463,7 @@ PHP_METHOD(Phalcon_Http_Request, getClientAddress) ZEPHIR_INIT_VAR(&address); ZVAL_NULL(&address); - ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 421); + ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 422); zephir_check_call_status(); if (trustForwardedHeader) { ZEPHIR_OBS_NVAR(&address); @@ -510,7 +510,7 @@ PHP_METHOD(Phalcon_Http_Request, getClientCharsets) ZVAL_STRING(&_0, "HTTP_ACCEPT_CHARSET"); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "charset"); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getqualityheader", NULL, 418, &_0, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getqualityheader", NULL, 419, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -531,7 +531,7 @@ PHP_METHOD(Phalcon_Http_Request, getContentType) ZEPHIR_MM_GROW(); - ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 421); + ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 422); zephir_check_call_status(); if (!(zephir_array_isset_string_fetch(&contentType, &server, SL("CONTENT_TYPE"), 1))) { RETURN_MM_NULL(); @@ -570,7 +570,7 @@ PHP_METHOD(Phalcon_Http_Request, getDigestAuth) ZEPHIR_INIT_VAR(&auth); array_init(&auth); - ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 421); + ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 422); zephir_check_call_status(); ZEPHIR_OBS_VAR(&digest); if (zephir_array_isset_string_fetch(&digest, &server, SL("PHP_AUTH_DIGEST"), 0)) { @@ -925,7 +925,7 @@ PHP_METHOD(Phalcon_Http_Request, getHeader) zephir_check_call_status(); ZEPHIR_INIT_VAR(&name); zephir_fast_strtoupper(&name, &_2); - ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 421); + ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 422); zephir_check_call_status(); ZEPHIR_OBS_VAR(&value); if (zephir_array_isset_fetch(&value, &server, &name, 0)) { @@ -1019,7 +1019,7 @@ PHP_METHOD(Phalcon_Http_Request, getHeaders) zephir_array_update_string(&contentHeaders, SL("CONTENT_TYPE"), &__$true, PH_COPY | PH_SEPARATE); zephir_array_update_string(&contentHeaders, SL("CONTENT_LENGTH"), &__$true, PH_COPY | PH_SEPARATE); zephir_array_update_string(&contentHeaders, SL("CONTENT_MD5"), &__$true, PH_COPY | PH_SEPARATE); - ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 421); + ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 422); zephir_check_call_status(); zephir_is_iterable(&server, 0, "phalcon/Http/Request.zep", 441); if (Z_TYPE_P(&server) == IS_ARRAY) { @@ -1045,7 +1045,7 @@ PHP_METHOD(Phalcon_Http_Request, getHeaders) ZVAL_STRING(&_9$$4, " "); zephir_fast_str_replace(&_5$$4, &_8$$4, &_9$$4, &_7$$4); zephir_fast_strtolower(&_4$$4, &_5$$4); - ZEPHIR_CALL_FUNCTION(&name, "ucwords", &_10, 308, &_4$$4); + ZEPHIR_CALL_FUNCTION(&name, "ucwords", &_10, 309, &_4$$4); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_11$$4); ZEPHIR_INIT_NVAR(&_12$$4); @@ -1069,7 +1069,7 @@ PHP_METHOD(Phalcon_Http_Request, getHeaders) ZVAL_STRING(&_18$$5, " "); zephir_fast_str_replace(&_16$$5, &_17$$5, &_18$$5, &name); zephir_fast_strtolower(&_15$$5, &_16$$5); - ZEPHIR_CALL_FUNCTION(&name, "ucwords", &_10, 308, &_15$$5); + ZEPHIR_CALL_FUNCTION(&name, "ucwords", &_10, 309, &_15$$5); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_19$$5); ZEPHIR_INIT_NVAR(&_20$$5); @@ -1106,7 +1106,7 @@ PHP_METHOD(Phalcon_Http_Request, getHeaders) ZVAL_STRING(&_27$$7, " "); zephir_fast_str_replace(&_23$$7, &_26$$7, &_27$$7, &_25$$7); zephir_fast_strtolower(&_22$$7, &_23$$7); - ZEPHIR_CALL_FUNCTION(&name, "ucwords", &_10, 308, &_22$$7); + ZEPHIR_CALL_FUNCTION(&name, "ucwords", &_10, 309, &_22$$7); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_28$$7); ZEPHIR_INIT_NVAR(&_29$$7); @@ -1130,7 +1130,7 @@ PHP_METHOD(Phalcon_Http_Request, getHeaders) ZVAL_STRING(&_35$$8, " "); zephir_fast_str_replace(&_33$$8, &_34$$8, &_35$$8, &name); zephir_fast_strtolower(&_32$$8, &_33$$8); - ZEPHIR_CALL_FUNCTION(&name, "ucwords", &_10, 308, &_32$$8); + ZEPHIR_CALL_FUNCTION(&name, "ucwords", &_10, 309, &_32$$8); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_36$$8); ZEPHIR_INIT_NVAR(&_37$$8); @@ -1268,7 +1268,7 @@ PHP_METHOD(Phalcon_Http_Request, getHttpHost) object_init_ex(&_12$$7, spl_ce_UnexpectedValueException); ZEPHIR_INIT_VAR(&_13$$7); ZEPHIR_CONCAT_SV(&_13$$7, "Invalid host ", &host); - ZEPHIR_CALL_METHOD(NULL, &_12$$7, "__construct", NULL, 422, &_13$$7); + ZEPHIR_CALL_METHOD(NULL, &_12$$7, "__construct", NULL, 423, &_13$$7); zephir_check_call_status(); zephir_throw_exception_debug(&_12$$7, "phalcon/Http/Request.zep", 525); ZEPHIR_MM_RESTORE(); @@ -1297,7 +1297,7 @@ PHP_METHOD(Phalcon_Http_Request, getHTTPReferer) ZEPHIR_MM_GROW(); - ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 421); + ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 422); zephir_check_call_status(); if (!(zephir_array_isset_string_fetch(&httpReferer, &server, SL("HTTP_REFERER"), 1))) { RETURN_MM_STRING(""); @@ -1367,7 +1367,7 @@ PHP_METHOD(Phalcon_Http_Request, getLanguages) ZVAL_STRING(&_0, "HTTP_ACCEPT_LANGUAGE"); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "language"); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getqualityheader", NULL, 418, &_0, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getqualityheader", NULL, 419, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -1407,7 +1407,7 @@ PHP_METHOD(Phalcon_Http_Request, getMethod) zephir_get_global(&_REQUEST, SL("_REQUEST")); ZEPHIR_INIT_VAR(&returnMethod); - ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 421); + ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 422); zephir_check_call_status(); ZEPHIR_OBS_VAR(&requestMethod); if (EXPECTED(zephir_array_isset_string_fetch(&requestMethod, &server, SL("REQUEST_METHOD"), 0))) { @@ -1421,7 +1421,7 @@ PHP_METHOD(Phalcon_Http_Request, getMethod) if (ZEPHIR_IS_IDENTICAL(&_0, &returnMethod)) { ZEPHIR_INIT_VAR(&_1$$5); ZVAL_STRING(&_1$$5, "X-HTTP-METHOD-OVERRIDE"); - ZEPHIR_CALL_METHOD(&overridedMethod, this_ptr, "getheader", NULL, 423, &_1$$5); + ZEPHIR_CALL_METHOD(&overridedMethod, this_ptr, "getheader", NULL, 424, &_1$$5); zephir_check_call_status(); zephir_read_property(&_2$$5, this_ptr, ZEND_STRL("httpMethodParameterOverride"), PH_NOISY_CC | PH_READONLY); if (!(ZEPHIR_IS_EMPTY(&overridedMethod))) { @@ -1481,7 +1481,7 @@ PHP_METHOD(Phalcon_Http_Request, getPort) if (zephir_memnstr_str(&host, SL(":"), "phalcon/Http/Request.zep", 634)) { ZEPHIR_INIT_VAR(&_3$$4); ZVAL_STRING(&_3$$4, ":"); - ZEPHIR_CALL_FUNCTION(&pos, "strrpos", NULL, 124, &host, &_3$$4); + ZEPHIR_CALL_FUNCTION(&pos, "strrpos", NULL, 262, &host, &_3$$4); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&pos)) { ZVAL_LONG(&_4$$5, (zephir_get_numberval(&pos) + 1)); @@ -1590,7 +1590,7 @@ PHP_METHOD(Phalcon_Http_Request, getPost) } else { ZVAL_BOOL(&_1, 0); } - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "gethelper", NULL, 417, &_POST, &name, filters, defaultValue, &_0, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "gethelper", NULL, 418, &_POST, &name, filters, defaultValue, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -1684,7 +1684,7 @@ PHP_METHOD(Phalcon_Http_Request, getPut) if (_0$$3) { ZEPHIR_INIT_VAR(&_1$$3); ZVAL_STRING(&_1$$3, "json"); - ZEPHIR_CALL_FUNCTION(&_2$$3, "stripos", NULL, 424, &contentType, &_1$$3); + ZEPHIR_CALL_FUNCTION(&_2$$3, "stripos", NULL, 425, &contentType, &_1$$3); zephir_check_call_status(); _0$$3 = !ZEPHIR_IS_FALSE(&_2$$3); } @@ -1702,7 +1702,7 @@ PHP_METHOD(Phalcon_Http_Request, getPut) ZEPHIR_CALL_METHOD(&_4$$6, this_ptr, "getrawbody", NULL, 0); zephir_check_call_status(); ZEPHIR_MAKE_REF(&put); - ZEPHIR_CALL_FUNCTION(NULL, "parse_str", NULL, 381, &_4$$6, &put); + ZEPHIR_CALL_FUNCTION(NULL, "parse_str", NULL, 382, &_4$$6, &put); ZEPHIR_UNREF(&put); zephir_check_call_status(); } @@ -1718,7 +1718,7 @@ PHP_METHOD(Phalcon_Http_Request, getPut) } else { ZVAL_BOOL(&_6, 0); } - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "gethelper", NULL, 417, &put, &name, filters, defaultValue, &_5, &_6); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "gethelper", NULL, 418, &put, &name, filters, defaultValue, &_5, &_6); zephir_check_call_status(); RETURN_MM(); } @@ -1813,7 +1813,7 @@ PHP_METHOD(Phalcon_Http_Request, getQuery) } else { ZVAL_BOOL(&_1, 0); } - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "gethelper", NULL, 417, &_GET, &name, filters, defaultValue, &_0, &_1); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "gethelper", NULL, 418, &_GET, &name, filters, defaultValue, &_0, &_1); zephir_check_call_status(); RETURN_MM(); } @@ -1914,7 +1914,7 @@ PHP_METHOD(Phalcon_Http_Request, getServer) } - ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 421); + ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 422); zephir_check_call_status(); if (!(zephir_array_isset_fetch(&serverValue, &server, &name, 1))) { RETURN_MM_NULL(); @@ -1946,7 +1946,7 @@ PHP_METHOD(Phalcon_Http_Request, getServerAddress) if (Z_TYPE_P(&serverAddr) == IS_NULL) { ZEPHIR_INIT_VAR(&_1$$3); ZVAL_STRING(&_1$$3, "localhost"); - ZEPHIR_RETURN_CALL_FUNCTION("gethostbyname", NULL, 425, &_1$$3); + ZEPHIR_RETURN_CALL_FUNCTION("gethostbyname", NULL, 426, &_1$$3); zephir_check_call_status(); RETURN_MM(); } @@ -2103,7 +2103,7 @@ PHP_METHOD(Phalcon_Http_Request, getUploadedFiles) zephir_array_fetch_string(&_7$$5, &input, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 861); zephir_array_fetch_string(&_8$$5, &input, SL("size"), PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 862); zephir_array_fetch_string(&_9$$5, &input, SL("error"), PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 863); - ZEPHIR_CALL_METHOD(&smoothInput, this_ptr, "smoothfiles", &_10, 426, &_5$$5, &_6$$5, &_7$$5, &_8$$5, &_9$$5, &prefix); + ZEPHIR_CALL_METHOD(&smoothInput, this_ptr, "smoothfiles", &_10, 427, &_5$$5, &_6$$5, &_7$$5, &_8$$5, &_9$$5, &prefix); zephir_check_call_status(); zephir_is_iterable(&smoothInput, 0, "phalcon/Http/Request.zep", 890); if (Z_TYPE_P(&smoothInput) == IS_ARRAY) { @@ -2138,7 +2138,7 @@ PHP_METHOD(Phalcon_Http_Request, getUploadedFiles) ZEPHIR_INIT_NVAR(&_16$$8); object_init_ex(&_16$$8, phalcon_http_request_file_ce); zephir_array_fetch_string(&_17$$8, &file, SL("key"), PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 881); - ZEPHIR_CALL_METHOD(NULL, &_16$$8, "__construct", &_18, 427, &dataFile, &_17$$8); + ZEPHIR_CALL_METHOD(NULL, &_16$$8, "__construct", &_18, 428, &dataFile, &_17$$8); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&_19$$8); zephir_array_fetch_string(&_19$$8, &file, SL("key"), PH_NOISY, "phalcon/Http/Request.zep", 878); @@ -2147,7 +2147,7 @@ PHP_METHOD(Phalcon_Http_Request, getUploadedFiles) ZEPHIR_INIT_NVAR(&_20$$9); object_init_ex(&_20$$9, phalcon_http_request_file_ce); zephir_array_fetch_string(&_21$$9, &file, SL("key"), PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 886); - ZEPHIR_CALL_METHOD(NULL, &_20$$9, "__construct", &_18, 427, &dataFile, &_21$$9); + ZEPHIR_CALL_METHOD(NULL, &_20$$9, "__construct", &_18, 428, &dataFile, &_21$$9); zephir_check_call_status(); zephir_array_append(&files, &_20$$9, PH_SEPARATE, "phalcon/Http/Request.zep", 886); } @@ -2192,7 +2192,7 @@ PHP_METHOD(Phalcon_Http_Request, getUploadedFiles) ZEPHIR_INIT_NVAR(&_26$$12); object_init_ex(&_26$$12, phalcon_http_request_file_ce); zephir_array_fetch_string(&_27$$12, &file, SL("key"), PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 881); - ZEPHIR_CALL_METHOD(NULL, &_26$$12, "__construct", &_18, 427, &dataFile, &_27$$12); + ZEPHIR_CALL_METHOD(NULL, &_26$$12, "__construct", &_18, 428, &dataFile, &_27$$12); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&_28$$12); zephir_array_fetch_string(&_28$$12, &file, SL("key"), PH_NOISY, "phalcon/Http/Request.zep", 878); @@ -2201,7 +2201,7 @@ PHP_METHOD(Phalcon_Http_Request, getUploadedFiles) ZEPHIR_INIT_NVAR(&_29$$13); object_init_ex(&_29$$13, phalcon_http_request_file_ce); zephir_array_fetch_string(&_30$$13, &file, SL("key"), PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 886); - ZEPHIR_CALL_METHOD(NULL, &_29$$13, "__construct", &_18, 427, &dataFile, &_30$$13); + ZEPHIR_CALL_METHOD(NULL, &_29$$13, "__construct", &_18, 428, &dataFile, &_30$$13); zephir_check_call_status(); zephir_array_append(&files, &_29$$13, PH_SEPARATE, "phalcon/Http/Request.zep", 886); } @@ -2221,13 +2221,13 @@ PHP_METHOD(Phalcon_Http_Request, getUploadedFiles) if (namedKeys == 1) { ZEPHIR_INIT_NVAR(&_33$$16); object_init_ex(&_33$$16, phalcon_http_request_file_ce); - ZEPHIR_CALL_METHOD(NULL, &_33$$16, "__construct", &_18, 427, &input, &prefix); + ZEPHIR_CALL_METHOD(NULL, &_33$$16, "__construct", &_18, 428, &input, &prefix); zephir_check_call_status(); zephir_array_update_zval(&files, &prefix, &_33$$16, PH_COPY | PH_SEPARATE); } else { ZEPHIR_INIT_NVAR(&_34$$17); object_init_ex(&_34$$17, phalcon_http_request_file_ce); - ZEPHIR_CALL_METHOD(NULL, &_34$$17, "__construct", &_18, 427, &input, &prefix); + ZEPHIR_CALL_METHOD(NULL, &_34$$17, "__construct", &_18, 428, &input, &prefix); zephir_check_call_status(); zephir_array_append(&files, &_34$$17, PH_SEPARATE, "phalcon/Http/Request.zep", 895); } @@ -2255,7 +2255,7 @@ PHP_METHOD(Phalcon_Http_Request, getUploadedFiles) zephir_array_fetch_string(&_38$$19, &input, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 861); zephir_array_fetch_string(&_39$$19, &input, SL("size"), PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 862); zephir_array_fetch_string(&_40$$19, &input, SL("error"), PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 863); - ZEPHIR_CALL_METHOD(&smoothInput, this_ptr, "smoothfiles", &_10, 426, &_36$$19, &_37$$19, &_38$$19, &_39$$19, &_40$$19, &prefix); + ZEPHIR_CALL_METHOD(&smoothInput, this_ptr, "smoothfiles", &_10, 427, &_36$$19, &_37$$19, &_38$$19, &_39$$19, &_40$$19, &prefix); zephir_check_call_status(); zephir_is_iterable(&smoothInput, 0, "phalcon/Http/Request.zep", 890); if (Z_TYPE_P(&smoothInput) == IS_ARRAY) { @@ -2291,7 +2291,7 @@ PHP_METHOD(Phalcon_Http_Request, getUploadedFiles) ZEPHIR_INIT_NVAR(&_47$$22); object_init_ex(&_47$$22, phalcon_http_request_file_ce); zephir_array_fetch_string(&_48$$22, &file, SL("key"), PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 881); - ZEPHIR_CALL_METHOD(NULL, &_47$$22, "__construct", &_18, 427, &dataFile, &_48$$22); + ZEPHIR_CALL_METHOD(NULL, &_47$$22, "__construct", &_18, 428, &dataFile, &_48$$22); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&_49$$22); zephir_array_fetch_string(&_49$$22, &file, SL("key"), PH_NOISY, "phalcon/Http/Request.zep", 878); @@ -2300,7 +2300,7 @@ PHP_METHOD(Phalcon_Http_Request, getUploadedFiles) ZEPHIR_INIT_NVAR(&_50$$23); object_init_ex(&_50$$23, phalcon_http_request_file_ce); zephir_array_fetch_string(&_51$$23, &file, SL("key"), PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 886); - ZEPHIR_CALL_METHOD(NULL, &_50$$23, "__construct", &_18, 427, &dataFile, &_51$$23); + ZEPHIR_CALL_METHOD(NULL, &_50$$23, "__construct", &_18, 428, &dataFile, &_51$$23); zephir_check_call_status(); zephir_array_append(&files, &_50$$23, PH_SEPARATE, "phalcon/Http/Request.zep", 886); } @@ -2345,7 +2345,7 @@ PHP_METHOD(Phalcon_Http_Request, getUploadedFiles) ZEPHIR_INIT_NVAR(&_56$$26); object_init_ex(&_56$$26, phalcon_http_request_file_ce); zephir_array_fetch_string(&_57$$26, &file, SL("key"), PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 881); - ZEPHIR_CALL_METHOD(NULL, &_56$$26, "__construct", &_18, 427, &dataFile, &_57$$26); + ZEPHIR_CALL_METHOD(NULL, &_56$$26, "__construct", &_18, 428, &dataFile, &_57$$26); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&_58$$26); zephir_array_fetch_string(&_58$$26, &file, SL("key"), PH_NOISY, "phalcon/Http/Request.zep", 878); @@ -2354,7 +2354,7 @@ PHP_METHOD(Phalcon_Http_Request, getUploadedFiles) ZEPHIR_INIT_NVAR(&_59$$27); object_init_ex(&_59$$27, phalcon_http_request_file_ce); zephir_array_fetch_string(&_60$$27, &file, SL("key"), PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 886); - ZEPHIR_CALL_METHOD(NULL, &_59$$27, "__construct", &_18, 427, &dataFile, &_60$$27); + ZEPHIR_CALL_METHOD(NULL, &_59$$27, "__construct", &_18, 428, &dataFile, &_60$$27); zephir_check_call_status(); zephir_array_append(&files, &_59$$27, PH_SEPARATE, "phalcon/Http/Request.zep", 886); } @@ -2374,13 +2374,13 @@ PHP_METHOD(Phalcon_Http_Request, getUploadedFiles) if (namedKeys == 1) { ZEPHIR_INIT_NVAR(&_63$$30); object_init_ex(&_63$$30, phalcon_http_request_file_ce); - ZEPHIR_CALL_METHOD(NULL, &_63$$30, "__construct", &_18, 427, &input, &prefix); + ZEPHIR_CALL_METHOD(NULL, &_63$$30, "__construct", &_18, 428, &input, &prefix); zephir_check_call_status(); zephir_array_update_zval(&files, &prefix, &_63$$30, PH_COPY | PH_SEPARATE); } else { ZEPHIR_INIT_NVAR(&_64$$31); object_init_ex(&_64$$31, phalcon_http_request_file_ce); - ZEPHIR_CALL_METHOD(NULL, &_64$$31, "__construct", &_18, 427, &input, &prefix); + ZEPHIR_CALL_METHOD(NULL, &_64$$31, "__construct", &_18, 428, &input, &prefix); zephir_check_call_status(); zephir_array_append(&files, &_64$$31, PH_SEPARATE, "phalcon/Http/Request.zep", 895); } @@ -2593,13 +2593,13 @@ PHP_METHOD(Phalcon_Http_Request, hasHeader) zephir_check_call_status(); ZEPHIR_INIT_VAR(&name); zephir_fast_strtoupper(&name, &_2); - ZEPHIR_CALL_METHOD(&_3, this_ptr, "hasserver", NULL, 419, &name); + ZEPHIR_CALL_METHOD(&_3, this_ptr, "hasserver", NULL, 420, &name); zephir_check_call_status(); _4 = zephir_is_true(&_3); if (!(_4)) { ZEPHIR_INIT_VAR(&_6); ZEPHIR_CONCAT_SV(&_6, "HTTP_", &name); - ZEPHIR_CALL_METHOD(&_5, this_ptr, "hasserver", NULL, 419, &_6); + ZEPHIR_CALL_METHOD(&_5, this_ptr, "hasserver", NULL, 420, &_6); zephir_check_call_status(); _4 = zephir_is_true(&_5); } @@ -2753,7 +2753,7 @@ PHP_METHOD(Phalcon_Http_Request, hasServer) } - ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 421); + ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 422); zephir_check_call_status(); RETURN_MM_BOOL(zephir_array_isset(&server, &name)); } @@ -2778,7 +2778,7 @@ PHP_METHOD(Phalcon_Http_Request, isAjax) ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "HTTP_X_REQUESTED_WITH"); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "hasserver", NULL, 419, &_1); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "hasserver", NULL, 420, &_1); zephir_check_call_status(); _2 = zephir_is_true(&_0); if (_2) { @@ -2807,7 +2807,7 @@ PHP_METHOD(Phalcon_Http_Request, isConnect) ZEPHIR_MM_GROW(); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 428); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 429); zephir_check_call_status(); RETURN_MM_BOOL(ZEPHIR_IS_STRING_IDENTICAL(&_0, "CONNECT")); } @@ -2828,7 +2828,7 @@ PHP_METHOD(Phalcon_Http_Request, isDelete) ZEPHIR_MM_GROW(); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 428); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 429); zephir_check_call_status(); RETURN_MM_BOOL(ZEPHIR_IS_STRING_IDENTICAL(&_0, "DELETE")); } @@ -2849,7 +2849,7 @@ PHP_METHOD(Phalcon_Http_Request, isGet) ZEPHIR_MM_GROW(); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 428); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 429); zephir_check_call_status(); RETURN_MM_BOOL(ZEPHIR_IS_STRING_IDENTICAL(&_0, "GET")); } @@ -2870,7 +2870,7 @@ PHP_METHOD(Phalcon_Http_Request, isHead) ZEPHIR_MM_GROW(); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 428); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 429); zephir_check_call_status(); RETURN_MM_BOOL(ZEPHIR_IS_STRING_IDENTICAL(&_0, "HEAD")); } @@ -2918,7 +2918,7 @@ PHP_METHOD(Phalcon_Http_Request, isMethod) } - ZEPHIR_CALL_METHOD(&httpMethod, this_ptr, "getmethod", NULL, 428); + ZEPHIR_CALL_METHOD(&httpMethod, this_ptr, "getmethod", NULL, 429); zephir_check_call_status(); if (Z_TYPE_P(methods) == IS_STRING) { _0$$3 = strict; @@ -2952,7 +2952,7 @@ PHP_METHOD(Phalcon_Http_Request, isMethod) } else { ZVAL_BOOL(&_7$$6, 0); } - ZEPHIR_CALL_METHOD(&_6$$6, this_ptr, "ismethod", &_8, 429, &method, &_7$$6); + ZEPHIR_CALL_METHOD(&_6$$6, this_ptr, "ismethod", &_8, 430, &method, &_7$$6); zephir_check_call_status(); if (zephir_is_true(&_6$$6)) { RETURN_MM_BOOL(1); @@ -2974,7 +2974,7 @@ PHP_METHOD(Phalcon_Http_Request, isMethod) } else { ZVAL_BOOL(&_10$$8, 0); } - ZEPHIR_CALL_METHOD(&_9$$8, this_ptr, "ismethod", &_8, 429, &method, &_10$$8); + ZEPHIR_CALL_METHOD(&_9$$8, this_ptr, "ismethod", &_8, 430, &method, &_10$$8); zephir_check_call_status(); if (zephir_is_true(&_9$$8)) { RETURN_MM_BOOL(1); @@ -3009,7 +3009,7 @@ PHP_METHOD(Phalcon_Http_Request, isOptions) ZEPHIR_MM_GROW(); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 428); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 429); zephir_check_call_status(); RETURN_MM_BOOL(ZEPHIR_IS_STRING_IDENTICAL(&_0, "OPTIONS")); } @@ -3030,7 +3030,7 @@ PHP_METHOD(Phalcon_Http_Request, isPatch) ZEPHIR_MM_GROW(); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 428); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 429); zephir_check_call_status(); RETURN_MM_BOOL(ZEPHIR_IS_STRING_IDENTICAL(&_0, "PATCH")); } @@ -3051,7 +3051,7 @@ PHP_METHOD(Phalcon_Http_Request, isPost) ZEPHIR_MM_GROW(); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 428); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 429); zephir_check_call_status(); RETURN_MM_BOOL(ZEPHIR_IS_STRING_IDENTICAL(&_0, "POST")); } @@ -3072,7 +3072,7 @@ PHP_METHOD(Phalcon_Http_Request, isPut) ZEPHIR_MM_GROW(); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 428); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 429); zephir_check_call_status(); RETURN_MM_BOOL(ZEPHIR_IS_STRING_IDENTICAL(&_0, "PUT")); } @@ -3093,7 +3093,7 @@ PHP_METHOD(Phalcon_Http_Request, isPurge) ZEPHIR_MM_GROW(); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 428); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 429); zephir_check_call_status(); RETURN_MM_BOOL(ZEPHIR_IS_STRING_IDENTICAL(&_0, "PURGE")); } @@ -3150,7 +3150,7 @@ PHP_METHOD(Phalcon_Http_Request, isSoap) ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "HTTP_SOAPACTION"); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "hasserver", NULL, 419, &_1); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "hasserver", NULL, 420, &_1); zephir_check_call_status(); if (zephir_is_true(&_0)) { RETURN_MM_BOOL(1); @@ -3179,7 +3179,7 @@ PHP_METHOD(Phalcon_Http_Request, isTrace) ZEPHIR_MM_GROW(); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 428); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmethod", NULL, 429); zephir_check_call_status(); RETURN_MM_BOOL(ZEPHIR_IS_STRING_IDENTICAL(&_0, "TRACE")); } @@ -3288,7 +3288,7 @@ PHP_METHOD(Phalcon_Http_Request, numFiles) } else { ZVAL_BOOL(&_4$$8, 0); } - ZEPHIR_CALL_METHOD(&_3$$8, this_ptr, "hasfilehelper", &_5, 430, &error, &_4$$8); + ZEPHIR_CALL_METHOD(&_3$$8, this_ptr, "hasfilehelper", &_5, 431, &error, &_4$$8); zephir_check_call_status(); numberFiles += zephir_get_numberval(&_3$$8); } @@ -3322,7 +3322,7 @@ PHP_METHOD(Phalcon_Http_Request, numFiles) } else { ZVAL_BOOL(&_8$$13, 0); } - ZEPHIR_CALL_METHOD(&_7$$13, this_ptr, "hasfilehelper", &_5, 430, &error, &_8$$13); + ZEPHIR_CALL_METHOD(&_7$$13, this_ptr, "hasfilehelper", &_5, 431, &error, &_8$$13); zephir_check_call_status(); numberFiles += zephir_get_numberval(&_7$$13); } @@ -3416,7 +3416,7 @@ PHP_METHOD(Phalcon_Http_Request, setParameterFilters) ZEPHIR_MM_RESTORE(); return; } - ZEPHIR_CALL_METHOD(&filterService, this_ptr, "getfilterservice", NULL, 431); + ZEPHIR_CALL_METHOD(&filterService, this_ptr, "getfilterservice", NULL, 432); zephir_check_call_status(); zephir_is_iterable(&filters, 0, "phalcon/Http/Request.zep", 1272); if (Z_TYPE_P(&filters) == IS_ARRAY) { @@ -3754,7 +3754,7 @@ PHP_METHOD(Phalcon_Http_Request, getHelper) RETURN_MM(); } if (Z_TYPE_P(filters) != IS_NULL) { - ZEPHIR_CALL_METHOD(&filterService, this_ptr, "getfilterservice", NULL, 431); + ZEPHIR_CALL_METHOD(&filterService, this_ptr, "getfilterservice", NULL, 432); zephir_check_call_status(); if (noRecursive) { ZVAL_BOOL(&_3$$6, 1); @@ -3826,7 +3826,7 @@ PHP_METHOD(Phalcon_Http_Request, hasFileHelper) } else { ZVAL_BOOL(&_4$$7, 0); } - ZEPHIR_CALL_METHOD(&_3$$7, this_ptr, "hasfilehelper", &_5, 430, &value, &_4$$7); + ZEPHIR_CALL_METHOD(&_3$$7, this_ptr, "hasfilehelper", &_5, 431, &value, &_4$$7); zephir_check_call_status(); numberFiles += zephir_get_numberval(&_3$$7); } @@ -3857,7 +3857,7 @@ PHP_METHOD(Phalcon_Http_Request, hasFileHelper) } else { ZVAL_BOOL(&_8$$11, 0); } - ZEPHIR_CALL_METHOD(&_7$$11, this_ptr, "hasfilehelper", &_5, 430, &value, &_8$$11); + ZEPHIR_CALL_METHOD(&_7$$11, this_ptr, "hasfilehelper", &_5, 431, &value, &_8$$11); zephir_check_call_status(); numberFiles += zephir_get_numberval(&_7$$11); } @@ -4243,7 +4243,7 @@ PHP_METHOD(Phalcon_Http_Request, resolveAuthorizationHeaders) ZEPHIR_CALL_METHOD(&_0, this_ptr, "getdi", NULL, 0); zephir_check_call_status(); ZEPHIR_CPY_WRT(&container, &_0); - ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 421); + ZEPHIR_CALL_METHOD(&server, this_ptr, "getserverarray", NULL, 422); zephir_check_call_status(); if (Z_TYPE_P(&container) == IS_OBJECT) { ZEPHIR_INIT_VAR(&_2$$3); @@ -4279,13 +4279,13 @@ PHP_METHOD(Phalcon_Http_Request, resolveAuthorizationHeaders) } ZEPHIR_INIT_VAR(&_9); ZVAL_STRING(&_9, "PHP_AUTH_USER"); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "hasserver", NULL, 419, &_9); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "hasserver", NULL, 420, &_9); zephir_check_call_status(); _10 = zephir_is_true(&_0); if (_10) { ZEPHIR_INIT_NVAR(&_9); ZVAL_STRING(&_9, "PHP_AUTH_PW"); - ZEPHIR_CALL_METHOD(&_11, this_ptr, "hasserver", NULL, 419, &_9); + ZEPHIR_CALL_METHOD(&_11, this_ptr, "hasserver", NULL, 420, &_9); zephir_check_call_status(); _10 = zephir_is_true(&_11); } @@ -4303,11 +4303,11 @@ PHP_METHOD(Phalcon_Http_Request, resolveAuthorizationHeaders) } else { ZEPHIR_INIT_VAR(&_16$$8); ZVAL_STRING(&_16$$8, "HTTP_AUTHORIZATION"); - ZEPHIR_CALL_METHOD(&_15$$8, this_ptr, "hasserver", NULL, 419, &_16$$8); + ZEPHIR_CALL_METHOD(&_15$$8, this_ptr, "hasserver", NULL, 420, &_16$$8); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_16$$8); ZVAL_STRING(&_16$$8, "REDIRECT_HTTP_AUTHORIZATION"); - ZEPHIR_CALL_METHOD(&_17$$8, this_ptr, "hasserver", NULL, 419, &_16$$8); + ZEPHIR_CALL_METHOD(&_17$$8, this_ptr, "hasserver", NULL, 420, &_16$$8); zephir_check_call_status(); if (zephir_is_true(&_15$$8)) { ZEPHIR_INIT_VAR(&_18$$9); @@ -4323,23 +4323,23 @@ PHP_METHOD(Phalcon_Http_Request, resolveAuthorizationHeaders) if (zephir_is_true(&authHeader)) { ZEPHIR_INIT_VAR(&_20$$11); ZVAL_STRING(&_20$$11, "basic "); - ZEPHIR_CALL_FUNCTION(&_21$$11, "stripos", NULL, 424, &authHeader, &_20$$11); + ZEPHIR_CALL_FUNCTION(&_21$$11, "stripos", NULL, 425, &authHeader, &_20$$11); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_20$$11); ZVAL_STRING(&_20$$11, "digest "); - ZEPHIR_CALL_FUNCTION(&_22$$11, "stripos", NULL, 424, &authHeader, &_20$$11); + ZEPHIR_CALL_FUNCTION(&_22$$11, "stripos", NULL, 425, &authHeader, &_20$$11); zephir_check_call_status(); _23$$11 = ZEPHIR_IS_LONG_IDENTICAL(&_22$$11, 0); if (_23$$11) { ZEPHIR_INIT_NVAR(&_20$$11); ZVAL_STRING(&_20$$11, "PHP_AUTH_DIGEST"); - ZEPHIR_CALL_METHOD(&_24$$11, this_ptr, "hasserver", NULL, 419, &_20$$11); + ZEPHIR_CALL_METHOD(&_24$$11, this_ptr, "hasserver", NULL, 420, &_20$$11); zephir_check_call_status(); _23$$11 = !zephir_is_true(&_24$$11); } ZEPHIR_INIT_NVAR(&_20$$11); ZVAL_STRING(&_20$$11, "bearer "); - ZEPHIR_CALL_FUNCTION(&_25$$11, "stripos", NULL, 424, &authHeader, &_20$$11); + ZEPHIR_CALL_FUNCTION(&_25$$11, "stripos", NULL, 425, &authHeader, &_20$$11); zephir_check_call_status(); if (ZEPHIR_IS_LONG_IDENTICAL(&_21$$11, 0)) { ZVAL_LONG(&_26$$12, 6); @@ -4508,7 +4508,7 @@ PHP_METHOD(Phalcon_Http_Request, smoothFiles) zephir_array_fetch(&_8$$5, &tmp_names, &idx, PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 1554); zephir_array_fetch(&_9$$5, &sizes, &idx, PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 1555); zephir_array_fetch(&_10$$5, &errors, &idx, PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 1556); - ZEPHIR_CALL_METHOD(&parentFiles, this_ptr, "smoothfiles", &_11, 426, &_6$$5, &_7$$5, &_8$$5, &_9$$5, &_10$$5, &p); + ZEPHIR_CALL_METHOD(&parentFiles, this_ptr, "smoothfiles", &_11, 427, &_6$$5, &_7$$5, &_8$$5, &_9$$5, &_10$$5, &p); zephir_check_call_status(); zephir_is_iterable(&parentFiles, 0, "phalcon/Http/Request.zep", 1563); if (Z_TYPE_P(&parentFiles) == IS_ARRAY) { @@ -4577,7 +4577,7 @@ PHP_METHOD(Phalcon_Http_Request, smoothFiles) zephir_array_fetch(&_18$$10, &tmp_names, &idx, PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 1554); zephir_array_fetch(&_19$$10, &sizes, &idx, PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 1555); zephir_array_fetch(&_20$$10, &errors, &idx, PH_NOISY | PH_READONLY, "phalcon/Http/Request.zep", 1556); - ZEPHIR_CALL_METHOD(&parentFiles, this_ptr, "smoothfiles", &_11, 426, &_16$$10, &_17$$10, &_18$$10, &_19$$10, &_20$$10, &p); + ZEPHIR_CALL_METHOD(&parentFiles, this_ptr, "smoothfiles", &_11, 427, &_16$$10, &_17$$10, &_18$$10, &_19$$10, &_20$$10, &p); zephir_check_call_status(); zephir_is_iterable(&parentFiles, 0, "phalcon/Http/Request.zep", 1563); if (Z_TYPE_P(&parentFiles) == IS_ARRAY) { diff --git a/ext/phalcon/http/request/file.zep.c b/ext/phalcon/http/request/file.zep.c index 05700c88377..9f83123da57 100644 --- a/ext/phalcon/http/request/file.zep.c +++ b/ext/phalcon/http/request/file.zep.c @@ -177,29 +177,29 @@ PHP_METHOD(Phalcon_Http_Request_File, __construct) zephir_check_call_status(); if (zephir_is_true(&_1$$3)) { ZVAL_LONG(&_2$$4, 4); - ZEPHIR_CALL_FUNCTION(&_3$$4, "pathinfo", NULL, 116, &name, &_2$$4); + ZEPHIR_CALL_FUNCTION(&_3$$4, "pathinfo", NULL, 118, &name, &_2$$4); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("extension"), &_3$$4); } } ZEPHIR_INIT_VAR(&_5); ZVAL_STRING(&_5, "tmp_name"); - ZEPHIR_CALL_METHOD(&_4, this_ptr, "getarrval", NULL, 432, &file, &_5); + ZEPHIR_CALL_METHOD(&_4, this_ptr, "getarrval", NULL, 433, &file, &_5); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("tmp"), &_4); ZEPHIR_INIT_NVAR(&_5); ZVAL_STRING(&_5, "size"); - ZEPHIR_CALL_METHOD(&_6, this_ptr, "getarrval", NULL, 432, &file, &_5); + ZEPHIR_CALL_METHOD(&_6, this_ptr, "getarrval", NULL, 433, &file, &_5); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("size"), &_6); ZEPHIR_INIT_NVAR(&_5); ZVAL_STRING(&_5, "type"); - ZEPHIR_CALL_METHOD(&_7, this_ptr, "getarrval", NULL, 432, &file, &_5); + ZEPHIR_CALL_METHOD(&_7, this_ptr, "getarrval", NULL, 433, &file, &_5); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("type"), &_7); ZEPHIR_INIT_NVAR(&_5); ZVAL_STRING(&_5, "error"); - ZEPHIR_CALL_METHOD(&_8, this_ptr, "getarrval", NULL, 432, &file, &_5); + ZEPHIR_CALL_METHOD(&_8, this_ptr, "getarrval", NULL, 433, &file, &_5); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("error"), &_8); if (zephir_is_true(key)) { @@ -238,15 +238,15 @@ PHP_METHOD(Phalcon_Http_Request_File, getRealType) ZEPHIR_MM_GROW(); ZVAL_LONG(&_0, 16); - ZEPHIR_CALL_FUNCTION(&finfo, "finfo_open", NULL, 331, &_0); + ZEPHIR_CALL_FUNCTION(&finfo, "finfo_open", NULL, 332, &_0); zephir_check_call_status(); if (Z_TYPE_P(&finfo) != IS_RESOURCE) { RETURN_MM_STRING(""); } zephir_read_property(&_0, this_ptr, ZEND_STRL("tmp"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&mime, "finfo_file", NULL, 332, &finfo, &_0); + ZEPHIR_CALL_FUNCTION(&mime, "finfo_file", NULL, 333, &finfo, &_0); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(NULL, "finfo_close", NULL, 333, &finfo); + ZEPHIR_CALL_FUNCTION(NULL, "finfo_close", NULL, 334, &finfo); zephir_check_call_status(); RETURN_CCTOR(&mime); } @@ -351,7 +351,7 @@ PHP_METHOD(Phalcon_Http_Request_File, moveTo) zephir_read_property(&_0, this_ptr, ZEND_STRL("tmp"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_RETURN_CALL_FUNCTION("move_uploaded_file", NULL, 403, &_0, &destination); + ZEPHIR_RETURN_CALL_FUNCTION("move_uploaded_file", NULL, 404, &_0, &destination); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/http/response.zep.c b/ext/phalcon/http/response.zep.c index 052307a93cf..9c324395b73 100644 --- a/ext/phalcon/http/response.zep.c +++ b/ext/phalcon/http/response.zep.c @@ -502,7 +502,7 @@ PHP_METHOD(Phalcon_Http_Response, redirect) if (_0$$5) { ZEPHIR_INIT_VAR(&_1$$5); ZVAL_STRING(&_1$$5, "://"); - ZEPHIR_CALL_FUNCTION(&_2$$5, "strstr", NULL, 433, location, &_1$$5); + ZEPHIR_CALL_FUNCTION(&_2$$5, "strstr", NULL, 434, location, &_1$$5); zephir_check_call_status(); _0$$5 = zephir_is_true(&_2$$5); } @@ -667,7 +667,7 @@ PHP_METHOD(Phalcon_Http_Response, send) _3$$5 = ((zephir_fast_strlen_ev(&file)) ? 1 : 0); } if (_3$$5) { - ZEPHIR_CALL_FUNCTION(NULL, "readfile", NULL, 434, &file); + ZEPHIR_CALL_FUNCTION(NULL, "readfile", NULL, 435, &file); zephir_check_call_status(); } } @@ -1159,16 +1159,16 @@ PHP_METHOD(Phalcon_Http_Response, setFileToSend) ZEPHIR_INIT_VAR(&basePathEncoding); ZVAL_STRING(&basePathEncoding, "ASCII"); if (Z_TYPE_P(attachmentName) != IS_STRING) { - ZEPHIR_CALL_METHOD(&basePath, this_ptr, "getbasename", NULL, 435, &filePath); + ZEPHIR_CALL_METHOD(&basePath, this_ptr, "getbasename", NULL, 436, &filePath); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(&basePath, attachmentName); } if (zephir_is_true(attachment)) { if ((zephir_function_exists_ex(ZEND_STRL("mb_detect_encoding")) == SUCCESS)) { - ZEPHIR_CALL_FUNCTION(&_0$$6, "mb_detect_order", NULL, 436); + ZEPHIR_CALL_FUNCTION(&_0$$6, "mb_detect_order", NULL, 437); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&basePathEncoding, "mb_detect_encoding", NULL, 347, &basePath, &_0$$6, &__$true); + ZEPHIR_CALL_FUNCTION(&basePathEncoding, "mb_detect_encoding", NULL, 348, &basePath, &_0$$6, &__$true); zephir_check_call_status(); } ZEPHIR_INIT_VAR(&_1$$5); @@ -1184,7 +1184,7 @@ PHP_METHOD(Phalcon_Http_Response, setFileToSend) ZEPHIR_CALL_METHOD(NULL, this_ptr, "setrawheader", NULL, 0, &_1$$5); zephir_check_call_status(); if (!ZEPHIR_IS_STRING(&basePathEncoding, "ASCII")) { - ZEPHIR_CALL_FUNCTION(&_2$$7, "rawurlencode", NULL, 351, &basePath); + ZEPHIR_CALL_FUNCTION(&_2$$7, "rawurlencode", NULL, 352, &basePath); zephir_check_call_status(); ZEPHIR_CPY_WRT(&basePath, &_2$$7); ZEPHIR_INIT_VAR(&_3$$7); @@ -1376,7 +1376,7 @@ PHP_METHOD(Phalcon_Http_Response, setJsonContent) zephir_check_call_status(); ZVAL_LONG(&_2, jsonOptions); ZVAL_LONG(&_3, depth); - ZEPHIR_CALL_METHOD(&_1, this_ptr, "encode", NULL, 437, content, &_2, &_3); + ZEPHIR_CALL_METHOD(&_1, this_ptr, "encode", NULL, 438, content, &_2, &_3); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, this_ptr, "setcontent", NULL, 0, &_1); zephir_check_call_status(); @@ -1546,7 +1546,7 @@ PHP_METHOD(Phalcon_Http_Response, setStatusCode) if (_6$$3) { ZEPHIR_INIT_NVAR(&_7$$3); ZVAL_STRING(&_7$$3, "HTTP/"); - ZEPHIR_CALL_FUNCTION(&_8$$3, "strstr", &_9, 433, &key, &_7$$3); + ZEPHIR_CALL_FUNCTION(&_8$$3, "strstr", &_9, 434, &key, &_7$$3); zephir_check_call_status(); _6$$3 = zephir_is_true(&_8$$3); } @@ -1573,7 +1573,7 @@ PHP_METHOD(Phalcon_Http_Response, setStatusCode) if (_11$$5) { ZEPHIR_INIT_NVAR(&_12$$5); ZVAL_STRING(&_12$$5, "HTTP/"); - ZEPHIR_CALL_FUNCTION(&_13$$5, "strstr", &_9, 433, &key, &_12$$5); + ZEPHIR_CALL_FUNCTION(&_13$$5, "strstr", &_9, 434, &key, &_12$$5); zephir_check_call_status(); _11$$5 = zephir_is_true(&_13$$5); } @@ -1804,7 +1804,7 @@ PHP_METHOD(Phalcon_Http_Response, getBasename) ZVAL_STRING(&_2, "/"); ZEPHIR_INIT_VAR(&_3); ZVAL_STRING(&_3, "@"); - ZEPHIR_CALL_FUNCTION(&_4, "preg_quote", NULL, 438, &_2, &_3); + ZEPHIR_CALL_FUNCTION(&_4, "preg_quote", NULL, 439, &_2, &_3); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_5); ZEPHIR_CONCAT_SVS(&_5, "@[^", &_4, "]+$@"); @@ -1820,7 +1820,7 @@ PHP_METHOD(Phalcon_Http_Response, getBasename) if (zephir_is_true(suffix)) { ZEPHIR_INIT_VAR(&_6$$3); ZVAL_STRING(&_6$$3, "@"); - ZEPHIR_CALL_FUNCTION(&_7$$3, "preg_quote", NULL, 438, suffix, &_6$$3); + ZEPHIR_CALL_FUNCTION(&_7$$3, "preg_quote", NULL, 439, suffix, &_6$$3); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_8$$3); ZEPHIR_CONCAT_SVS(&_8$$3, "@", &_7$$3, "$@"); diff --git a/ext/phalcon/http/response/cookies.zep.c b/ext/phalcon/http/response/cookies.zep.c index d9c6b81a1df..529dd15b022 100644 --- a/ext/phalcon/http/response/cookies.zep.c +++ b/ext/phalcon/http/response/cookies.zep.c @@ -403,7 +403,7 @@ PHP_METHOD(Phalcon_Http_Response_Cookies, send) ZEPHIR_MM_GROW(); - ZEPHIR_CALL_FUNCTION(&_0, "headers_sent", NULL, 439); + ZEPHIR_CALL_FUNCTION(&_0, "headers_sent", NULL, 440); zephir_check_call_status(); _1 = ZEPHIR_IS_TRUE_IDENTICAL(&_0); if (!(_1)) { diff --git a/ext/phalcon/http/response/headers.zep.c b/ext/phalcon/http/response/headers.zep.c index 0508dbdd3da..23383d6917e 100644 --- a/ext/phalcon/http/response/headers.zep.c +++ b/ext/phalcon/http/response/headers.zep.c @@ -217,7 +217,7 @@ PHP_METHOD(Phalcon_Http_Response_Headers, send) ZEPHIR_MM_GROW(); - ZEPHIR_CALL_FUNCTION(&_0, "headers_sent", NULL, 439); + ZEPHIR_CALL_FUNCTION(&_0, "headers_sent", NULL, 440); zephir_check_call_status(); _1 = ZEPHIR_IS_TRUE_IDENTICAL(&_0); if (!(_1)) { @@ -243,7 +243,7 @@ PHP_METHOD(Phalcon_Http_Response_Headers, send) if (Z_TYPE_P(&value) != IS_NULL) { ZEPHIR_INIT_NVAR(&_8$$5); ZEPHIR_CONCAT_VSV(&_8$$5, &header, ": ", &value); - ZEPHIR_CALL_FUNCTION(NULL, "header", &_9, 440, &_8$$5, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "header", &_9, 441, &_8$$5, &__$true); zephir_check_call_status(); } else { _10$$6 = zephir_memnstr_str(&header, SL(":"), "phalcon/Http/Response/Headers.zep", 99); @@ -255,12 +255,12 @@ PHP_METHOD(Phalcon_Http_Response_Headers, send) _10$$6 = ZEPHIR_IS_STRING(&_13$$6, "HTTP/"); } if (_10$$6) { - ZEPHIR_CALL_FUNCTION(NULL, "header", &_9, 440, &header, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "header", &_9, 441, &header, &__$true); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(&_14$$8); ZEPHIR_CONCAT_VS(&_14$$8, &header, ": "); - ZEPHIR_CALL_FUNCTION(NULL, "header", &_9, 440, &_14$$8, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "header", &_9, 441, &_14$$8, &__$true); zephir_check_call_status(); } } @@ -281,7 +281,7 @@ PHP_METHOD(Phalcon_Http_Response_Headers, send) if (Z_TYPE_P(&value) != IS_NULL) { ZEPHIR_INIT_NVAR(&_15$$10); ZEPHIR_CONCAT_VSV(&_15$$10, &header, ": ", &value); - ZEPHIR_CALL_FUNCTION(NULL, "header", &_9, 440, &_15$$10, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "header", &_9, 441, &_15$$10, &__$true); zephir_check_call_status(); } else { _16$$11 = zephir_memnstr_str(&header, SL(":"), "phalcon/Http/Response/Headers.zep", 99); @@ -293,12 +293,12 @@ PHP_METHOD(Phalcon_Http_Response_Headers, send) _16$$11 = ZEPHIR_IS_STRING(&_19$$11, "HTTP/"); } if (_16$$11) { - ZEPHIR_CALL_FUNCTION(NULL, "header", &_9, 440, &header, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "header", &_9, 441, &header, &__$true); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(&_20$$13); ZEPHIR_CONCAT_VS(&_20$$13, &header, ": "); - ZEPHIR_CALL_FUNCTION(NULL, "header", &_9, 440, &_20$$13, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "header", &_9, 441, &_20$$13, &__$true); zephir_check_call_status(); } } diff --git a/ext/phalcon/image/adapter/abstractadapter.zep.c b/ext/phalcon/image/adapter/abstractadapter.zep.c index 381422871dd..bed227a7374 100644 --- a/ext/phalcon/image/adapter/abstractadapter.zep.c +++ b/ext/phalcon/image/adapter/abstractadapter.zep.c @@ -231,7 +231,7 @@ PHP_METHOD(Phalcon_Image_Adapter_AbstractAdapter, background) zephir_get_strval(&color, &_8$$4); } ZVAL_LONG(&_9, 2); - ZEPHIR_CALL_FUNCTION(&_10, "str_split", NULL, 115, &color, &_9); + ZEPHIR_CALL_FUNCTION(&_10, "str_split", NULL, 117, &color, &_9); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_11); ZVAL_STRING(&_11, "hexdec"); @@ -657,7 +657,7 @@ PHP_METHOD(Phalcon_Image_Adapter_AbstractAdapter, render) if (ZEPHIR_IS_EMPTY(&ext)) { zephir_read_property(&_0$$3, this_ptr, ZEND_STRL("file"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1$$3, 4); - ZEPHIR_CALL_FUNCTION(&_2$$3, "pathinfo", NULL, 116, &_0$$3, &_1$$3); + ZEPHIR_CALL_FUNCTION(&_2$$3, "pathinfo", NULL, 118, &_0$$3, &_1$$3); zephir_check_call_status(); zephir_cast_to_string(&_3$$3, &_2$$3); ZEPHIR_CPY_WRT(&ext, &_3$$3); @@ -864,14 +864,14 @@ PHP_METHOD(Phalcon_Image_Adapter_AbstractAdapter, resize) ZVAL_LONG(&_24, width); zephir_round(&_23, &_24, NULL, NULL); ZVAL_LONG(&_25, 1); - ZEPHIR_CALL_FUNCTION(&_26, "max", NULL, 117, &_23, &_25); + ZEPHIR_CALL_FUNCTION(&_26, "max", NULL, 119, &_23, &_25); zephir_check_call_status(); width = zephir_get_intval(&_26); ZEPHIR_INIT_VAR(&_27); ZVAL_LONG(&_25, height); zephir_round(&_27, &_25, NULL, NULL); ZVAL_LONG(&_28, 1); - ZEPHIR_CALL_FUNCTION(&_29, "max", NULL, 117, &_27, &_28); + ZEPHIR_CALL_FUNCTION(&_29, "max", NULL, 119, &_27, &_28); zephir_check_call_status(); height = zephir_get_intval(&_29); ZVAL_LONG(&_28, width); @@ -1124,7 +1124,7 @@ PHP_METHOD(Phalcon_Image_Adapter_AbstractAdapter, text) zephir_get_strval(&color, &_8$$7); } ZVAL_LONG(&_9, 2); - ZEPHIR_CALL_FUNCTION(&_10, "str_split", NULL, 115, &color, &_9); + ZEPHIR_CALL_FUNCTION(&_10, "str_split", NULL, 117, &color, &_9); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_11); ZVAL_STRING(&_11, "hexdec"); diff --git a/ext/phalcon/image/adapter/gd.zep.c b/ext/phalcon/image/adapter/gd.zep.c index b73b0933a4f..11bad8d0116 100644 --- a/ext/phalcon/image/adapter/gd.zep.c +++ b/ext/phalcon/image/adapter/gd.zep.c @@ -137,7 +137,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __construct) zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("realpath"), &_3$$4); zephir_read_property(&_4$$4, this_ptr, ZEND_STRL("file"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&imageinfo, "getimagesize", NULL, 334, &_4$$4); + ZEPHIR_CALL_FUNCTION(&imageinfo, "getimagesize", NULL, 335, &_4$$4); zephir_check_call_status(); if (zephir_is_true(&imageinfo)) { zephir_array_fetch_long(&_5$$5, &imageinfo, 0, PH_NOISY | PH_READONLY, "phalcon/Image/Adapter/Gd.zep", 38); @@ -153,35 +153,35 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __construct) do { if (ZEPHIR_IS_LONG(&_9$$4, 1)) { zephir_read_property(&_10$$6, this_ptr, ZEND_STRL("file"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_11$$6, "imagecreatefromgif", NULL, 441, &_10$$6); + ZEPHIR_CALL_FUNCTION(&_11$$6, "imagecreatefromgif", NULL, 442, &_10$$6); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("image"), &_11$$6); break; } if (ZEPHIR_IS_LONG(&_9$$4, 2)) { zephir_read_property(&_12$$7, this_ptr, ZEND_STRL("file"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_13$$7, "imagecreatefromjpeg", NULL, 442, &_12$$7); + ZEPHIR_CALL_FUNCTION(&_13$$7, "imagecreatefromjpeg", NULL, 443, &_12$$7); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("image"), &_13$$7); break; } if (ZEPHIR_IS_LONG(&_9$$4, 3)) { zephir_read_property(&_14$$8, this_ptr, ZEND_STRL("file"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_15$$8, "imagecreatefrompng", NULL, 443, &_14$$8); + ZEPHIR_CALL_FUNCTION(&_15$$8, "imagecreatefrompng", NULL, 444, &_14$$8); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("image"), &_15$$8); break; } if (ZEPHIR_IS_LONG(&_9$$4, 15)) { zephir_read_property(&_16$$9, this_ptr, ZEND_STRL("file"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_17$$9, "imagecreatefromwbmp", NULL, 444, &_16$$9); + ZEPHIR_CALL_FUNCTION(&_17$$9, "imagecreatefromwbmp", NULL, 445, &_16$$9); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("image"), &_17$$9); break; } if (ZEPHIR_IS_LONG(&_9$$4, 16)) { zephir_read_property(&_18$$10, this_ptr, ZEND_STRL("file"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_19$$10, "imagecreatefromxbm", NULL, 445, &_18$$10); + ZEPHIR_CALL_FUNCTION(&_19$$10, "imagecreatefromxbm", NULL, 446, &_18$$10); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("image"), &_19$$10); break; @@ -204,7 +204,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __construct) } while(0); zephir_read_property(&_24$$4, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 446, &_24$$4, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 447, &_24$$4, &__$true); zephir_check_call_status(); } else { _25$$13 = !width; @@ -225,14 +225,14 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __construct) } ZVAL_LONG(&_29$$13, width); ZVAL_LONG(&_30$$13, height); - ZEPHIR_CALL_FUNCTION(&_31$$13, "imagecreatetruecolor", NULL, 447, &_29$$13, &_30$$13); + ZEPHIR_CALL_FUNCTION(&_31$$13, "imagecreatetruecolor", NULL, 448, &_29$$13, &_30$$13); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("image"), &_31$$13); zephir_read_property(&_29$$13, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagealphablending", NULL, 448, &_29$$13, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "imagealphablending", NULL, 449, &_29$$13, &__$true); zephir_check_call_status(); zephir_read_property(&_30$$13, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 446, &_30$$13, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 447, &_30$$13, &__$true); zephir_check_call_status(); zephir_read_property(&_32$$13, this_ptr, ZEND_STRL("file"), PH_NOISY_CC | PH_READONLY); zephir_update_property_zval(this_ptr, ZEND_STRL("realpath"), &_32$$13); @@ -269,7 +269,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, __destruct) zephir_read_property(&_0, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); if (Z_TYPE_P(&image) == IS_RESOURCE) { - ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 449, &image); + ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 450, &image); zephir_check_call_status(); } ZEPHIR_MM_RESTORE(); @@ -361,7 +361,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, getVersion) ZEPHIR_INIT_NVAR(&version); ZEPHIR_GET_CONSTANT(&version, "GD_VERSION"); } else { - ZEPHIR_CALL_FUNCTION(&info, "gd_info", NULL, 450); + ZEPHIR_CALL_FUNCTION(&info, "gd_info", NULL, 451); zephir_check_call_status(); ZEPHIR_INIT_VAR(&matches); ZVAL_NULL(&matches); @@ -424,7 +424,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processBackground) ZEPHIR_INIT_VAR(&_0); ZVAL_DOUBLE(&_1, ((zephir_safe_div_long_long((opacity * 127), 100)) - (double) (127))); - ZEPHIR_CALL_FUNCTION(&_2, "abs", NULL, 305, &_1); + ZEPHIR_CALL_FUNCTION(&_2, "abs", NULL, 306, &_1); zephir_check_call_status(); zephir_round(&_0, &_2, NULL, NULL); opacity = zephir_get_intval(&_0); @@ -436,9 +436,9 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processBackground) ZVAL_LONG(&_5, g); ZVAL_LONG(&_6, b); ZVAL_LONG(&_7, opacity); - ZEPHIR_CALL_FUNCTION(&color, "imagecolorallocatealpha", NULL, 451, &background, &_4, &_5, &_6, &_7); + ZEPHIR_CALL_FUNCTION(&color, "imagecolorallocatealpha", NULL, 452, &background, &_4, &_5, &_6, &_7); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(NULL, "imagealphablending", NULL, 448, &background, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "imagealphablending", NULL, 449, &background, &__$true); zephir_check_call_status(); zephir_read_property(&_4, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); zephir_read_property(&_5, this_ptr, ZEND_STRL("width"), PH_NOISY_CC | PH_READONLY); @@ -447,11 +447,11 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processBackground) ZVAL_LONG(&_8, 0); ZVAL_LONG(&_9, 0); ZVAL_LONG(&_10, 0); - ZEPHIR_CALL_FUNCTION(&_11, "imagecopy", NULL, 452, &background, &_4, &_7, &_8, &_9, &_10, &_5, &_6); + ZEPHIR_CALL_FUNCTION(&_11, "imagecopy", NULL, 453, &background, &_4, &_7, &_8, &_9, &_10, &_5, &_6); zephir_check_call_status(); if (zephir_is_true(&_11)) { zephir_read_property(&_12$$3, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 449, &_12$$3); + ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 450, &_12$$3); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("image"), &background); } @@ -488,7 +488,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processBlur) } zephir_read_property(&_0$$3, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1$$3, 7); - ZEPHIR_CALL_FUNCTION(NULL, "imagefilter", &_2, 453, &_0$$3, &_1$$3); + ZEPHIR_CALL_FUNCTION(NULL, "imagefilter", &_2, 454, &_0$$3, &_1$$3); zephir_check_call_status(); i++; } @@ -524,11 +524,11 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processCreate) ZVAL_LONG(&_0, width); ZVAL_LONG(&_1, height); - ZEPHIR_CALL_FUNCTION(&image, "imagecreatetruecolor", NULL, 447, &_0, &_1); + ZEPHIR_CALL_FUNCTION(&image, "imagecreatetruecolor", NULL, 448, &_0, &_1); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(NULL, "imagealphablending", NULL, 448, &image, &__$false); + ZEPHIR_CALL_FUNCTION(NULL, "imagealphablending", NULL, 449, &image, &__$false); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 446, &image, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 447, &image, &__$true); zephir_check_call_status(); RETURN_CCTOR(&image); } @@ -581,16 +581,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_read_property(&_1, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&image, "imagecrop", NULL, 454, &_1, &rect); + ZEPHIR_CALL_FUNCTION(&image, "imagecrop", NULL, 455, &_1, &rect); zephir_check_call_status(); zephir_read_property(&_2, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 449, &_2); + ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 450, &_2); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("image"), &image); - ZEPHIR_CALL_FUNCTION(&_3, "imagesx", NULL, 455, &image); + ZEPHIR_CALL_FUNCTION(&_3, "imagesx", NULL, 456, &image); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("width"), &_3); - ZEPHIR_CALL_FUNCTION(&_4, "imagesy", NULL, 456, &image); + ZEPHIR_CALL_FUNCTION(&_4, "imagesy", NULL, 457, &image); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("height"), &_4); ZEPHIR_MM_RESTORE(); @@ -623,12 +623,12 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processFlip) if (direction == 11) { zephir_read_property(&_0$$3, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1$$3, 1); - ZEPHIR_CALL_FUNCTION(NULL, "imageflip", NULL, 457, &_0$$3, &_1$$3); + ZEPHIR_CALL_FUNCTION(NULL, "imageflip", NULL, 458, &_0$$3, &_1$$3); zephir_check_call_status(); } else { zephir_read_property(&_2$$4, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_3$$4, 2); - ZEPHIR_CALL_FUNCTION(NULL, "imageflip", NULL, 457, &_2$$4, &_3$$4); + ZEPHIR_CALL_FUNCTION(NULL, "imageflip", NULL, 458, &_2$$4, &_3$$4); zephir_check_call_status(); } ZEPHIR_MM_RESTORE(); @@ -693,32 +693,32 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processMask) ZEPHIR_CALL_METHOD(&_0, mask, "render", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&maskImage, "imagecreatefromstring", NULL, 458, &_0); + ZEPHIR_CALL_FUNCTION(&maskImage, "imagecreatefromstring", NULL, 459, &_0); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&_1, "imagesx", NULL, 455, &maskImage); + ZEPHIR_CALL_FUNCTION(&_1, "imagesx", NULL, 456, &maskImage); zephir_check_call_status(); mask_width = zephir_get_intval(&_1); - ZEPHIR_CALL_FUNCTION(&_2, "imagesy", NULL, 456, &maskImage); + ZEPHIR_CALL_FUNCTION(&_2, "imagesy", NULL, 457, &maskImage); zephir_check_call_status(); mask_height = zephir_get_intval(&_2); alpha = 127; - ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 446, &maskImage, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 447, &maskImage, &__$true); zephir_check_call_status(); zephir_read_property(&_3, this_ptr, ZEND_STRL("width"), PH_NOISY_CC | PH_READONLY); zephir_read_property(&_4, this_ptr, ZEND_STRL("height"), 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, 446, &newimage, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 447, &newimage, &__$true); zephir_check_call_status(); ZVAL_LONG(&_5, 0); ZVAL_LONG(&_6, 0); ZVAL_LONG(&_7, 0); ZVAL_LONG(&_8, alpha); - ZEPHIR_CALL_FUNCTION(&color, "imagecolorallocatealpha", NULL, 451, &newimage, &_5, &_6, &_7, &_8); + ZEPHIR_CALL_FUNCTION(&color, "imagecolorallocatealpha", NULL, 452, &newimage, &_5, &_6, &_7, &_8); zephir_check_call_status(); ZVAL_LONG(&_5, 0); ZVAL_LONG(&_6, 0); - ZEPHIR_CALL_FUNCTION(NULL, "imagefill", NULL, 459, &newimage, &_5, &_6, &color); + ZEPHIR_CALL_FUNCTION(NULL, "imagefill", NULL, 460, &newimage, &_5, &_6, &color); zephir_check_call_status(); zephir_read_property(&_5, this_ptr, ZEND_STRL("width"), PH_NOISY_CC | PH_READONLY); _9 = !ZEPHIR_IS_LONG(&_5, mask_width); @@ -729,7 +729,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processMask) if (_9) { zephir_read_property(&_10$$3, this_ptr, ZEND_STRL("width"), PH_NOISY_CC | PH_READONLY); zephir_read_property(&_11$$3, this_ptr, ZEND_STRL("height"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&tempImage, "imagecreatetruecolor", NULL, 447, &_10$$3, &_11$$3); + ZEPHIR_CALL_FUNCTION(&tempImage, "imagecreatetruecolor", NULL, 448, &_10$$3, &_11$$3); zephir_check_call_status(); zephir_read_property(&_12$$3, this_ptr, ZEND_STRL("width"), PH_NOISY_CC | PH_READONLY); zephir_read_property(&_13$$3, this_ptr, ZEND_STRL("height"), PH_NOISY_CC | PH_READONLY); @@ -739,9 +739,9 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processMask) ZVAL_LONG(&_17$$3, 0); ZVAL_LONG(&_18$$3, mask_width); ZVAL_LONG(&_19$$3, mask_height); - ZEPHIR_CALL_FUNCTION(NULL, "imagecopyresampled", NULL, 460, &tempImage, &maskImage, &_14$$3, &_15$$3, &_16$$3, &_17$$3, &_12$$3, &_13$$3, &_18$$3, &_19$$3); + ZEPHIR_CALL_FUNCTION(NULL, "imagecopyresampled", NULL, 461, &tempImage, &maskImage, &_14$$3, &_15$$3, &_16$$3, &_17$$3, &_12$$3, &_13$$3, &_18$$3, &_19$$3); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 449, &maskImage); + ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 450, &maskImage); zephir_check_call_status(); ZEPHIR_CPY_WRT(&maskImage, &tempImage); } @@ -759,9 +759,9 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processMask) } ZVAL_LONG(&_21$$5, x); ZVAL_LONG(&_22$$5, y); - ZEPHIR_CALL_FUNCTION(&index, "imagecolorat", &_23, 461, &maskImage, &_21$$5, &_22$$5); + ZEPHIR_CALL_FUNCTION(&index, "imagecolorat", &_23, 462, &maskImage, &_21$$5, &_22$$5); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&color, "imagecolorsforindex", &_24, 462, &maskImage, &index); + ZEPHIR_CALL_FUNCTION(&color, "imagecolorsforindex", &_24, 463, &maskImage, &index); zephir_check_call_status(); if (zephir_array_isset_string(&color, SL("red"))) { zephir_array_fetch_string(&_25$$6, &color, SL("red"), PH_NOISY | PH_READONLY, "phalcon/Image/Adapter/Gd.zep", 291); @@ -771,10 +771,10 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processMask) zephir_read_property(&_21$$5, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_22$$5, x); ZVAL_LONG(&_27$$5, y); - ZEPHIR_CALL_FUNCTION(&index, "imagecolorat", &_23, 461, &_21$$5, &_22$$5, &_27$$5); + ZEPHIR_CALL_FUNCTION(&index, "imagecolorat", &_23, 462, &_21$$5, &_22$$5, &_27$$5); zephir_check_call_status(); zephir_read_property(&_22$$5, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&color, "imagecolorsforindex", &_24, 462, &_22$$5, &index); + ZEPHIR_CALL_FUNCTION(&color, "imagecolorsforindex", &_24, 463, &_22$$5, &index); zephir_check_call_status(); ZEPHIR_OBS_NVAR(&r); zephir_array_fetch_string(&r, &color, SL("red"), PH_NOISY, "phalcon/Image/Adapter/Gd.zep", 296); @@ -783,20 +783,20 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processMask) ZEPHIR_OBS_NVAR(&b); zephir_array_fetch_string(&b, &color, SL("blue"), PH_NOISY, "phalcon/Image/Adapter/Gd.zep", 298); ZVAL_LONG(&_27$$5, alpha); - ZEPHIR_CALL_FUNCTION(&color, "imagecolorallocatealpha", NULL, 451, &newimage, &r, &g, &b, &_27$$5); + ZEPHIR_CALL_FUNCTION(&color, "imagecolorallocatealpha", NULL, 452, &newimage, &r, &g, &b, &_27$$5); zephir_check_call_status(); ZVAL_LONG(&_27$$5, x); ZVAL_LONG(&_28$$5, y); - ZEPHIR_CALL_FUNCTION(NULL, "imagesetpixel", &_29, 463, &newimage, &_27$$5, &_28$$5, &color); + ZEPHIR_CALL_FUNCTION(NULL, "imagesetpixel", &_29, 464, &newimage, &_27$$5, &_28$$5, &color); zephir_check_call_status(); y++; } x++; } zephir_read_property(&_8, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 449, &_8); + ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 450, &_8); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 449, &maskImage); + ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 450, &maskImage); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("image"), &newimage); ZEPHIR_MM_RESTORE(); @@ -861,7 +861,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processPixelate) zephir_read_property(&_5$$4, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_6$$4, x1); ZVAL_LONG(&_7$$4, y1); - ZEPHIR_CALL_FUNCTION(&color, "imagecolorat", &_8, 461, &_5$$4, &_6$$4, &_7$$4); + ZEPHIR_CALL_FUNCTION(&color, "imagecolorat", &_8, 462, &_5$$4, &_6$$4, &_7$$4); zephir_check_call_status(); x2 = (x + amount); y2 = (y + amount); @@ -870,7 +870,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processPixelate) ZVAL_LONG(&_9$$4, y); ZVAL_LONG(&_10$$4, x2); ZVAL_LONG(&_11$$4, y2); - ZEPHIR_CALL_FUNCTION(NULL, "imagefilledrectangle", &_12, 464, &_6$$4, &_7$$4, &_9$$4, &_10$$4, &_11$$4, &color); + ZEPHIR_CALL_FUNCTION(NULL, "imagefilledrectangle", &_12, 465, &_6$$4, &_7$$4, &_9$$4, &_10$$4, &_11$$4, &color); zephir_check_call_status(); y += amount; } @@ -937,7 +937,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processReflection) ZEPHIR_INIT_VAR(&_0); ZVAL_DOUBLE(&_1, ((zephir_safe_div_long_long((opacity * 127), 100)) - (double) (127))); - ZEPHIR_CALL_FUNCTION(&_2, "abs", NULL, 305, &_1); + ZEPHIR_CALL_FUNCTION(&_2, "abs", NULL, 306, &_1); zephir_check_call_status(); zephir_round(&_0, &_2, NULL, NULL); opacity = zephir_get_intval(&_0); @@ -958,7 +958,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processReflection) ZVAL_LONG(&_8, 0); ZVAL_LONG(&_9, 0); ZVAL_LONG(&_10, 0); - ZEPHIR_CALL_FUNCTION(NULL, "imagecopy", NULL, 452, &reflection, &_4, &_7, &_8, &_9, &_10, &_5, &_6); + ZEPHIR_CALL_FUNCTION(NULL, "imagecopy", NULL, 453, &reflection, &_4, &_7, &_8, &_9, &_10, &_5, &_6); zephir_check_call_status(); offset = 0; while (1) { @@ -991,14 +991,14 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processReflection) ZVAL_LONG(&_22$$5, 0); ZVAL_LONG(&_23$$5, src_y); ZVAL_LONG(&_24$$5, 1); - ZEPHIR_CALL_FUNCTION(NULL, "imagecopy", NULL, 452, &line, &_18$$5, &_20$$5, &_21$$5, &_22$$5, &_23$$5, &_19$$5, &_24$$5); + ZEPHIR_CALL_FUNCTION(NULL, "imagecopy", NULL, 453, &line, &_18$$5, &_20$$5, &_21$$5, &_22$$5, &_23$$5, &_19$$5, &_24$$5); zephir_check_call_status(); ZVAL_LONG(&_20$$5, 4); ZVAL_LONG(&_21$$5, 0); ZVAL_LONG(&_22$$5, 0); ZVAL_LONG(&_23$$5, 0); ZVAL_LONG(&_24$$5, dst_opacity); - ZEPHIR_CALL_FUNCTION(NULL, "imagefilter", &_25, 453, &line, &_20$$5, &_21$$5, &_22$$5, &_23$$5, &_24$$5); + ZEPHIR_CALL_FUNCTION(NULL, "imagefilter", &_25, 454, &line, &_20$$5, &_21$$5, &_22$$5, &_23$$5, &_24$$5); zephir_check_call_status(); zephir_read_property(&_20$$5, this_ptr, ZEND_STRL("width"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_21$$5, 0); @@ -1006,18 +1006,18 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processReflection) ZVAL_LONG(&_23$$5, 0); ZVAL_LONG(&_24$$5, 0); ZVAL_LONG(&_26$$5, 1); - ZEPHIR_CALL_FUNCTION(NULL, "imagecopy", NULL, 452, &reflection, &line, &_21$$5, &_22$$5, &_23$$5, &_24$$5, &_20$$5, &_26$$5); + ZEPHIR_CALL_FUNCTION(NULL, "imagecopy", NULL, 453, &reflection, &line, &_21$$5, &_22$$5, &_23$$5, &_24$$5, &_20$$5, &_26$$5); zephir_check_call_status(); offset++; } zephir_read_property(&_7, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 449, &_7); + ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 450, &_7); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("image"), &reflection); - ZEPHIR_CALL_FUNCTION(&_27, "imagesx", NULL, 455, &reflection); + ZEPHIR_CALL_FUNCTION(&_27, "imagesx", NULL, 456, &reflection); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("width"), &_27); - ZEPHIR_CALL_FUNCTION(&_28, "imagesy", NULL, 456, &reflection); + ZEPHIR_CALL_FUNCTION(&_28, "imagesy", NULL, 457, &reflection); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("height"), &_28); ZEPHIR_MM_RESTORE(); @@ -1068,56 +1068,56 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processRender) ZEPHIR_INIT_VAR(&_0); zephir_fast_strtolower(&_0, &ext); zephir_get_strval(&ext, &_0); - ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 465); + ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 466); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "gif"); - ZEPHIR_CALL_FUNCTION(&_2, "strcmp", NULL, 314, &ext, &_1); + ZEPHIR_CALL_FUNCTION(&_2, "strcmp", NULL, 315, &ext, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "jpg"); - ZEPHIR_CALL_FUNCTION(&_3, "strcmp", NULL, 314, &ext, &_1); + ZEPHIR_CALL_FUNCTION(&_3, "strcmp", NULL, 315, &ext, &_1); zephir_check_call_status(); _4 = ZEPHIR_IS_LONG(&_3, 0); if (!(_4)) { ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "jpeg"); - ZEPHIR_CALL_FUNCTION(&_5, "strcmp", NULL, 314, &ext, &_1); + ZEPHIR_CALL_FUNCTION(&_5, "strcmp", NULL, 315, &ext, &_1); zephir_check_call_status(); _4 = ZEPHIR_IS_LONG(&_5, 0); } ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "png"); - ZEPHIR_CALL_FUNCTION(&_6, "strcmp", NULL, 314, &ext, &_1); + ZEPHIR_CALL_FUNCTION(&_6, "strcmp", NULL, 315, &ext, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "wbmp"); - ZEPHIR_CALL_FUNCTION(&_7, "strcmp", NULL, 314, &ext, &_1); + ZEPHIR_CALL_FUNCTION(&_7, "strcmp", NULL, 315, &ext, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "xbm"); - ZEPHIR_CALL_FUNCTION(&_8, "strcmp", NULL, 314, &ext, &_1); + ZEPHIR_CALL_FUNCTION(&_8, "strcmp", NULL, 315, &ext, &_1); zephir_check_call_status(); if (ZEPHIR_IS_LONG(&_2, 0)) { zephir_read_property(&_9$$3, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagegif", NULL, 466, &_9$$3); + ZEPHIR_CALL_FUNCTION(NULL, "imagegif", NULL, 467, &_9$$3); zephir_check_call_status(); } else if (_4) { zephir_read_property(&_10$$4, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_11$$4, quality); - ZEPHIR_CALL_FUNCTION(NULL, "imagejpeg", NULL, 467, &_10$$4, &__$null, &_11$$4); + ZEPHIR_CALL_FUNCTION(NULL, "imagejpeg", NULL, 468, &_10$$4, &__$null, &_11$$4); zephir_check_call_status(); } else if (ZEPHIR_IS_LONG(&_6, 0)) { zephir_read_property(&_12$$5, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagepng", NULL, 468, &_12$$5); + ZEPHIR_CALL_FUNCTION(NULL, "imagepng", NULL, 469, &_12$$5); zephir_check_call_status(); } else if (ZEPHIR_IS_LONG(&_7, 0)) { zephir_read_property(&_13$$6, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagewbmp", NULL, 469, &_13$$6); + ZEPHIR_CALL_FUNCTION(NULL, "imagewbmp", NULL, 470, &_13$$6); zephir_check_call_status(); } else if (ZEPHIR_IS_LONG(&_8, 0)) { zephir_read_property(&_14$$7, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagexbm", NULL, 470, &_14$$7, &__$null); + ZEPHIR_CALL_FUNCTION(NULL, "imagexbm", NULL, 471, &_14$$7, &__$null); zephir_check_call_status(); } else { ZEPHIR_INIT_VAR(&_15$$8); @@ -1130,7 +1130,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processRender) ZEPHIR_MM_RESTORE(); return; } - ZEPHIR_RETURN_CALL_FUNCTION("ob_get_clean", NULL, 471); + ZEPHIR_RETURN_CALL_FUNCTION("ob_get_clean", NULL, 472); zephir_check_call_status(); RETURN_MM(); } @@ -1166,16 +1166,16 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processResize) zephir_read_property(&_0, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1, width); ZVAL_LONG(&_2, height); - ZEPHIR_CALL_FUNCTION(&image, "imagescale", NULL, 472, &_0, &_1, &_2); + ZEPHIR_CALL_FUNCTION(&image, "imagescale", NULL, 473, &_0, &_1, &_2); zephir_check_call_status(); zephir_read_property(&_1, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 449, &_1); + ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 450, &_1); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("image"), &image); - ZEPHIR_CALL_FUNCTION(&_3, "imagesx", NULL, 455, &image); + ZEPHIR_CALL_FUNCTION(&_3, "imagesx", NULL, 456, &image); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("width"), &_3); - ZEPHIR_CALL_FUNCTION(&_4, "imagesy", NULL, 456, &image); + ZEPHIR_CALL_FUNCTION(&_4, "imagesy", NULL, 457, &image); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("height"), &_4); ZEPHIR_MM_RESTORE(); @@ -1221,18 +1221,18 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processRotate) ZVAL_LONG(&_2, 0); ZVAL_LONG(&_3, 0); ZVAL_LONG(&_4, 127); - ZEPHIR_CALL_FUNCTION(&transparent, "imagecolorallocatealpha", NULL, 451, &_0, &_1, &_2, &_3, &_4); + ZEPHIR_CALL_FUNCTION(&transparent, "imagecolorallocatealpha", NULL, 452, &_0, &_1, &_2, &_3, &_4); zephir_check_call_status(); zephir_read_property(&_1, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_2, (360 - degrees)); ZVAL_LONG(&_3, 1); - ZEPHIR_CALL_FUNCTION(&image, "imagerotate", NULL, 473, &_1, &_2, &transparent, &_3); + ZEPHIR_CALL_FUNCTION(&image, "imagerotate", NULL, 474, &_1, &_2, &transparent, &_3); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 446, &image, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 447, &image, &__$true); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&width, "imagesx", NULL, 455, &image); + ZEPHIR_CALL_FUNCTION(&width, "imagesx", NULL, 456, &image); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&height, "imagesy", NULL, 456, &image); + ZEPHIR_CALL_FUNCTION(&height, "imagesy", NULL, 457, &image); zephir_check_call_status(); zephir_read_property(&_2, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_3, 0); @@ -1240,11 +1240,11 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processRotate) ZVAL_LONG(&_5, 0); ZVAL_LONG(&_6, 0); ZVAL_LONG(&_7, 100); - ZEPHIR_CALL_FUNCTION(&_8, "imagecopymerge", NULL, 474, &_2, &image, &_3, &_4, &_5, &_6, &width, &height, &_7); + ZEPHIR_CALL_FUNCTION(&_8, "imagecopymerge", NULL, 475, &_2, &image, &_3, &_4, &_5, &_6, &width, &height, &_7); zephir_check_call_status(); if (zephir_is_true(&_8)) { zephir_read_property(&_9$$3, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 449, &_9$$3); + ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 450, &_9$$3); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("image"), &image); zephir_update_property_zval(this_ptr, ZEND_STRL("width"), &width); @@ -1308,11 +1308,11 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSave) ZVAL_LONG(&_0, 4); - ZEPHIR_CALL_FUNCTION(&ext, "pathinfo", NULL, 116, &file, &_0); + ZEPHIR_CALL_FUNCTION(&ext, "pathinfo", NULL, 118, &file, &_0); zephir_check_call_status(); if (!(zephir_is_true(&ext))) { zephir_read_property(&_1$$3, this_ptr, ZEND_STRL("type"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&ext, "image_type_to_extension", NULL, 475, &_1$$3, &__$false); + ZEPHIR_CALL_FUNCTION(&ext, "image_type_to_extension", NULL, 476, &_1$$3, &__$false); zephir_check_call_status(); } ZEPHIR_INIT_VAR(&_2); @@ -1320,30 +1320,30 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSave) ZEPHIR_CPY_WRT(&ext, &_2); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "gif"); - ZEPHIR_CALL_FUNCTION(&_3, "strcmp", NULL, 314, &ext, &_2); + ZEPHIR_CALL_FUNCTION(&_3, "strcmp", NULL, 315, &ext, &_2); zephir_check_call_status(); if (ZEPHIR_IS_LONG(&_3, 0)) { ZEPHIR_INIT_ZVAL_NREF(_4$$4); ZVAL_LONG(&_4$$4, 1); zephir_update_property_zval(this_ptr, ZEND_STRL("type"), &_4$$4); zephir_read_property(&_4$$4, this_ptr, ZEND_STRL("type"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_5$$4, "image_type_to_mime_type", NULL, 476, &_4$$4); + ZEPHIR_CALL_FUNCTION(&_5$$4, "image_type_to_mime_type", NULL, 477, &_4$$4); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("mime"), &_5$$4); zephir_read_property(&_6$$4, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagegif", NULL, 466, &_6$$4, &file); + ZEPHIR_CALL_FUNCTION(NULL, "imagegif", NULL, 467, &_6$$4, &file); zephir_check_call_status(); RETURN_MM_BOOL(1); } ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "jpg"); - ZEPHIR_CALL_FUNCTION(&_7, "strcmp", NULL, 314, &ext, &_2); + ZEPHIR_CALL_FUNCTION(&_7, "strcmp", NULL, 315, &ext, &_2); zephir_check_call_status(); _8 = ZEPHIR_IS_LONG(&_7, 0); if (!(_8)) { ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "jpeg"); - ZEPHIR_CALL_FUNCTION(&_9, "strcmp", NULL, 314, &ext, &_2); + ZEPHIR_CALL_FUNCTION(&_9, "strcmp", NULL, 315, &ext, &_2); zephir_check_call_status(); _8 = ZEPHIR_IS_LONG(&_9, 0); } @@ -1352,7 +1352,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSave) ZVAL_LONG(&_10$$5, 2); zephir_update_property_zval(this_ptr, ZEND_STRL("type"), &_10$$5); zephir_read_property(&_10$$5, this_ptr, ZEND_STRL("type"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_11$$5, "image_type_to_mime_type", NULL, 476, &_10$$5); + ZEPHIR_CALL_FUNCTION(&_11$$5, "image_type_to_mime_type", NULL, 477, &_10$$5); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("mime"), &_11$$5); if (quality >= 0) { @@ -1363,63 +1363,63 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSave) } zephir_read_property(&_12$$6, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_13$$6, quality); - ZEPHIR_CALL_FUNCTION(NULL, "imagejpeg", NULL, 467, &_12$$6, &file, &_13$$6); + ZEPHIR_CALL_FUNCTION(NULL, "imagejpeg", NULL, 468, &_12$$6, &file, &_13$$6); zephir_check_call_status(); } else { zephir_read_property(&_14$$9, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagejpeg", NULL, 467, &_14$$9, &file); + ZEPHIR_CALL_FUNCTION(NULL, "imagejpeg", NULL, 468, &_14$$9, &file); zephir_check_call_status(); } RETURN_MM_BOOL(1); } ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "png"); - ZEPHIR_CALL_FUNCTION(&_15, "strcmp", NULL, 314, &ext, &_2); + ZEPHIR_CALL_FUNCTION(&_15, "strcmp", NULL, 315, &ext, &_2); zephir_check_call_status(); if (ZEPHIR_IS_LONG(&_15, 0)) { ZEPHIR_INIT_ZVAL_NREF(_16$$10); ZVAL_LONG(&_16$$10, 3); zephir_update_property_zval(this_ptr, ZEND_STRL("type"), &_16$$10); zephir_read_property(&_16$$10, this_ptr, ZEND_STRL("type"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_17$$10, "image_type_to_mime_type", NULL, 476, &_16$$10); + ZEPHIR_CALL_FUNCTION(&_17$$10, "image_type_to_mime_type", NULL, 477, &_16$$10); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("mime"), &_17$$10); zephir_read_property(&_18$$10, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagepng", NULL, 468, &_18$$10, &file); + ZEPHIR_CALL_FUNCTION(NULL, "imagepng", NULL, 469, &_18$$10, &file); zephir_check_call_status(); RETURN_MM_BOOL(1); } ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "wbmp"); - ZEPHIR_CALL_FUNCTION(&_19, "strcmp", NULL, 314, &ext, &_2); + ZEPHIR_CALL_FUNCTION(&_19, "strcmp", NULL, 315, &ext, &_2); zephir_check_call_status(); if (ZEPHIR_IS_LONG(&_19, 0)) { ZEPHIR_INIT_ZVAL_NREF(_20$$11); ZVAL_LONG(&_20$$11, 15); zephir_update_property_zval(this_ptr, ZEND_STRL("type"), &_20$$11); zephir_read_property(&_20$$11, this_ptr, ZEND_STRL("type"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_21$$11, "image_type_to_mime_type", NULL, 476, &_20$$11); + ZEPHIR_CALL_FUNCTION(&_21$$11, "image_type_to_mime_type", NULL, 477, &_20$$11); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("mime"), &_21$$11); zephir_read_property(&_22$$11, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagewbmp", NULL, 469, &_22$$11, &file); + ZEPHIR_CALL_FUNCTION(NULL, "imagewbmp", NULL, 470, &_22$$11, &file); zephir_check_call_status(); RETURN_MM_BOOL(1); } ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "xbm"); - ZEPHIR_CALL_FUNCTION(&_23, "strcmp", NULL, 314, &ext, &_2); + ZEPHIR_CALL_FUNCTION(&_23, "strcmp", NULL, 315, &ext, &_2); zephir_check_call_status(); if (ZEPHIR_IS_LONG(&_23, 0)) { ZEPHIR_INIT_ZVAL_NREF(_24$$12); ZVAL_LONG(&_24$$12, 16); zephir_update_property_zval(this_ptr, ZEND_STRL("type"), &_24$$12); zephir_read_property(&_24$$12, this_ptr, ZEND_STRL("type"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_25$$12, "image_type_to_mime_type", NULL, 476, &_24$$12); + ZEPHIR_CALL_FUNCTION(&_25$$12, "image_type_to_mime_type", NULL, 477, &_24$$12); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("mime"), &_25$$12); zephir_read_property(&_26$$12, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagexbm", NULL, 470, &_26$$12, &file); + ZEPHIR_CALL_FUNCTION(NULL, "imagexbm", NULL, 471, &_26$$12, &file); zephir_check_call_status(); RETURN_MM_BOOL(1); } @@ -1471,7 +1471,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSharpen) ZEPHIR_INIT_VAR(&_0); ZVAL_LONG(&_1, (-18 + ((amount * 0.08)))); - ZEPHIR_CALL_FUNCTION(&_2, "abs", NULL, 305, &_1); + ZEPHIR_CALL_FUNCTION(&_2, "abs", NULL, 306, &_1); zephir_check_call_status(); ZVAL_LONG(&_1, 2); zephir_round(&_0, &_2, &_1, NULL); @@ -1517,15 +1517,15 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processSharpen) zephir_read_property(&_5, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_6, (amount - 8)); ZVAL_LONG(&_7, 0); - ZEPHIR_CALL_FUNCTION(&_8, "imageconvolution", NULL, 477, &_5, &matrix, &_6, &_7); + ZEPHIR_CALL_FUNCTION(&_8, "imageconvolution", NULL, 478, &_5, &matrix, &_6, &_7); zephir_check_call_status(); if (zephir_is_true(&_8)) { zephir_read_property(&_9$$3, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_10$$3, "imagesx", NULL, 455, &_9$$3); + ZEPHIR_CALL_FUNCTION(&_10$$3, "imagesx", NULL, 456, &_9$$3); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("width"), &_10$$3); zephir_read_property(&_11$$3, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_12$$3, "imagesy", NULL, 456, &_11$$3); + ZEPHIR_CALL_FUNCTION(&_12$$3, "imagesy", NULL, 457, &_11$$3); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("height"), &_12$$3); } @@ -1605,14 +1605,14 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processText) topRightY = 0; ZEPHIR_INIT_VAR(&_0); ZVAL_DOUBLE(&_1, ((zephir_safe_div_long_long((opacity * 127), 100)) - (double) (127))); - ZEPHIR_CALL_FUNCTION(&_2, "abs", NULL, 305, &_1); + ZEPHIR_CALL_FUNCTION(&_2, "abs", NULL, 306, &_1); zephir_check_call_status(); zephir_round(&_0, &_2, NULL, NULL); opacity = zephir_get_intval(&_0); if (!(ZEPHIR_IS_EMPTY(&fontfile))) { ZVAL_LONG(&_3$$3, size); ZVAL_LONG(&_4$$3, 0); - ZEPHIR_CALL_FUNCTION(&space, "imagettfbbox", NULL, 478, &_3$$3, &_4$$3, &fontfile, &text); + ZEPHIR_CALL_FUNCTION(&space, "imagettfbbox", NULL, 479, &_3$$3, &_4$$3, &fontfile, &text); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&space)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_image_exception_ce, "Call to imagettfbbox() failed", "phalcon/Image/Adapter/Gd.zep", 618); @@ -1633,11 +1633,11 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processText) topRightY = zephir_get_intval(&_8$$5); } ZVAL_LONG(&_3$$3, (topRightX - bottomLeftX)); - ZEPHIR_CALL_FUNCTION(&_9$$3, "abs", NULL, 305, &_3$$3); + ZEPHIR_CALL_FUNCTION(&_9$$3, "abs", NULL, 306, &_3$$3); zephir_check_call_status(); width = (zephir_get_numberval(&_9$$3) + 10); ZVAL_LONG(&_3$$3, (topRightY - bottomLeftY)); - ZEPHIR_CALL_FUNCTION(&_10$$3, "abs", NULL, 305, &_3$$3); + ZEPHIR_CALL_FUNCTION(&_10$$3, "abs", NULL, 306, &_3$$3); zephir_check_call_status(); height = (zephir_get_numberval(&_10$$3) + 10); if (offsetX < 0) { @@ -1653,7 +1653,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processText) ZVAL_LONG(&_13$$3, g); ZVAL_LONG(&_14$$3, b); ZVAL_LONG(&_15$$3, opacity); - ZEPHIR_CALL_FUNCTION(&color, "imagecolorallocatealpha", NULL, 451, &_3$$3, &_4$$3, &_13$$3, &_14$$3, &_15$$3); + ZEPHIR_CALL_FUNCTION(&color, "imagecolorallocatealpha", NULL, 452, &_3$$3, &_4$$3, &_13$$3, &_14$$3, &_15$$3); zephir_check_call_status(); angle = 0; zephir_read_property(&_4$$3, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); @@ -1661,15 +1661,15 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processText) ZVAL_LONG(&_14$$3, angle); ZVAL_LONG(&_15$$3, offsetX); ZVAL_LONG(&_16$$3, offsetY); - ZEPHIR_CALL_FUNCTION(NULL, "imagettftext", NULL, 479, &_4$$3, &_13$$3, &_14$$3, &_15$$3, &_16$$3, &color, &fontfile, &text); + ZEPHIR_CALL_FUNCTION(NULL, "imagettftext", NULL, 480, &_4$$3, &_13$$3, &_14$$3, &_15$$3, &_16$$3, &color, &fontfile, &text); zephir_check_call_status(); } else { ZVAL_LONG(&_17$$8, size); - ZEPHIR_CALL_FUNCTION(&_18$$8, "imagefontwidth", NULL, 480, &_17$$8); + ZEPHIR_CALL_FUNCTION(&_18$$8, "imagefontwidth", NULL, 481, &_17$$8); zephir_check_call_status(); width = (zephir_get_intval(&_18$$8) * zephir_fast_strlen_ev(&text)); ZVAL_LONG(&_17$$8, size); - ZEPHIR_CALL_FUNCTION(&_19$$8, "imagefontheight", NULL, 481, &_17$$8); + ZEPHIR_CALL_FUNCTION(&_19$$8, "imagefontheight", NULL, 482, &_17$$8); zephir_check_call_status(); height = zephir_get_intval(&_19$$8); if (offsetX < 0) { @@ -1685,13 +1685,13 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processText) ZVAL_LONG(&_23$$8, g); ZVAL_LONG(&_24$$8, b); ZVAL_LONG(&_25$$8, opacity); - ZEPHIR_CALL_FUNCTION(&color, "imagecolorallocatealpha", NULL, 451, &_17$$8, &_22$$8, &_23$$8, &_24$$8, &_25$$8); + ZEPHIR_CALL_FUNCTION(&color, "imagecolorallocatealpha", NULL, 452, &_17$$8, &_22$$8, &_23$$8, &_24$$8, &_25$$8); zephir_check_call_status(); zephir_read_property(&_22$$8, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_23$$8, size); ZVAL_LONG(&_24$$8, offsetX); ZVAL_LONG(&_25$$8, offsetY); - ZEPHIR_CALL_FUNCTION(NULL, "imagestring", NULL, 482, &_22$$8, &_23$$8, &_24$$8, &_25$$8, &text, &color); + ZEPHIR_CALL_FUNCTION(NULL, "imagestring", NULL, 483, &_22$$8, &_23$$8, &_24$$8, &_25$$8, &text, &color); zephir_check_call_status(); } ZEPHIR_MM_RESTORE(); @@ -1746,20 +1746,20 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processWatermark) ZEPHIR_CALL_METHOD(&_0, watermark, "render", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&overlay, "imagecreatefromstring", NULL, 458, &_0); + ZEPHIR_CALL_FUNCTION(&overlay, "imagecreatefromstring", NULL, 459, &_0); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 446, &overlay, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 447, &overlay, &__$true); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&_1, "imagesx", NULL, 455, &overlay); + ZEPHIR_CALL_FUNCTION(&_1, "imagesx", NULL, 456, &overlay); zephir_check_call_status(); width = zephir_get_intval(&_1); - ZEPHIR_CALL_FUNCTION(&_2, "imagesy", NULL, 456, &overlay); + ZEPHIR_CALL_FUNCTION(&_2, "imagesy", NULL, 457, &overlay); zephir_check_call_status(); height = zephir_get_intval(&_2); if (opacity < 100) { ZEPHIR_INIT_VAR(&_3$$3); ZVAL_DOUBLE(&_4$$3, ((zephir_safe_div_long_long((opacity * 127), 100)) - (double) (127))); - ZEPHIR_CALL_FUNCTION(&_5$$3, "abs", NULL, 305, &_4$$3); + ZEPHIR_CALL_FUNCTION(&_5$$3, "abs", NULL, 306, &_4$$3); zephir_check_call_status(); zephir_round(&_3$$3, &_5$$3, NULL, NULL); opacity = zephir_get_intval(&_3$$3); @@ -1767,20 +1767,20 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processWatermark) ZVAL_LONG(&_6$$3, 127); ZVAL_LONG(&_7$$3, 127); ZVAL_LONG(&_8$$3, opacity); - ZEPHIR_CALL_FUNCTION(&color, "imagecolorallocatealpha", NULL, 451, &overlay, &_4$$3, &_6$$3, &_7$$3, &_8$$3); + ZEPHIR_CALL_FUNCTION(&color, "imagecolorallocatealpha", NULL, 452, &overlay, &_4$$3, &_6$$3, &_7$$3, &_8$$3); zephir_check_call_status(); ZVAL_LONG(&_4$$3, 3); - ZEPHIR_CALL_FUNCTION(NULL, "imagelayereffect", NULL, 483, &overlay, &_4$$3); + ZEPHIR_CALL_FUNCTION(NULL, "imagelayereffect", NULL, 484, &overlay, &_4$$3); zephir_check_call_status(); ZVAL_LONG(&_4$$3, 0); ZVAL_LONG(&_6$$3, 0); ZVAL_LONG(&_7$$3, width); ZVAL_LONG(&_8$$3, height); - ZEPHIR_CALL_FUNCTION(NULL, "imagefilledrectangle", NULL, 464, &overlay, &_4$$3, &_6$$3, &_7$$3, &_8$$3, &color); + ZEPHIR_CALL_FUNCTION(NULL, "imagefilledrectangle", NULL, 465, &overlay, &_4$$3, &_6$$3, &_7$$3, &_8$$3, &color); zephir_check_call_status(); } zephir_read_property(&_9, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagealphablending", NULL, 448, &_9, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "imagealphablending", NULL, 449, &_9, &__$true); zephir_check_call_status(); zephir_read_property(&_10, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_11, offsetX); @@ -1789,10 +1789,10 @@ PHP_METHOD(Phalcon_Image_Adapter_Gd, processWatermark) ZVAL_LONG(&_14, 0); ZVAL_LONG(&_15, width); ZVAL_LONG(&_16, height); - ZEPHIR_CALL_FUNCTION(&_17, "imagecopy", NULL, 452, &_10, &overlay, &_11, &_12, &_13, &_14, &_15, &_16); + ZEPHIR_CALL_FUNCTION(&_17, "imagecopy", NULL, 453, &_10, &overlay, &_11, &_12, &_13, &_14, &_15, &_16); zephir_check_call_status(); if (zephir_is_true(&_17)) { - ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 449, &overlay); + ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 450, &overlay); zephir_check_call_status(); } ZEPHIR_MM_RESTORE(); diff --git a/ext/phalcon/image/adapter/imagick.zep.c b/ext/phalcon/image/adapter/imagick.zep.c index 3dd389d3e88..cf7ecb81590 100644 --- a/ext/phalcon/image/adapter/imagick.zep.c +++ b/ext/phalcon/image/adapter/imagick.zep.c @@ -1494,7 +1494,7 @@ PHP_METHOD(Phalcon_Image_Adapter_Imagick, processSave) ZVAL_LONG(&_0, 4); - ZEPHIR_CALL_FUNCTION(&ext, "pathinfo", NULL, 116, &file, &_0); + ZEPHIR_CALL_FUNCTION(&ext, "pathinfo", NULL, 118, &file, &_0); zephir_check_call_status(); zephir_read_property(&_0, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); ZEPHIR_CALL_METHOD(NULL, &_0, "setformat", NULL, 0, &ext); diff --git a/ext/phalcon/image/imagefactory.zep.c b/ext/phalcon/image/imagefactory.zep.c index 7a87ae53f6a..dee258fc525 100644 --- a/ext/phalcon/image/imagefactory.zep.c +++ b/ext/phalcon/image/imagefactory.zep.c @@ -131,17 +131,17 @@ PHP_METHOD(Phalcon_Image_ImageFactory, load) zephir_array_unset_string(config, SL("adapter"), PH_SEPARATE); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "file"); - ZEPHIR_CALL_METHOD(&file, this_ptr, "getarrval", NULL, 484, config, &_1); + ZEPHIR_CALL_METHOD(&file, this_ptr, "getarrval", NULL, 485, config, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "height"); ZVAL_NULL(&_2); - ZEPHIR_CALL_METHOD(&height, this_ptr, "getarrval", NULL, 484, config, &_1, &_2); + ZEPHIR_CALL_METHOD(&height, this_ptr, "getarrval", NULL, 485, config, &_1, &_2); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "width"); ZVAL_NULL(&_2); - ZEPHIR_CALL_METHOD(&width, this_ptr, "getarrval", NULL, 484, config, &_1, &_2); + ZEPHIR_CALL_METHOD(&width, this_ptr, "getarrval", NULL, 485, config, &_1, &_2); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "newinstance", NULL, 0, &name, &file, &width, &height); zephir_check_call_status(); diff --git a/ext/phalcon/logger/adapter/stream.zep.c b/ext/phalcon/logger/adapter/stream.zep.c index e866bc6c774..e45063d52de 100644 --- a/ext/phalcon/logger/adapter/stream.zep.c +++ b/ext/phalcon/logger/adapter/stream.zep.c @@ -146,7 +146,7 @@ PHP_METHOD(Phalcon_Logger_Adapter_Stream, __construct) } ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "r"); - ZEPHIR_CALL_FUNCTION(&_1, "mb_strpos", NULL, 485, &mode, &_0); + ZEPHIR_CALL_FUNCTION(&_1, "mb_strpos", NULL, 113, &mode, &_0); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&_1)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_logger_exception_ce, "Adapter cannot be opened in read mode", "phalcon/Logger/Adapter/Stream.zep", 84); diff --git a/ext/phalcon/mvc/model.zep.c b/ext/phalcon/mvc/model.zep.c index ae5ce9c148d..f760ba79ff7 100644 --- a/ext/phalcon/mvc/model.zep.c +++ b/ext/phalcon/mvc/model.zep.c @@ -702,7 +702,7 @@ PHP_METHOD(Phalcon_Mvc_Model, __set) RETVAL_ZVAL(value, 1, 0); RETURN_MM(); } - ZEPHIR_CALL_FUNCTION(&_15, "property_exists", NULL, 310, this_ptr, &property); + ZEPHIR_CALL_FUNCTION(&_15, "property_exists", NULL, 311, this_ptr, &property); zephir_check_call_status(); if (zephir_is_true(&_15)) { ZEPHIR_CALL_METHOD(&manager, this_ptr, "getmodelsmanager", NULL, 0); diff --git a/ext/phalcon/mvc/model/criteria.zep.c b/ext/phalcon/mvc/model/criteria.zep.c index e1c4aa28e1a..64047ba0fa4 100644 --- a/ext/phalcon/mvc/model/criteria.zep.c +++ b/ext/phalcon/mvc/model/criteria.zep.c @@ -1459,11 +1459,11 @@ PHP_METHOD(Phalcon_Mvc_Model_Criteria, limit) ZVAL_LONG(&_0, limit); - ZEPHIR_CALL_FUNCTION(&_1, "abs", NULL, 305, &_0); + ZEPHIR_CALL_FUNCTION(&_1, "abs", NULL, 306, &_0); zephir_check_call_status(); limit = zephir_get_numberval(&_1); ZVAL_LONG(&_0, offset); - ZEPHIR_CALL_FUNCTION(&_2, "abs", NULL, 305, &_0); + ZEPHIR_CALL_FUNCTION(&_2, "abs", NULL, 306, &_0); zephir_check_call_status(); offset = zephir_get_numberval(&_2); if (UNEXPECTED(limit == 0)) { diff --git a/ext/phalcon/mvc/model/query.zep.c b/ext/phalcon/mvc/model/query.zep.c index 8162687719e..9d1ce69f7fa 100644 --- a/ext/phalcon/mvc/model/query.zep.c +++ b/ext/phalcon/mvc/model/query.zep.c @@ -447,13 +447,13 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, execute) zephir_check_call_status(); ZEPHIR_INIT_VAR(&_2$$3); ZVAL_STRING(&_2$$3, "Phalcon\\Cache\\CacheInterface"); - ZEPHIR_CALL_FUNCTION(&_3$$3, "is_a", NULL, 118, &cache, &_2$$3); + ZEPHIR_CALL_FUNCTION(&_3$$3, "is_a", NULL, 114, &cache, &_2$$3); zephir_check_call_status(); _4$$3 = !ZEPHIR_IS_TRUE_IDENTICAL(&_3$$3); if (_4$$3) { ZEPHIR_INIT_NVAR(&_2$$3); ZVAL_STRING(&_2$$3, "Psr\\SimpleCache\\CacheInterface"); - ZEPHIR_CALL_FUNCTION(&_5$$3, "is_a", NULL, 118, &cache, &_2$$3); + ZEPHIR_CALL_FUNCTION(&_5$$3, "is_a", NULL, 114, &cache, &_2$$3); zephir_check_call_status(); _4$$3 = !ZEPHIR_IS_TRUE_IDENTICAL(&_5$$3); } diff --git a/ext/phalcon/mvc/model/query/builder.zep.c b/ext/phalcon/mvc/model/query/builder.zep.c index c63e3202599..8accc2d9e5e 100644 --- a/ext/phalcon/mvc/model/query/builder.zep.c +++ b/ext/phalcon/mvc/model/query/builder.zep.c @@ -2495,7 +2495,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, limit) ZVAL_LONG(&_0, limit); - ZEPHIR_CALL_FUNCTION(&_1, "abs", NULL, 305, &_0); + ZEPHIR_CALL_FUNCTION(&_1, "abs", NULL, 306, &_0); zephir_check_call_status(); limit = zephir_get_numberval(&_1); if (UNEXPECTED(limit == 0)) { @@ -2506,7 +2506,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, limit) zephir_update_property_zval(this_ptr, ZEND_STRL("limit"), &_0); if (zephir_is_numeric(offset)) { ZVAL_LONG(&_2$$4, zephir_get_intval(offset)); - ZEPHIR_CALL_FUNCTION(&_3$$4, "abs", NULL, 305, &_2$$4); + ZEPHIR_CALL_FUNCTION(&_3$$4, "abs", NULL, 306, &_2$$4); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("offset"), &_3$$4); } diff --git a/ext/phalcon/mvc/model/resultset.zep.c b/ext/phalcon/mvc/model/resultset.zep.c index d3dee98b547..3384f997872 100644 --- a/ext/phalcon/mvc/model/resultset.zep.c +++ b/ext/phalcon/mvc/model/resultset.zep.c @@ -202,13 +202,13 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset, __construct) if (Z_TYPE_P(cache) != IS_NULL) { ZEPHIR_INIT_VAR(&_2$$4); ZVAL_STRING(&_2$$4, "Phalcon\\Cache\\CacheInterface"); - ZEPHIR_CALL_FUNCTION(&_3$$4, "is_a", NULL, 118, cache, &_2$$4); + ZEPHIR_CALL_FUNCTION(&_3$$4, "is_a", NULL, 114, cache, &_2$$4); zephir_check_call_status(); _4$$4 = !ZEPHIR_IS_TRUE_IDENTICAL(&_3$$4); if (_4$$4) { ZEPHIR_INIT_NVAR(&_2$$4); ZVAL_STRING(&_2$$4, "Psr\\SimpleCache\\CacheInterface"); - ZEPHIR_CALL_FUNCTION(&_5$$4, "is_a", NULL, 118, cache, &_2$$4); + ZEPHIR_CALL_FUNCTION(&_5$$4, "is_a", NULL, 114, cache, &_2$$4); zephir_check_call_status(); _4$$4 = !ZEPHIR_IS_TRUE_IDENTICAL(&_5$$4); } @@ -314,7 +314,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset, delete) ZVAL_NULL(&connection); result = 1; transaction = 0; - ZEPHIR_CALL_METHOD(NULL, this_ptr, "rewind", NULL, 119); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "rewind", NULL, 120); zephir_check_call_status(); while (1) { ZEPHIR_CALL_METHOD(&_0, this_ptr, "valid", &_1, 0); @@ -413,7 +413,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset, filter) ZEPHIR_INIT_VAR(&records); array_init(&records); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "rewind", NULL, 119); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "rewind", NULL, 120); zephir_check_call_status(); while (1) { ZEPHIR_CALL_METHOD(&_0, this_ptr, "valid", &_1, 0); @@ -500,7 +500,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset, getFirst) RETURN_MM_NULL(); } ZVAL_LONG(&_1, 0); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "seek", NULL, 120, &_1); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "seek", NULL, 121, &_1); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "current", NULL, 0); zephir_check_call_status(); @@ -541,7 +541,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset, getLast) RETURN_MM_NULL(); } ZVAL_LONG(&_0, (zephir_get_numberval(&count) - 1)); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "seek", NULL, 120, &_0); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "seek", NULL, 121, &_0); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "current", NULL, 0); zephir_check_call_status(); @@ -628,7 +628,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset, jsonSerialize) ZEPHIR_INIT_VAR(&records); array_init(&records); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "rewind", NULL, 119); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "rewind", NULL, 120); zephir_check_call_status(); while (1) { ZEPHIR_CALL_METHOD(&_0, this_ptr, "valid", &_1, 0); @@ -696,7 +696,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset, next) zephir_read_property(&_0, this_ptr, ZEND_STRL("pointer"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_1, (zephir_get_numberval(&_0) + 1)); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "seek", NULL, 120, &_1); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "seek", NULL, 121, &_1); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); } @@ -730,7 +730,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset, offsetGet) ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "The index does not exist in the cursor", "phalcon/Mvc/Model/Resultset.zep", 497); return; } - ZEPHIR_CALL_METHOD(NULL, this_ptr, "seek", NULL, 120, index); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "seek", NULL, 121, index); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "current", NULL, 0); zephir_check_call_status(); @@ -831,7 +831,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset, rewind) ZEPHIR_MM_GROW(); ZVAL_LONG(&_0, 0); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "seek", NULL, 120, &_0); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "seek", NULL, 121, &_0); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); } @@ -1038,7 +1038,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset, update) ZEPHIR_INIT_VAR(&connection); ZVAL_NULL(&connection); transaction = 0; - ZEPHIR_CALL_METHOD(NULL, this_ptr, "rewind", NULL, 119); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "rewind", NULL, 120); zephir_check_call_status(); while (1) { ZEPHIR_CALL_METHOD(&_0, this_ptr, "valid", &_1, 0); diff --git a/ext/phalcon/mvc/model/resultset/complex.zep.c b/ext/phalcon/mvc/model/resultset/complex.zep.c index c4a44ae1bdf..5716d24080f 100644 --- a/ext/phalcon/mvc/model/resultset/complex.zep.c +++ b/ext/phalcon/mvc/model/resultset/complex.zep.c @@ -503,7 +503,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, toArray) ZEPHIR_INIT_VAR(&records); array_init(&records); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "rewind", NULL, 119); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "rewind", NULL, 120); zephir_check_call_status(); while (1) { ZEPHIR_CALL_METHOD(&_0, this_ptr, "valid", &_1, 0); diff --git a/ext/phalcon/mvc/view.zep.c b/ext/phalcon/mvc/view.zep.c index 0c16c175911..502cff6b34e 100644 --- a/ext/phalcon/mvc/view.zep.c +++ b/ext/phalcon/mvc/view.zep.c @@ -764,11 +764,11 @@ PHP_METHOD(Phalcon_Mvc_View, getPartial) } - ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 465); + ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 466); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, this_ptr, "partial", NULL, 0, &partialPath, params); zephir_check_call_status(); - ZEPHIR_RETURN_CALL_FUNCTION("ob_get_clean", NULL, 471); + ZEPHIR_RETURN_CALL_FUNCTION("ob_get_clean", NULL, 472); zephir_check_call_status(); RETURN_MM(); } @@ -2039,7 +2039,7 @@ PHP_METHOD(Phalcon_Mvc_View, start) ZEPHIR_MM_GROW(); - ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 465); + ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 466); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("content"), &__$null); RETURN_THIS(); diff --git a/ext/phalcon/mvc/view/engine/volt.zep.c b/ext/phalcon/mvc/view/engine/volt.zep.c index 7567372536d..8692cece68e 100644 --- a/ext/phalcon/mvc/view/engine/volt.zep.c +++ b/ext/phalcon/mvc/view/engine/volt.zep.c @@ -195,12 +195,12 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, convertEncoding) _1 = ZEPHIR_IS_STRING_IDENTICAL(&from, "utf8"); } if (_1) { - ZEPHIR_RETURN_CALL_FUNCTION("utf8_decode", NULL, 306, &text); + ZEPHIR_RETURN_CALL_FUNCTION("utf8_decode", NULL, 307, &text); zephir_check_call_status(); RETURN_MM(); } if ((zephir_function_exists_ex(ZEND_STRL("mb_convert_encoding")) == SUCCESS)) { - ZEPHIR_RETURN_CALL_FUNCTION("mb_convert_encoding", NULL, 350, &text, &from, &to); + ZEPHIR_RETURN_CALL_FUNCTION("mb_convert_encoding", NULL, 351, &text, &from, &to); zephir_check_call_status(); RETURN_MM(); } @@ -320,7 +320,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, isIncluded) } if (Z_TYPE_P(haystack) == IS_STRING) { if ((zephir_function_exists_ex(ZEND_STRL("mb_strpos")) == SUCCESS)) { - ZEPHIR_CALL_FUNCTION(&_0$$5, "mb_strpos", NULL, 485, haystack, needle); + ZEPHIR_CALL_FUNCTION(&_0$$5, "mb_strpos", NULL, 113, haystack, needle); zephir_check_call_status(); RETURN_MM_BOOL(!ZEPHIR_IS_FALSE_IDENTICAL(&_0$$5)); } diff --git a/ext/phalcon/mvc/view/engine/volt/compiler.zep.c b/ext/phalcon/mvc/view/engine/volt/compiler.zep.c index ff3f5783747..1222d9e10ea 100644 --- a/ext/phalcon/mvc/view/engine/volt/compiler.zep.c +++ b/ext/phalcon/mvc/view/engine/volt/compiler.zep.c @@ -3961,7 +3961,7 @@ PHP_METHOD(Phalcon_Mvc_View_Engine_Volt_Compiler, resolveFilter) zephir_array_update_string(&_4$$7, SL("file"), &file, PH_COPY | PH_SEPARATE); zephir_array_update_string(&_4$$7, SL("line"), &line, PH_COPY | PH_SEPARATE); ZEPHIR_MAKE_REF(&funcArguments); - ZEPHIR_CALL_FUNCTION(NULL, "array_unshift", NULL, 291, &funcArguments, &_4$$7); + ZEPHIR_CALL_FUNCTION(NULL, "array_unshift", NULL, 292, &funcArguments, &_4$$7); ZEPHIR_UNREF(&funcArguments); zephir_check_call_status(); } diff --git a/ext/phalcon/mvc/view/simple.zep.c b/ext/phalcon/mvc/view/simple.zep.c index 22be4a46582..1d1915fb336 100644 --- a/ext/phalcon/mvc/view/simple.zep.c +++ b/ext/phalcon/mvc/view/simple.zep.c @@ -417,7 +417,7 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, partial) } - ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 465); + ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 466); zephir_check_call_status(); if (Z_TYPE_P(params) == IS_ARRAY) { zephir_read_property(&_0$$3, this_ptr, ZEND_STRL("viewParams"), PH_NOISY_CC | PH_READONLY); @@ -534,7 +534,7 @@ PHP_METHOD(Phalcon_Mvc_View_Simple, render) ZEPHIR_INIT_VAR(&_0); ZEPHIR_CREATE_SYMBOL_TABLE(); - ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 465); + ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 466); zephir_check_call_status(); zephir_read_property(&_1, this_ptr, ZEND_STRL("viewParams"), PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&viewParams, &_1); diff --git a/ext/phalcon/session/adapter/stream.zep.c b/ext/phalcon/session/adapter/stream.zep.c index 698f1409818..84d2acf5783 100644 --- a/ext/phalcon/session/adapter/stream.zep.c +++ b/ext/phalcon/session/adapter/stream.zep.c @@ -748,7 +748,7 @@ PHP_METHOD(Phalcon_Session_Adapter_Stream, phpIsWritable) zephir_get_strval(&filename, filename_param); - ZEPHIR_RETURN_CALL_FUNCTION("is_writable", NULL, 401, &filename); + ZEPHIR_RETURN_CALL_FUNCTION("is_writable", NULL, 402, &filename); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/session/manager.zep.c b/ext/phalcon/session/manager.zep.c index 049a46abea4..479dcf14ed7 100644 --- a/ext/phalcon/session/manager.zep.c +++ b/ext/phalcon/session/manager.zep.c @@ -868,7 +868,7 @@ PHP_METHOD(Phalcon_Session_Manager, phpHeadersSent) ZEPHIR_MM_GROW(); - ZEPHIR_RETURN_CALL_FUNCTION("headers_sent", NULL, 439); + ZEPHIR_RETURN_CALL_FUNCTION("headers_sent", NULL, 440); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/phalcon/storage/adapter/stream.zep.c b/ext/phalcon/storage/adapter/stream.zep.c index c55d1d55872..c4f8742e2cb 100644 --- a/ext/phalcon/storage/adapter/stream.zep.c +++ b/ext/phalcon/storage/adapter/stream.zep.c @@ -1387,7 +1387,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, getDirFromFile) ZVAL_LONG(&_0, 8); - ZEPHIR_CALL_FUNCTION(&name, "pathinfo", NULL, 116, &file, &_0); + ZEPHIR_CALL_FUNCTION(&name, "pathinfo", NULL, 118, &file, &_0); zephir_check_call_status(); ZVAL_LONG(&_0, 0); ZVAL_LONG(&_1, -2); @@ -1410,7 +1410,7 @@ PHP_METHOD(Phalcon_Storage_Adapter_Stream, getDirFromFile) } ZEPHIR_INIT_VAR(&_7); ZVAL_LONG(&_8, 2); - ZEPHIR_CALL_FUNCTION(&_9, "str_split", NULL, 115, &start, &_8); + ZEPHIR_CALL_FUNCTION(&_9, "str_split", NULL, 117, &start, &_8); zephir_check_call_status(); zephir_fast_join_str(&_7, SL("/"), &_9); ZEPHIR_CONCAT_VS(return_value, &_7, "/"); diff --git a/ext/phalcon/support/helper/arr/last.zep.c b/ext/phalcon/support/helper/arr/last.zep.c index fd66e694fae..5b686e338c1 100644 --- a/ext/phalcon/support/helper/arr/last.zep.c +++ b/ext/phalcon/support/helper/arr/last.zep.c @@ -77,7 +77,7 @@ PHP_METHOD(Phalcon_Support_Helper_Arr_Last, __invoke) ZEPHIR_CALL_METHOD(&filtered, this_ptr, "tofilter", NULL, 0, &collection, method); zephir_check_call_status(); ZEPHIR_MAKE_REF(&filtered); - ZEPHIR_RETURN_CALL_FUNCTION("end", NULL, 344, &filtered); + ZEPHIR_RETURN_CALL_FUNCTION("end", NULL, 345, &filtered); ZEPHIR_UNREF(&filtered); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/phalcon/support/helper/file/basename.zep.c b/ext/phalcon/support/helper/file/basename.zep.c index 8550d09fdd2..0e4f4bebf53 100644 --- a/ext/phalcon/support/helper/file/basename.zep.c +++ b/ext/phalcon/support/helper/file/basename.zep.c @@ -100,7 +100,7 @@ PHP_METHOD(Phalcon_Support_Helper_File_Basename, __invoke) ZVAL_STRING(&_2, "/"); ZEPHIR_INIT_VAR(&_3); ZVAL_STRING(&_3, "@"); - ZEPHIR_CALL_FUNCTION(&_4, "preg_quote", NULL, 438, &_2, &_3); + ZEPHIR_CALL_FUNCTION(&_4, "preg_quote", NULL, 439, &_2, &_3); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_5); ZEPHIR_CONCAT_SVS(&_5, "@[^", &_4, "]+$@"); @@ -116,7 +116,7 @@ PHP_METHOD(Phalcon_Support_Helper_File_Basename, __invoke) if (1 != ZEPHIR_IS_EMPTY(&suffix)) { ZEPHIR_INIT_VAR(&_6$$3); ZVAL_STRING(&_6$$3, "@"); - ZEPHIR_CALL_FUNCTION(&_7$$3, "preg_quote", NULL, 438, &suffix, &_6$$3); + ZEPHIR_CALL_FUNCTION(&_7$$3, "preg_quote", NULL, 439, &suffix, &_6$$3); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_8$$3); ZEPHIR_CONCAT_SVS(&_8$$3, "@", &_7$$3, "$@"); diff --git a/ext/phalcon/support/helper/str/concat.zep.c b/ext/phalcon/support/helper/str/concat.zep.c index 2e8ba565f3d..6b9698088da 100644 --- a/ext/phalcon/support/helper/str/concat.zep.c +++ b/ext/phalcon/support/helper/str/concat.zep.c @@ -93,7 +93,7 @@ PHP_METHOD(Phalcon_Support_Helper_Str_Concat, __invoke) ZEPHIR_UNREF(&arguments); zephir_check_call_status(); ZEPHIR_MAKE_REF(&arguments); - ZEPHIR_CALL_FUNCTION(&last, "end", NULL, 344, &arguments); + ZEPHIR_CALL_FUNCTION(&last, "end", NULL, 345, &arguments); ZEPHIR_UNREF(&arguments); zephir_check_call_status(); ZEPHIR_INIT_VAR(&prefix); diff --git a/ext/phalcon/support/helper/str/dirfromfile.zep.c b/ext/phalcon/support/helper/str/dirfromfile.zep.c index d7c78078210..7dde5654406 100644 --- a/ext/phalcon/support/helper/str/dirfromfile.zep.c +++ b/ext/phalcon/support/helper/str/dirfromfile.zep.c @@ -75,7 +75,7 @@ PHP_METHOD(Phalcon_Support_Helper_Str_DirFromFile, __invoke) ZVAL_LONG(&_0, 8); - ZEPHIR_CALL_FUNCTION(&name, "pathinfo", NULL, 116, &file, &_0); + ZEPHIR_CALL_FUNCTION(&name, "pathinfo", NULL, 118, &file, &_0); zephir_check_call_status(); ZVAL_LONG(&_0, 0); ZVAL_LONG(&_1, -2); diff --git a/ext/phalcon/support/helper/str/dynamic.zep.c b/ext/phalcon/support/helper/str/dynamic.zep.c index 6eac40be677..268d0e42fda 100644 --- a/ext/phalcon/support/helper/str/dynamic.zep.c +++ b/ext/phalcon/support/helper/str/dynamic.zep.c @@ -142,9 +142,9 @@ PHP_METHOD(Phalcon_Support_Helper_Str_Dynamic, __invoke) ZEPHIR_MM_RESTORE(); return; } - ZEPHIR_CALL_FUNCTION(&ldS, "preg_quote", NULL, 438, &leftDelimiter); + ZEPHIR_CALL_FUNCTION(&ldS, "preg_quote", NULL, 439, &leftDelimiter); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&rdS, "preg_quote", NULL, 438, &rightDelimiter); + ZEPHIR_CALL_FUNCTION(&rdS, "preg_quote", NULL, 439, &rightDelimiter); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_4); ZEPHIR_CONCAT_SVSVVSVS(&_4, "/", &ldS, "([^", &ldS, &rdS, "]+)", &rdS, "/"); @@ -178,7 +178,7 @@ PHP_METHOD(Phalcon_Support_Helper_Str_Dynamic, __invoke) zephir_check_call_status(); zephir_array_fetch(&word, &words, &_10$$6, PH_NOISY, "phalcon/Support/Helper/Str/Dynamic.zep", 62); zephir_array_fetch_long(&_12$$6, &match, 0, PH_NOISY | PH_READONLY, "phalcon/Support/Helper/Str/Dynamic.zep", 63); - ZEPHIR_CALL_FUNCTION(&sub, "preg_quote", NULL, 438, &_12$$6, &separator); + ZEPHIR_CALL_FUNCTION(&sub, "preg_quote", NULL, 439, &_12$$6, &separator); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_13$$6); ZEPHIR_CONCAT_SVS(&_13$$6, "/", &sub, "/"); @@ -213,7 +213,7 @@ PHP_METHOD(Phalcon_Support_Helper_Str_Dynamic, __invoke) zephir_check_call_status(); zephir_array_fetch(&word, &words, &_19$$8, PH_NOISY, "phalcon/Support/Helper/Str/Dynamic.zep", 62); zephir_array_fetch_long(&_20$$8, &match, 0, PH_NOISY | PH_READONLY, "phalcon/Support/Helper/Str/Dynamic.zep", 63); - ZEPHIR_CALL_FUNCTION(&sub, "preg_quote", NULL, 438, &_20$$8, &separator); + ZEPHIR_CALL_FUNCTION(&sub, "preg_quote", NULL, 439, &_20$$8, &separator); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_21$$8); ZEPHIR_CONCAT_SVS(&_21$$8, "/", &sub, "/"); diff --git a/ext/phalcon/support/helper/str/includes.zep.c b/ext/phalcon/support/helper/str/includes.zep.c index 35b37cbc478..bcf87a515f0 100644 --- a/ext/phalcon/support/helper/str/includes.zep.c +++ b/ext/phalcon/support/helper/str/includes.zep.c @@ -68,7 +68,7 @@ PHP_METHOD(Phalcon_Support_Helper_Str_Includes, __invoke) zephir_get_strval(&needle, needle_param); - ZEPHIR_CALL_FUNCTION(&_0, "mb_strpos", NULL, 485, &haystack, &needle); + ZEPHIR_CALL_FUNCTION(&_0, "mb_strpos", NULL, 113, &haystack, &needle); zephir_check_call_status(); RETURN_MM_BOOL(!ZEPHIR_IS_FALSE_IDENTICAL(&_0)); } diff --git a/ext/phalcon/support/helper/str/random.zep.c b/ext/phalcon/support/helper/str/random.zep.c index 54a8b13158a..1c9fdf767e4 100644 --- a/ext/phalcon/support/helper/str/random.zep.c +++ b/ext/phalcon/support/helper/str/random.zep.c @@ -133,61 +133,61 @@ PHP_METHOD(Phalcon_Support_Helper_Str_Random, __invoke) ZVAL_STRING(&_3, "a"); ZEPHIR_INIT_VAR(&_4); ZVAL_STRING(&_4, "z"); - ZEPHIR_CALL_FUNCTION(&_5, "range", NULL, 337, &_3, &_4); + ZEPHIR_CALL_FUNCTION(&_5, "range", NULL, 338, &_3, &_4); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_3); ZVAL_STRING(&_3, "A"); ZEPHIR_INIT_NVAR(&_4); ZVAL_STRING(&_4, "Z"); - ZEPHIR_CALL_FUNCTION(&_6, "range", NULL, 337, &_3, &_4); + ZEPHIR_CALL_FUNCTION(&_6, "range", NULL, 338, &_3, &_4); zephir_check_call_status(); zephir_fast_array_merge(&_2, &_5, &_6); zephir_array_update_long(&pools, 1, &_2, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY); ZEPHIR_INIT_NVAR(&_2); ZVAL_LONG(&_7, 0); ZVAL_LONG(&_8, 9); - ZEPHIR_CALL_FUNCTION(&_9, "range", NULL, 337, &_7, &_8); + ZEPHIR_CALL_FUNCTION(&_9, "range", NULL, 338, &_7, &_8); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_3); ZVAL_STRING(&_3, "a"); ZEPHIR_INIT_NVAR(&_4); ZVAL_STRING(&_4, "f"); - ZEPHIR_CALL_FUNCTION(&_10, "range", NULL, 337, &_3, &_4); + ZEPHIR_CALL_FUNCTION(&_10, "range", NULL, 338, &_3, &_4); zephir_check_call_status(); zephir_fast_array_merge(&_2, &_9, &_10); zephir_array_update_long(&pools, 2, &_2, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY); ZVAL_LONG(&_7, 0); ZVAL_LONG(&_8, 9); - ZEPHIR_CALL_FUNCTION(&_11, "range", NULL, 337, &_7, &_8); + ZEPHIR_CALL_FUNCTION(&_11, "range", NULL, 338, &_7, &_8); zephir_check_call_status(); zephir_array_update_long(&pools, 3, &_11, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY); ZVAL_LONG(&_7, 1); ZVAL_LONG(&_8, 9); - ZEPHIR_CALL_FUNCTION(&_11, "range", NULL, 337, &_7, &_8); + ZEPHIR_CALL_FUNCTION(&_11, "range", NULL, 338, &_7, &_8); zephir_check_call_status(); zephir_array_update_long(&pools, 4, &_11, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "2345679ACDEFHJKLMNPRSTUVWXYZ"); - ZEPHIR_CALL_FUNCTION(&_11, "str_split", NULL, 115, &_2); + ZEPHIR_CALL_FUNCTION(&_11, "str_split", NULL, 117, &_2); zephir_check_call_status(); zephir_array_update_long(&pools, 5, &_11, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY); ZVAL_LONG(&_7, 0); ZVAL_LONG(&_8, 9); - ZEPHIR_CALL_FUNCTION(&_11, "range", NULL, 337, &_7, &_8); + ZEPHIR_CALL_FUNCTION(&_11, "range", NULL, 338, &_7, &_8); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "a"); ZEPHIR_INIT_NVAR(&_3); ZVAL_STRING(&_3, "z"); - ZEPHIR_CALL_FUNCTION(&_12, "range", NULL, 337, &_2, &_3); + ZEPHIR_CALL_FUNCTION(&_12, "range", NULL, 338, &_2, &_3); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "A"); ZEPHIR_INIT_NVAR(&_3); ZVAL_STRING(&_3, "Z"); - ZEPHIR_CALL_FUNCTION(&_13, "range", NULL, 337, &_2, &_3); + ZEPHIR_CALL_FUNCTION(&_13, "range", NULL, 338, &_2, &_3); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&_14, "array_merge", NULL, 354, &_11, &_12, &_13); + ZEPHIR_CALL_FUNCTION(&_14, "array_merge", NULL, 355, &_11, &_12, &_13); zephir_check_call_status(); zephir_array_update_long(&pools, 0, &_14, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY); zephir_array_fetch_long(&_15, &pools, type, PH_NOISY | PH_READONLY, "phalcon/Support/Helper/Str/Random.zep", 66); diff --git a/ext/phalcon/tag.zep.c b/ext/phalcon/tag.zep.c index 0de98e264cd..ba9967d1d81 100644 --- a/ext/phalcon/tag.zep.c +++ b/ext/phalcon/tag.zep.c @@ -960,7 +960,7 @@ PHP_METHOD(Phalcon_Tag, getTitle) zephir_read_static_property_ce(&_6$$3, phalcon_tag_ce, SL("documentPrependTitle"), PH_NOISY_CC); ZEPHIR_CPY_WRT(&documentPrependTitle, &_6$$3); if (!(ZEPHIR_IS_EMPTY(&documentPrependTitle))) { - ZEPHIR_CALL_FUNCTION(&tmp$$5, "array_reverse", NULL, 316, &documentPrependTitle); + ZEPHIR_CALL_FUNCTION(&tmp$$5, "array_reverse", NULL, 317, &documentPrependTitle); zephir_check_call_status(); zephir_is_iterable(&tmp$$5, 0, "phalcon/Tag.zep", 443); if (Z_TYPE_P(&tmp$$5) == IS_ARRAY) { @@ -3106,7 +3106,7 @@ PHP_METHOD(Phalcon_Tag, textArea) ZVAL_STRING(&_1, "", &_2, ""); diff --git a/ext/phalcon/tag/select.zep.c b/ext/phalcon/tag/select.zep.c index cc601b7b472..38d2193fd23 100644 --- a/ext/phalcon/tag/select.zep.c +++ b/ext/phalcon/tag/select.zep.c @@ -292,7 +292,7 @@ PHP_METHOD(Phalcon_Tag_Select, optionsFromArray) } ZEPHIR_INIT_NVAR(&optionText); ZVAL_COPY(&optionText, _0); - ZEPHIR_CALL_FUNCTION(&escaped, "htmlspecialchars", &_4, 343, &optionValue); + ZEPHIR_CALL_FUNCTION(&escaped, "htmlspecialchars", &_4, 344, &optionValue); zephir_check_call_status(); if (Z_TYPE_P(&optionText) == IS_ARRAY) { ZEPHIR_INIT_NVAR(&_5$$4); @@ -345,7 +345,7 @@ PHP_METHOD(Phalcon_Tag_Select, optionsFromArray) zephir_check_call_status(); ZEPHIR_CALL_METHOD(&optionText, &data, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&escaped, "htmlspecialchars", &_4, 343, &optionValue); + ZEPHIR_CALL_FUNCTION(&escaped, "htmlspecialchars", &_4, 344, &optionValue); zephir_check_call_status(); if (Z_TYPE_P(&optionText) == IS_ARRAY) { ZEPHIR_INIT_NVAR(&_16$$12); diff --git a/ext/phalcon/translate/interpolator/indexedarray.zep.c b/ext/phalcon/translate/interpolator/indexedarray.zep.c index d44e339122d..38910025ee2 100644 --- a/ext/phalcon/translate/interpolator/indexedarray.zep.c +++ b/ext/phalcon/translate/interpolator/indexedarray.zep.c @@ -92,7 +92,7 @@ PHP_METHOD(Phalcon_Translate_Interpolator_IndexedArray, replacePlaceholders) if (1 != ZEPHIR_IS_EMPTY(&placeholders)) { ZEPHIR_MAKE_REF(&placeholders); - ZEPHIR_CALL_FUNCTION(NULL, "array_unshift", NULL, 291, &placeholders, &translation); + ZEPHIR_CALL_FUNCTION(NULL, "array_unshift", NULL, 292, &placeholders, &translation); ZEPHIR_UNREF(&placeholders); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_0$$3); From c17bc6636d983a64c79e6941497589d38cff8d46 Mon Sep 17 00:00:00 2001 From: Nikolaos Dimopoulos Date: Mon, 18 Apr 2022 22:26:55 -0400 Subject: [PATCH 4/4] updating changelog --- CHANGELOG-5.0.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/CHANGELOG-5.0.md b/CHANGELOG-5.0.md index 71ef940821b..91f454f3bcf 100644 --- a/CHANGELOG-5.0.md +++ b/CHANGELOG-5.0.md @@ -4,6 +4,7 @@ - Changed `Phalcon\Session\Bag::__construct()` to accept a `Phalcon\Session\Manager` as the first parameter and `name` as the second one [#15904](https://github.com/phalcon/cphalcon/issues/15904) - Changed `Phalcon\Logger\Logger` to no longer depend on PSR interfaces [#15925](https://github.com/phalcon/cphalcon/issues/15925) - Changed `Phalcon\Cache\Cache` to no longer depend on PSR interfaces [#15927](https://github.com/phalcon/cphalcon/issues/15927) +- Changed `Phalcon\Html\Link` to no longer depend on PSR interfaces [#15930](https://github.com/phalcon/cphalcon/issues/15930) ## Fixed - Fixed `Phalcon\Html\Helper\Input\Numeric` to produce correct elements [#15896](https://github.com/phalcon/cphalcon/issues/15896) @@ -27,6 +28,13 @@ - Added - `Phalcon\Cache\CacheInterface` - `Phalcon\Cache\AbstractCache` to be used in the cache class but also the proxy-psr16 repo [#15927](https://github.com/phalcon/cphalcon/issues/15927) +- Added + - EvolvableLinkInterface.zep + - `Phalcon\Html\Link\Interfaces\EvolvableLinkProviderInterface` + - `Phalcon\Html\Link\Interfaces\LinkInterface` + - `Phalcon\Html\Link\Interfaces\LinkProviderInterface` + - `Phalcon\Html\Link\AbstractLink` + - `Phalcon\Html\Link\AbstractLinkProvider` to be used in the link class but also the proxy-psr13 repo [#15930](https://github.com/phalcon/cphalcon/issues/15930) # [5.0.0beta3](https://github.com/phalcon/cphalcon/releases/tag/v5.0.0beta3) (2022-02-06)