1
2 #ifdef HAVE_CONFIG_H
3 #include "../ext_config.h"
4 #endif
5
6 #include <php.h>
7 #include "../php_ext.h"
8 #include "../ext.h"
9
10 #include <Zend/zend_operators.h>
11 #include <Zend/zend_exceptions.h>
12 #include <Zend/zend_interfaces.h>
13
14 #include "kernel/main.h"
15 #include "kernel/array.h"
16 #include "kernel/memory.h"
17 #include "kernel/object.h"
18 #include "kernel/operators.h"
19 #include "kernel/fcall.h"
20 #include "ext/spl/spl_exceptions.h"
21 #include "kernel/exception.h"
22 #include "kernel/concat.h"
23 #include "kernel/string.h"
24
25
26 /**
27 * Phalcon\Tag
28 *
29 * Phalcon\Tag is designed to simplify building of HTML tags.
30 * It provides a set of helpers to generate HTML in a dynamic way.
31 * This component is an abstract class that you can extend to add more helpers.
32 */
ZEPHIR_INIT_CLASS(Phalcon_Tag)33 ZEPHIR_INIT_CLASS(Phalcon_Tag) {
34
35 ZEPHIR_REGISTER_CLASS(Phalcon, Tag, phalcon, tag, phalcon_tag_method_entry, 0);
36
37 /**
38 * Pre-assigned values for components
39 */
40 zend_declare_property_null(phalcon_tag_ce, SL("_displayValues"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC TSRMLS_CC);
41
42 /**
43 * HTML document title
44 */
45 zend_declare_property_null(phalcon_tag_ce, SL("_documentTitle"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC TSRMLS_CC);
46
47 zend_declare_property_null(phalcon_tag_ce, SL("_documentAppendTitle"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC TSRMLS_CC);
48
49 zend_declare_property_null(phalcon_tag_ce, SL("_documentPrependTitle"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC TSRMLS_CC);
50
51 zend_declare_property_null(phalcon_tag_ce, SL("_documentTitleSeparator"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC TSRMLS_CC);
52
53 zend_declare_property_long(phalcon_tag_ce, SL("_documentType"), 11, ZEND_ACC_PROTECTED|ZEND_ACC_STATIC TSRMLS_CC);
54
55 /**
56 * Framework Dispatcher
57 */
58 zend_declare_property_null(phalcon_tag_ce, SL("_dependencyInjector"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC TSRMLS_CC);
59
60 zend_declare_property_null(phalcon_tag_ce, SL("_urlService"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC TSRMLS_CC);
61
62 zend_declare_property_null(phalcon_tag_ce, SL("_dispatcherService"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC TSRMLS_CC);
63
64 zend_declare_property_null(phalcon_tag_ce, SL("_escaperService"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC TSRMLS_CC);
65
66 zend_declare_property_bool(phalcon_tag_ce, SL("_autoEscape"), 1, ZEND_ACC_PROTECTED|ZEND_ACC_STATIC TSRMLS_CC);
67
68 zend_declare_class_constant_long(phalcon_tag_ce, SL("HTML32"), 1 TSRMLS_CC);
69
70 zend_declare_class_constant_long(phalcon_tag_ce, SL("HTML401_STRICT"), 2 TSRMLS_CC);
71
72 zend_declare_class_constant_long(phalcon_tag_ce, SL("HTML401_TRANSITIONAL"), 3 TSRMLS_CC);
73
74 zend_declare_class_constant_long(phalcon_tag_ce, SL("HTML401_FRAMESET"), 4 TSRMLS_CC);
75
76 zend_declare_class_constant_long(phalcon_tag_ce, SL("HTML5"), 5 TSRMLS_CC);
77
78 zend_declare_class_constant_long(phalcon_tag_ce, SL("XHTML10_STRICT"), 6 TSRMLS_CC);
79
80 zend_declare_class_constant_long(phalcon_tag_ce, SL("XHTML10_TRANSITIONAL"), 7 TSRMLS_CC);
81
82 zend_declare_class_constant_long(phalcon_tag_ce, SL("XHTML10_FRAMESET"), 8 TSRMLS_CC);
83
84 zend_declare_class_constant_long(phalcon_tag_ce, SL("XHTML11"), 9 TSRMLS_CC);
85
86 zend_declare_class_constant_long(phalcon_tag_ce, SL("XHTML20"), 10 TSRMLS_CC);
87
88 zend_declare_class_constant_long(phalcon_tag_ce, SL("XHTML5"), 11 TSRMLS_CC);
89
90 return SUCCESS;
91
92 }
93
94 /**
95 * Obtains the 'escaper' service if required
96 *
97 * @param array params
98 * @return EscaperInterface
99 */
PHP_METHOD(Phalcon_Tag,getEscaper)100 PHP_METHOD(Phalcon_Tag, getEscaper) {
101
102 zend_long ZEPHIR_LAST_CALL_STATUS;
103 zval *params_param = NULL, *autoescape = NULL;
104 zval *params = NULL;
105
106 ZEPHIR_MM_GROW();
107 zephir_fetch_params(1, 1, 0, ¶ms_param);
108
109 params = params_param;
110
111
112 ZEPHIR_OBS_VAR(autoescape);
113 if (!(zephir_array_isset_string_fetch(&autoescape, params, SS("escape"), 0 TSRMLS_CC))) {
114 ZEPHIR_OBS_NVAR(autoescape);
115 zephir_read_static_property_ce(&autoescape, phalcon_tag_ce, SL("_autoEscape") TSRMLS_CC);
116 }
117 if (!(zephir_is_true(autoescape))) {
118 RETURN_MM_NULL();
119 }
120 ZEPHIR_RETURN_CALL_SELF("getescaperservice", NULL, 0);
121 zephir_check_call_status();
122 RETURN_MM();
123
124 }
125
126 /**
127 * Renders parameters keeping order in their HTML attributes
128 */
PHP_METHOD(Phalcon_Tag,renderAttributes)129 PHP_METHOD(Phalcon_Tag, renderAttributes) {
130
131 zend_bool _10$$7, _11$$8;
132 HashTable *_1, *_4, *_8;
133 HashPosition _0, _3, _7;
134 zephir_fcall_cache_entry *_15 = NULL, *_16 = NULL;
135 zend_long ZEPHIR_LAST_CALL_STATUS;
136 zval *attributes = NULL;
137 zval *code_param = NULL, *attributes_param = NULL, *order = NULL, *escaper = NULL, *attrs = NULL, *attribute = NULL, *value = NULL, *escaped = NULL, *key = NULL, *newCode = NULL, **_2, **_5, *_6 = NULL, **_9, *_17$$8 = NULL, *_12$$9 = NULL, *_13$$9 = NULL, *_14$$9 = NULL;
138 zval *code = NULL;
139
140 ZEPHIR_MM_GROW();
141 zephir_fetch_params(1, 2, 0, &code_param, &attributes_param);
142
143 if (UNEXPECTED(Z_TYPE_P(code_param) != IS_STRING && Z_TYPE_P(code_param) != IS_NULL)) {
144 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'code' must be a string") TSRMLS_CC);
145 RETURN_MM_NULL();
146 }
147 if (EXPECTED(Z_TYPE_P(code_param) == IS_STRING)) {
148 zephir_get_strval(code, code_param);
149 } else {
150 ZEPHIR_INIT_VAR(code);
151 ZVAL_EMPTY_STRING(code);
152 }
153 attributes = attributes_param;
154
155
156 ZEPHIR_INIT_VAR(order);
157 zephir_create_array(order, 10, 0 TSRMLS_CC);
158 zephir_array_update_string(&order, SL("rel"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
159 zephir_array_update_string(&order, SL("type"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
160 zephir_array_update_string(&order, SL("for"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
161 zephir_array_update_string(&order, SL("src"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
162 zephir_array_update_string(&order, SL("href"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
163 zephir_array_update_string(&order, SL("action"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
164 zephir_array_update_string(&order, SL("id"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
165 zephir_array_update_string(&order, SL("name"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
166 zephir_array_update_string(&order, SL("value"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
167 zephir_array_update_string(&order, SL("class"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
168 ZEPHIR_INIT_VAR(attrs);
169 array_init(attrs);
170 zephir_is_iterable(order, &_1, &_0, 0, 0, "phalcon/tag.zep", 137);
171 for (
172 ; zend_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
173 ; zend_hash_move_forward_ex(_1, &_0)
174 ) {
175 ZEPHIR_GET_HMKEY(key, _1, _0);
176 ZEPHIR_GET_HVALUE(value, _2);
177 ZEPHIR_OBS_NVAR(attribute);
178 if (zephir_array_isset_fetch(&attribute, attributes, key, 0 TSRMLS_CC)) {
179 zephir_array_update_zval(&attrs, key, &attribute, PH_COPY | PH_SEPARATE);
180 }
181 }
182 zephir_is_iterable(attributes, &_4, &_3, 0, 0, "phalcon/tag.zep", 143);
183 for (
184 ; zend_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS
185 ; zend_hash_move_forward_ex(_4, &_3)
186 ) {
187 ZEPHIR_GET_HMKEY(key, _4, _3);
188 ZEPHIR_GET_HVALUE(value, _5);
189 if (!(zephir_array_isset(attrs, key))) {
190 zephir_array_update_zval(&attrs, key, &value, PH_COPY | PH_SEPARATE);
191 }
192 }
193 ZEPHIR_CALL_SELF(&_6, "getescaper", NULL, 0, attributes);
194 zephir_check_call_status();
195 ZEPHIR_CPY_WRT(escaper, _6);
196 zephir_array_unset_string(&attrs, SS("escape"), PH_SEPARATE);
197 ZEPHIR_CPY_WRT(newCode, code);
198 zephir_is_iterable(attrs, &_8, &_7, 0, 0, "phalcon/tag.zep", 162);
199 for (
200 ; zend_hash_get_current_data_ex(_8, (void**) &_9, &_7) == SUCCESS
201 ; zend_hash_move_forward_ex(_8, &_7)
202 ) {
203 ZEPHIR_GET_HMKEY(key, _8, _7);
204 ZEPHIR_GET_HVALUE(value, _9);
205 _10$$7 = Z_TYPE_P(key) == IS_STRING;
206 if (_10$$7) {
207 _10$$7 = Z_TYPE_P(value) != IS_NULL;
208 }
209 if (_10$$7) {
210 _11$$8 = Z_TYPE_P(value) == IS_ARRAY;
211 if (!(_11$$8)) {
212 _11$$8 = Z_TYPE_P(value) == IS_RESOURCE;
213 }
214 if (_11$$8) {
215 ZEPHIR_INIT_NVAR(_12$$9);
216 object_init_ex(_12$$9, phalcon_tag_exception_ce);
217 ZEPHIR_INIT_NVAR(_13$$9);
218 zephir_gettype(_13$$9, value TSRMLS_CC);
219 ZEPHIR_INIT_LNVAR(_14$$9);
220 ZEPHIR_CONCAT_SVSVS(_14$$9, "Value at index: '", key, "' type: '", _13$$9, "' cannot be rendered");
221 ZEPHIR_CALL_METHOD(NULL, _12$$9, "__construct", &_15, 9, _14$$9);
222 zephir_check_call_status();
223 zephir_throw_exception_debug(_12$$9, "phalcon/tag.zep", 151 TSRMLS_CC);
224 ZEPHIR_MM_RESTORE();
225 return;
226 }
227 if (zephir_is_true(escaper)) {
228 ZEPHIR_CALL_METHOD(&escaped, escaper, "escapehtmlattr", &_16, 0, value);
229 zephir_check_call_status();
230 } else {
231 ZEPHIR_CPY_WRT(escaped, value);
232 }
233 ZEPHIR_INIT_LNVAR(_17$$8);
234 ZEPHIR_CONCAT_SVSVS(_17$$8, " ", key, "=\"", escaped, "\"");
235 zephir_concat_self(&newCode, _17$$8 TSRMLS_CC);
236 }
237 }
238 RETURN_CCTOR(newCode);
239
240 }
241
242 /**
243 * Sets the dependency injector container.
244 */
PHP_METHOD(Phalcon_Tag,setDI)245 PHP_METHOD(Phalcon_Tag, setDI) {
246
247 zval *dependencyInjector;
248
249 zephir_fetch_params(0, 1, 0, &dependencyInjector);
250
251
252
253 zephir_update_static_property_ce(phalcon_tag_ce, SL("_dependencyInjector"), &dependencyInjector TSRMLS_CC);
254
255 }
256
257 /**
258 * Internally gets the request dispatcher
259 */
PHP_METHOD(Phalcon_Tag,getDI)260 PHP_METHOD(Phalcon_Tag, getDI) {
261
262 zval *di = NULL;
263 zend_long ZEPHIR_LAST_CALL_STATUS;
264 zephir_fcall_cache_entry *_0 = NULL;
265
266 ZEPHIR_MM_GROW();
267
268 ZEPHIR_OBS_VAR(di);
269 zephir_read_static_property_ce(&di, phalcon_tag_ce, SL("_dependencyInjector") TSRMLS_CC);
270 if (Z_TYPE_P(di) != IS_OBJECT) {
271 ZEPHIR_CALL_CE_STATIC(&di, phalcon_di_ce, "getdefault", &_0, 1);
272 zephir_check_call_status();
273 }
274 RETURN_CCTOR(di);
275
276 }
277
278 /**
279 * Returns a URL service from the default DI
280 */
PHP_METHOD(Phalcon_Tag,getUrlService)281 PHP_METHOD(Phalcon_Tag, getUrlService) {
282
283 zval *url = NULL, *dependencyInjector = NULL, *_0$$3 = NULL, *_1$$3;
284 zend_long ZEPHIR_LAST_CALL_STATUS;
285
286 ZEPHIR_MM_GROW();
287
288 ZEPHIR_OBS_VAR(url);
289 zephir_read_static_property_ce(&url, phalcon_tag_ce, SL("_urlService") TSRMLS_CC);
290 if (Z_TYPE_P(url) != IS_OBJECT) {
291 ZEPHIR_CALL_SELF(&dependencyInjector, "getdi", NULL, 0);
292 zephir_check_call_status();
293 if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
294 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_tag_exception_ce, "A dependency injector container is required to obtain the 'url' service", "phalcon/tag.zep", 199);
295 return;
296 }
297 ZEPHIR_INIT_VAR(_1$$3);
298 ZVAL_STRING(_1$$3, "url", ZEPHIR_TEMP_PARAM_COPY);
299 ZEPHIR_CALL_METHOD(&_0$$3, dependencyInjector, "getshared", NULL, 0, _1$$3);
300 zephir_check_temp_parameter(_1$$3);
301 zephir_check_call_status();
302 ZEPHIR_CPY_WRT(url, _0$$3);
303 zephir_update_static_property_ce(phalcon_tag_ce, SL("_urlService"), &url TSRMLS_CC);
304 }
305 RETURN_CCTOR(url);
306
307 }
308
309 /**
310 * Returns an Escaper service from the default DI
311 */
PHP_METHOD(Phalcon_Tag,getEscaperService)312 PHP_METHOD(Phalcon_Tag, getEscaperService) {
313
314 zval *escaper = NULL, *dependencyInjector = NULL, *_0$$3 = NULL, *_1$$3;
315 zend_long ZEPHIR_LAST_CALL_STATUS;
316
317 ZEPHIR_MM_GROW();
318
319 ZEPHIR_OBS_VAR(escaper);
320 zephir_read_static_property_ce(&escaper, phalcon_tag_ce, SL("_escaperService") TSRMLS_CC);
321 if (Z_TYPE_P(escaper) != IS_OBJECT) {
322 ZEPHIR_CALL_SELF(&dependencyInjector, "getdi", NULL, 0);
323 zephir_check_call_status();
324 if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
325 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_tag_exception_ce, "A dependency injector container is required to obtain the 'escaper' service", "phalcon/tag.zep", 221);
326 return;
327 }
328 ZEPHIR_INIT_VAR(_1$$3);
329 ZVAL_STRING(_1$$3, "escaper", ZEPHIR_TEMP_PARAM_COPY);
330 ZEPHIR_CALL_METHOD(&_0$$3, dependencyInjector, "getshared", NULL, 0, _1$$3);
331 zephir_check_temp_parameter(_1$$3);
332 zephir_check_call_status();
333 ZEPHIR_CPY_WRT(escaper, _0$$3);
334 zephir_update_static_property_ce(phalcon_tag_ce, SL("_escaperService"), &escaper TSRMLS_CC);
335 }
336 RETURN_CCTOR(escaper);
337
338 }
339
340 /**
341 * Set autoescape mode in generated html
342 */
PHP_METHOD(Phalcon_Tag,setAutoescape)343 PHP_METHOD(Phalcon_Tag, setAutoescape) {
344
345 zval *autoescape_param = NULL, *_0;
346 zend_bool autoescape;
347
348 zephir_fetch_params(0, 1, 0, &autoescape_param);
349
350 autoescape = zephir_get_boolval(autoescape_param);
351
352
353 ZEPHIR_INIT_ZVAL_NREF(_0);
354 ZVAL_BOOL(_0, autoescape);
355 zephir_update_static_property_ce(phalcon_tag_ce, SL("_autoEscape"), &_0 TSRMLS_CC);
356
357 }
358
359 /**
360 * Assigns default values to generated tags by helpers
361 *
362 * <code>
363 * // Assigning "peter" to "name" component
364 * Phalcon\Tag::setDefault("name", "peter");
365 *
366 * // Later in the view
367 * echo Phalcon\Tag::textField("name"); // Will have the value "peter" by default
368 * </code>
369 *
370 * @param string id
371 * @param string value
372 */
PHP_METHOD(Phalcon_Tag,setDefault)373 PHP_METHOD(Phalcon_Tag, setDefault) {
374
375 zend_bool _0$$3;
376 zval *id_param = NULL, *value;
377 zval *id = NULL;
378
379 ZEPHIR_MM_GROW();
380 zephir_fetch_params(1, 2, 0, &id_param, &value);
381
382 if (UNEXPECTED(Z_TYPE_P(id_param) != IS_STRING && Z_TYPE_P(id_param) != IS_NULL)) {
383 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'id' must be a string") TSRMLS_CC);
384 RETURN_MM_NULL();
385 }
386 if (EXPECTED(Z_TYPE_P(id_param) == IS_STRING)) {
387 zephir_get_strval(id, id_param);
388 } else {
389 ZEPHIR_INIT_VAR(id);
390 ZVAL_EMPTY_STRING(id);
391 }
392
393
394 if (Z_TYPE_P(value) != IS_NULL) {
395 _0$$3 = Z_TYPE_P(value) == IS_ARRAY;
396 if (!(_0$$3)) {
397 _0$$3 = Z_TYPE_P(value) == IS_OBJECT;
398 }
399 if (_0$$3) {
400 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_tag_exception_ce, "Only scalar values can be assigned to UI components", "phalcon/tag.zep", 256);
401 return;
402 }
403 }
404 zephir_update_static_property_array_multi_ce(phalcon_tag_ce, SL("_displayValues"), &value TSRMLS_CC, SL("z"), 1, id);
405 ZEPHIR_MM_RESTORE();
406
407 }
408
409 /**
410 * Assigns default values to generated tags by helpers
411 *
412 * <code>
413 * // Assigning "peter" to "name" component
414 * Phalcon\Tag::setDefaults(
415 * [
416 * "name" => "peter",
417 * ]
418 * );
419 *
420 * // Later in the view
421 * echo Phalcon\Tag::textField("name"); // Will have the value "peter" by default
422 * </code>
423 */
PHP_METHOD(Phalcon_Tag,setDefaults)424 PHP_METHOD(Phalcon_Tag, setDefaults) {
425
426 zend_bool merge, _0;
427 zval *values_param = NULL, *merge_param = NULL, *_1, *_2$$3, *_3$$3;
428 zval *values = NULL;
429
430 ZEPHIR_MM_GROW();
431 zephir_fetch_params(1, 1, 1, &values_param, &merge_param);
432
433 values = values_param;
434 if (!merge_param) {
435 merge = 0;
436 } else {
437 merge = zephir_get_boolval(merge_param);
438 }
439
440
441 _0 = merge;
442 if (_0) {
443 ZEPHIR_OBS_VAR(_1);
444 zephir_read_static_property_ce(&_1, phalcon_tag_ce, SL("_displayValues") TSRMLS_CC);
445 _0 = Z_TYPE_P(_1) == IS_ARRAY;
446 }
447 if (_0) {
448 ZEPHIR_INIT_VAR(_2$$3);
449 _3$$3 = zephir_fetch_static_property_ce(phalcon_tag_ce, SL("_displayValues") TSRMLS_CC);
450 zephir_fast_array_merge(_2$$3, &(_3$$3), &(values) TSRMLS_CC);
451 zephir_update_static_property_ce(phalcon_tag_ce, SL("_displayValues"), &_2$$3 TSRMLS_CC);
452 } else {
453 zephir_update_static_property_ce(phalcon_tag_ce, SL("_displayValues"), &values TSRMLS_CC);
454 }
455 ZEPHIR_MM_RESTORE();
456
457 }
458
459 /**
460 * Alias of Phalcon\Tag::setDefault
461 *
462 * @param string id
463 * @param string value
464 */
PHP_METHOD(Phalcon_Tag,displayTo)465 PHP_METHOD(Phalcon_Tag, displayTo) {
466
467 zend_long ZEPHIR_LAST_CALL_STATUS;
468 zval *id, *value;
469
470 ZEPHIR_MM_GROW();
471 zephir_fetch_params(1, 2, 0, &id, &value);
472
473
474
475 ZEPHIR_CALL_SELF(NULL, "setdefault", NULL, 0, id, value);
476 zephir_check_call_status();
477 ZEPHIR_MM_RESTORE();
478
479 }
480
481 /**
482 * Check if a helper has a default value set using Phalcon\Tag::setDefault or value from $_POST
483 *
484 * @param string name
485 * @return boolean
486 */
PHP_METHOD(Phalcon_Tag,hasValue)487 PHP_METHOD(Phalcon_Tag, hasValue) {
488
489 zend_bool _1;
490 zval *name, *_POST, *_0;
491
492 ZEPHIR_MM_GROW();
493 zephir_get_global(&_POST, SS("_POST") TSRMLS_CC);
494 zephir_fetch_params(0, 1, 0, &name);
495
496
497
498 _0 = zephir_fetch_static_property_ce(phalcon_tag_ce, SL("_displayValues") TSRMLS_CC);
499 _1 = zephir_array_isset(_0, name);
500 if (!(_1)) {
501 _1 = zephir_array_isset(_POST, name);
502 }
503 RETURN_MM_BOOL(_1);
504
505 }
506
507 /**
508 * Every helper calls this function to check whether a component has a predefined
509 * value using Phalcon\Tag::setDefault or value from $_POST
510 *
511 * @param string name
512 * @param array params
513 * @return mixed
514 */
PHP_METHOD(Phalcon_Tag,getValue)515 PHP_METHOD(Phalcon_Tag, getValue) {
516
517 zend_bool _0;
518 zval *name, *params = NULL, *_POST, *value = NULL, *_1$$3;
519
520 ZEPHIR_MM_GROW();
521 zephir_get_global(&_POST, SS("_POST") TSRMLS_CC);
522 zephir_fetch_params(1, 1, 1, &name, ¶ms);
523
524 if (!params) {
525 params = ZEPHIR_GLOBAL(global_null);
526 }
527
528
529 _0 = !zephir_is_true(params);
530 if (!(_0)) {
531 ZEPHIR_OBS_VAR(value);
532 _0 = !(zephir_array_isset_string_fetch(&value, params, SS("value"), 0 TSRMLS_CC));
533 }
534 if (_0) {
535 ZEPHIR_OBS_NVAR(value);
536 _1$$3 = zephir_fetch_static_property_ce(phalcon_tag_ce, SL("_displayValues") TSRMLS_CC);
537 if (!(zephir_array_isset_fetch(&value, _1$$3, name, 0 TSRMLS_CC))) {
538 ZEPHIR_OBS_NVAR(value);
539 if (!(zephir_array_isset_fetch(&value, _POST, name, 0 TSRMLS_CC))) {
540 RETURN_MM_NULL();
541 }
542 }
543 }
544 RETURN_CCTOR(value);
545
546 }
547
548 /**
549 * Resets the request and internal values to avoid those fields will have any default value.
550 * @deprecated Will be removed in 4.0.0
551 */
PHP_METHOD(Phalcon_Tag,resetInput)552 PHP_METHOD(Phalcon_Tag, resetInput) {
553
554 zval *_0, *_1, *_2;
555
556 ZEPHIR_MM_GROW();
557
558 ZEPHIR_INIT_VAR(_0);
559 array_init(_0);
560 zephir_update_static_property_ce(phalcon_tag_ce, SL("_displayValues"), &_0 TSRMLS_CC);
561 zephir_update_static_property_ce(phalcon_tag_ce, SL("_documentTitle"), &ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
562 ZEPHIR_INIT_VAR(_1);
563 array_init(_1);
564 zephir_update_static_property_ce(phalcon_tag_ce, SL("_documentAppendTitle"), &_1 TSRMLS_CC);
565 ZEPHIR_INIT_VAR(_2);
566 array_init(_2);
567 zephir_update_static_property_ce(phalcon_tag_ce, SL("_documentPrependTitle"), &_2 TSRMLS_CC);
568 zephir_update_static_property_ce(phalcon_tag_ce, SL("_documentTitleSeparator"), &ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
569 ZEPHIR_MM_RESTORE();
570
571 }
572
573 /**
574 * Builds a HTML A tag using framework conventions
575 *
576 *<code>
577 * echo Phalcon\Tag::linkTo("signup/register", "Register Here!");
578 *
579 * echo Phalcon\Tag::linkTo(
580 * [
581 * "signup/register",
582 * "Register Here!"
583 * ]
584 * );
585 *
586 * echo Phalcon\Tag::linkTo(
587 * [
588 * "signup/register",
589 * "Register Here!",
590 * "class" => "btn-primary",
591 * ]
592 * );
593 *
594 * echo Phalcon\Tag::linkTo("http://phalconphp.com/", "Phalcon", false);
595 *
596 * echo Phalcon\Tag::linkTo(
597 * [
598 * "http://phalconphp.com/",
599 * "Phalcon Home",
600 * false,
601 * ]
602 * );
603 *
604 * echo Phalcon\Tag::linkTo(
605 * [
606 * "http://phalconphp.com/",
607 * "Phalcon Home",
608 * "local" => false,
609 * ]
610 * );
611 *
612 * echo Phalcon\Tag::linkTo(
613 * [
614 * "action" => "http://phalconphp.com/",
615 * "text" => "Phalcon Home",
616 * "local" => false,
617 * "target" => "_new"
618 * ]
619 * );
620 *
621 *</code>
622 *
623 * @param array|string parameters
624 * @param string text
625 * @param boolean local
626 */
PHP_METHOD(Phalcon_Tag,linkTo)627 PHP_METHOD(Phalcon_Tag, linkTo) {
628
629 zend_long ZEPHIR_LAST_CALL_STATUS;
630 zval *parameters, *text = NULL, *local = NULL, *params = NULL, *action = NULL, *query = NULL, *url = NULL, *code = NULL, *_0 = NULL, *_1, *_2;
631
632 ZEPHIR_MM_GROW();
633 zephir_fetch_params(1, 1, 2, ¶meters, &text, &local);
634
635 if (!text) {
636 ZEPHIR_CPY_WRT(text, ZEPHIR_GLOBAL(global_null));
637 } else {
638 ZEPHIR_SEPARATE_PARAM(text);
639 }
640 if (!local) {
641 ZEPHIR_CPY_WRT(local, ZEPHIR_GLOBAL(global_true));
642 } else {
643 ZEPHIR_SEPARATE_PARAM(local);
644 }
645
646
647 if (Z_TYPE_P(parameters) != IS_ARRAY) {
648 ZEPHIR_INIT_VAR(params);
649 zephir_create_array(params, 3, 0 TSRMLS_CC);
650 zephir_array_fast_append(params, parameters);
651 zephir_array_fast_append(params, text);
652 zephir_array_fast_append(params, local);
653 } else {
654 ZEPHIR_CPY_WRT(params, parameters);
655 }
656 ZEPHIR_OBS_VAR(action);
657 if (!(zephir_array_isset_long_fetch(&action, params, 0, 0 TSRMLS_CC))) {
658 ZEPHIR_OBS_NVAR(action);
659 if (!(zephir_array_isset_string_fetch(&action, params, SS("action"), 0 TSRMLS_CC))) {
660 ZEPHIR_INIT_NVAR(action);
661 ZVAL_STRING(action, "", 1);
662 } else {
663 zephir_array_unset_string(¶ms, SS("action"), PH_SEPARATE);
664 }
665 }
666 ZEPHIR_OBS_NVAR(text);
667 if (!(zephir_array_isset_long_fetch(&text, params, 1, 0 TSRMLS_CC))) {
668 ZEPHIR_OBS_NVAR(text);
669 if (!(zephir_array_isset_string_fetch(&text, params, SS("text"), 0 TSRMLS_CC))) {
670 ZEPHIR_INIT_NVAR(text);
671 ZVAL_STRING(text, "", 1);
672 } else {
673 zephir_array_unset_string(¶ms, SS("text"), PH_SEPARATE);
674 }
675 }
676 ZEPHIR_OBS_NVAR(local);
677 if (!(zephir_array_isset_long_fetch(&local, params, 2, 0 TSRMLS_CC))) {
678 ZEPHIR_OBS_NVAR(local);
679 if (!(zephir_array_isset_string_fetch(&local, params, SS("local"), 0 TSRMLS_CC))) {
680 ZEPHIR_INIT_NVAR(local);
681 ZVAL_BOOL(local, 1);
682 } else {
683 zephir_array_unset_string(¶ms, SS("local"), PH_SEPARATE);
684 }
685 }
686 ZEPHIR_OBS_VAR(query);
687 if (zephir_array_isset_string_fetch(&query, params, SS("query"), 0 TSRMLS_CC)) {
688 zephir_array_unset_string(¶ms, SS("query"), PH_SEPARATE);
689 } else {
690 ZEPHIR_INIT_NVAR(query);
691 ZVAL_NULL(query);
692 }
693 ZEPHIR_CALL_SELF(&url, "geturlservice", NULL, 0);
694 zephir_check_call_status();
695 ZEPHIR_CALL_METHOD(&_0, url, "get", NULL, 0, action, query, local);
696 zephir_check_call_status();
697 zephir_array_update_string(¶ms, SL("href"), &_0, PH_COPY | PH_SEPARATE);
698 ZEPHIR_INIT_VAR(_1);
699 ZVAL_STRING(_1, "<a", ZEPHIR_TEMP_PARAM_COPY);
700 ZEPHIR_CALL_SELF(&code, "renderattributes", NULL, 0, _1, params);
701 zephir_check_temp_parameter(_1);
702 zephir_check_call_status();
703 ZEPHIR_INIT_VAR(_2);
704 ZEPHIR_CONCAT_SVS(_2, ">", text, "</a>");
705 zephir_concat_self(&code, _2 TSRMLS_CC);
706 RETURN_CCTOR(code);
707
708 }
709
710 /**
711 * Builds generic INPUT tags
712 *
713 * @param string type
714 * @param array parameters
715 * @param boolean asValue
716 * @return string
717 */
PHP_METHOD(Phalcon_Tag,_inputField)718 PHP_METHOD(Phalcon_Tag, _inputField) {
719
720 zend_long ZEPHIR_LAST_CALL_STATUS;
721 zend_bool asValue, _1$$10;
722 zval *type_param = NULL, *parameters, *asValue_param = NULL, *params = NULL, *id = NULL, *value = NULL, *code = NULL, *name = NULL, *_3, *_4, *_0$$6, *_2$$5 = NULL;
723 zval *type = NULL;
724
725 ZEPHIR_MM_GROW();
726 zephir_fetch_params(1, 2, 1, &type_param, ¶meters, &asValue_param);
727
728 zephir_get_strval(type, type_param);
729 if (!asValue_param) {
730 asValue = 0;
731 } else {
732 asValue = zephir_get_boolval(asValue_param);
733 }
734
735
736 ZEPHIR_INIT_VAR(params);
737 array_init(params);
738 if (Z_TYPE_P(parameters) != IS_ARRAY) {
739 zephir_array_append(¶ms, parameters, PH_SEPARATE, "phalcon/tag.zep", 470);
740 } else {
741 ZEPHIR_CPY_WRT(params, parameters);
742 }
743 if (asValue == 0) {
744 ZEPHIR_OBS_VAR(id);
745 if (!(zephir_array_isset_long_fetch(&id, params, 0, 0 TSRMLS_CC))) {
746 zephir_array_fetch_string(&_0$$6, params, SL("id"), PH_NOISY | PH_READONLY, "phalcon/tag.zep", 478 TSRMLS_CC);
747 zephir_array_update_long(¶ms, 0, &_0$$6, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY);
748 }
749 ZEPHIR_OBS_VAR(name);
750 if (zephir_array_isset_string_fetch(&name, params, SS("name"), 0 TSRMLS_CC)) {
751 if (ZEPHIR_IS_EMPTY(name)) {
752 zephir_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE);
753 }
754 } else {
755 zephir_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE);
756 }
757 if (Z_TYPE_P(id) == IS_STRING) {
758 _1$$10 = !(zephir_memnstr_str(id, SL("["), "phalcon/tag.zep", 493));
759 if (_1$$10) {
760 _1$$10 = !(zephir_array_isset_string(params, SS("id")));
761 }
762 if (_1$$10) {
763 zephir_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE);
764 }
765 }
766 ZEPHIR_CALL_SELF(&_2$$5, "getvalue", NULL, 0, id, params);
767 zephir_check_call_status();
768 zephir_array_update_string(¶ms, SL("value"), &_2$$5, PH_COPY | PH_SEPARATE);
769 } else {
770 if (!(zephir_array_isset_string(params, SS("value")))) {
771 ZEPHIR_OBS_VAR(value);
772 if (zephir_array_isset_long_fetch(&value, params, 0, 0 TSRMLS_CC)) {
773 zephir_array_update_string(¶ms, SL("value"), &value, PH_COPY | PH_SEPARATE);
774 }
775 }
776 }
777 zephir_array_update_string(¶ms, SL("type"), &type, PH_COPY | PH_SEPARATE);
778 ZEPHIR_INIT_VAR(_3);
779 ZVAL_STRING(_3, "<input", ZEPHIR_TEMP_PARAM_COPY);
780 ZEPHIR_CALL_SELF(&code, "renderattributes", NULL, 0, _3, params);
781 zephir_check_temp_parameter(_3);
782 zephir_check_call_status();
783 _4 = zephir_fetch_static_property_ce(phalcon_tag_ce, SL("_documentType") TSRMLS_CC);
784 if (ZEPHIR_GT_LONG(_4, 5)) {
785 zephir_concat_self_str(&code, SL(" />") TSRMLS_CC);
786 } else {
787 zephir_concat_self_str(&code, SL(">") TSRMLS_CC);
788 }
789 RETURN_CCTOR(code);
790
791 }
792
793 /**
794 * Builds INPUT tags that implements the checked attribute
795 *
796 * @param string type
797 * @param array parameters
798 * @return string
799 */
PHP_METHOD(Phalcon_Tag,_inputFieldChecked)800 PHP_METHOD(Phalcon_Tag, _inputFieldChecked) {
801
802 zend_bool _3$$11;
803 zend_long ZEPHIR_LAST_CALL_STATUS;
804 zval *type_param = NULL, *parameters, *params = NULL, *value = NULL, *id = NULL, *code = NULL, *name = NULL, *currentValue = NULL, _1, *_2, *_6, *_7, *_0$$5, *_4$$12, *_5$$14;
805 zval *type = NULL;
806
807 ZEPHIR_MM_GROW();
808 zephir_fetch_params(1, 2, 0, &type_param, ¶meters);
809
810 zephir_get_strval(type, type_param);
811
812
813 if (Z_TYPE_P(parameters) != IS_ARRAY) {
814 ZEPHIR_INIT_VAR(params);
815 zephir_create_array(params, 1, 0 TSRMLS_CC);
816 zephir_array_fast_append(params, parameters);
817 } else {
818 ZEPHIR_CPY_WRT(params, parameters);
819 }
820 if (!(zephir_array_isset_long(params, 0))) {
821 zephir_array_fetch_string(&_0$$5, params, SL("id"), PH_NOISY | PH_READONLY, "phalcon/tag.zep", 544 TSRMLS_CC);
822 zephir_array_update_long(¶ms, 0, &_0$$5, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY);
823 }
824 ZEPHIR_OBS_VAR(id);
825 zephir_array_fetch_long(&id, params, 0, PH_NOISY, "phalcon/tag.zep", 547 TSRMLS_CC);
826 if (!(zephir_array_isset_string(params, SS("name")))) {
827 zephir_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE);
828 } else {
829 ZEPHIR_OBS_VAR(name);
830 zephir_array_fetch_string(&name, params, SL("name"), PH_NOISY, "phalcon/tag.zep", 551 TSRMLS_CC);
831 if (ZEPHIR_IS_EMPTY(name)) {
832 zephir_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE);
833 }
834 }
835 ZEPHIR_SINIT_VAR(_1);
836 ZVAL_STRING(&_1, "[", 0);
837 ZEPHIR_INIT_VAR(_2);
838 zephir_fast_strpos(_2, id, &_1, 0 );
839 if (!(zephir_is_true(_2))) {
840 if (!(zephir_array_isset_string(params, SS("id")))) {
841 zephir_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE);
842 }
843 }
844 ZEPHIR_OBS_VAR(currentValue);
845 if (zephir_array_isset_string_fetch(¤tValue, params, SS("value"), 0 TSRMLS_CC)) {
846 zephir_array_unset_string(¶ms, SS("value"), PH_SEPARATE);
847 ZEPHIR_CALL_SELF(&value, "getvalue", NULL, 0, id, params);
848 zephir_check_call_status();
849 _3$$11 = Z_TYPE_P(value) != IS_NULL;
850 if (_3$$11) {
851 _3$$11 = ZEPHIR_IS_EQUAL(currentValue, value);
852 }
853 if (_3$$11) {
854 ZEPHIR_INIT_VAR(_4$$12);
855 ZVAL_STRING(_4$$12, "checked", 1);
856 zephir_array_update_string(¶ms, SL("checked"), &_4$$12, PH_COPY | PH_SEPARATE);
857 }
858 zephir_array_update_string(¶ms, SL("value"), ¤tValue, PH_COPY | PH_SEPARATE);
859 } else {
860 ZEPHIR_CALL_SELF(&value, "getvalue", NULL, 0, id, params);
861 zephir_check_call_status();
862 if (Z_TYPE_P(value) != IS_NULL) {
863 ZEPHIR_INIT_VAR(_5$$14);
864 ZVAL_STRING(_5$$14, "checked", 1);
865 zephir_array_update_string(¶ms, SL("checked"), &_5$$14, PH_COPY | PH_SEPARATE);
866 }
867 zephir_array_update_string(¶ms, SL("value"), &value, PH_COPY | PH_SEPARATE);
868 }
869 zephir_array_update_string(¶ms, SL("type"), &type, PH_COPY | PH_SEPARATE);
870 ZEPHIR_INIT_VAR(_6);
871 ZVAL_STRING(_6, "<input", ZEPHIR_TEMP_PARAM_COPY);
872 ZEPHIR_CALL_SELF(&code, "renderattributes", NULL, 0, _6, params);
873 zephir_check_temp_parameter(_6);
874 zephir_check_call_status();
875 _7 = zephir_fetch_static_property_ce(phalcon_tag_ce, SL("_documentType") TSRMLS_CC);
876 if (ZEPHIR_GT_LONG(_7, 5)) {
877 zephir_concat_self_str(&code, SL(" />") TSRMLS_CC);
878 } else {
879 zephir_concat_self_str(&code, SL(">") TSRMLS_CC);
880 }
881 RETURN_CCTOR(code);
882
883 }
884
885 /**
886 * Builds a HTML input[type="color"] tag
887 *
888 * @param array parameters
889 * @return string
890 */
PHP_METHOD(Phalcon_Tag,colorField)891 PHP_METHOD(Phalcon_Tag, colorField) {
892
893 zend_long ZEPHIR_LAST_CALL_STATUS;
894 zephir_fcall_cache_entry *_0 = NULL;
895 zval *parameters, *_1;
896
897 ZEPHIR_MM_GROW();
898 zephir_fetch_params(1, 1, 0, ¶meters);
899
900
901
902 ZEPHIR_INIT_VAR(_1);
903 ZVAL_STRING(_1, "color", ZEPHIR_TEMP_PARAM_COPY);
904 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters);
905 zephir_check_temp_parameter(_1);
906 zephir_check_call_status();
907 RETURN_MM();
908
909 }
910
911 /**
912 * Builds a HTML input[type="text"] tag
913 *
914 * <code>
915 * echo Phalcon\Tag::textField(
916 * [
917 * "name",
918 * "size" => 30,
919 * ]
920 * );
921 * </code>
922 *
923 * @param array parameters
924 * @return string
925 */
PHP_METHOD(Phalcon_Tag,textField)926 PHP_METHOD(Phalcon_Tag, textField) {
927
928 zend_long ZEPHIR_LAST_CALL_STATUS;
929 zephir_fcall_cache_entry *_0 = NULL;
930 zval *parameters, *_1;
931
932 ZEPHIR_MM_GROW();
933 zephir_fetch_params(1, 1, 0, ¶meters);
934
935
936
937 ZEPHIR_INIT_VAR(_1);
938 ZVAL_STRING(_1, "text", ZEPHIR_TEMP_PARAM_COPY);
939 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters);
940 zephir_check_temp_parameter(_1);
941 zephir_check_call_status();
942 RETURN_MM();
943
944 }
945
946 /**
947 * Builds a HTML input[type="number"] tag
948 *
949 * <code>
950 * echo Phalcon\Tag::numericField(
951 * [
952 * "price",
953 * "min" => "1",
954 * "max" => "5",
955 * ]
956 * );
957 * </code>
958 *
959 * @param array parameters
960 * @return string
961 */
PHP_METHOD(Phalcon_Tag,numericField)962 PHP_METHOD(Phalcon_Tag, numericField) {
963
964 zend_long ZEPHIR_LAST_CALL_STATUS;
965 zephir_fcall_cache_entry *_0 = NULL;
966 zval *parameters, *_1;
967
968 ZEPHIR_MM_GROW();
969 zephir_fetch_params(1, 1, 0, ¶meters);
970
971
972
973 ZEPHIR_INIT_VAR(_1);
974 ZVAL_STRING(_1, "number", ZEPHIR_TEMP_PARAM_COPY);
975 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters);
976 zephir_check_temp_parameter(_1);
977 zephir_check_call_status();
978 RETURN_MM();
979
980 }
981
982 /**
983 * Builds a HTML input[type="range"] tag
984 *
985 * @param array parameters
986 * @return string
987 */
PHP_METHOD(Phalcon_Tag,rangeField)988 PHP_METHOD(Phalcon_Tag, rangeField) {
989
990 zend_long ZEPHIR_LAST_CALL_STATUS;
991 zephir_fcall_cache_entry *_0 = NULL;
992 zval *parameters, *_1;
993
994 ZEPHIR_MM_GROW();
995 zephir_fetch_params(1, 1, 0, ¶meters);
996
997
998
999 ZEPHIR_INIT_VAR(_1);
1000 ZVAL_STRING(_1, "range", ZEPHIR_TEMP_PARAM_COPY);
1001 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters);
1002 zephir_check_temp_parameter(_1);
1003 zephir_check_call_status();
1004 RETURN_MM();
1005
1006 }
1007
1008 /**
1009 * Builds a HTML input[type="email"] tag
1010 *
1011 * <code>
1012 * echo Phalcon\Tag::emailField("email");
1013 * </code>
1014 *
1015 * @param array parameters
1016 * @return string
1017 */
PHP_METHOD(Phalcon_Tag,emailField)1018 PHP_METHOD(Phalcon_Tag, emailField) {
1019
1020 zend_long ZEPHIR_LAST_CALL_STATUS;
1021 zephir_fcall_cache_entry *_0 = NULL;
1022 zval *parameters, *_1;
1023
1024 ZEPHIR_MM_GROW();
1025 zephir_fetch_params(1, 1, 0, ¶meters);
1026
1027
1028
1029 ZEPHIR_INIT_VAR(_1);
1030 ZVAL_STRING(_1, "email", ZEPHIR_TEMP_PARAM_COPY);
1031 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters);
1032 zephir_check_temp_parameter(_1);
1033 zephir_check_call_status();
1034 RETURN_MM();
1035
1036 }
1037
1038 /**
1039 * Builds a HTML input[type="date"] tag
1040 *
1041 * <code>
1042 * echo Phalcon\Tag::dateField(
1043 * [
1044 * "born",
1045 * "value" => "14-12-1980",
1046 * ]
1047 * );
1048 * </code>
1049 *
1050 * @param array parameters
1051 * @return string
1052 */
PHP_METHOD(Phalcon_Tag,dateField)1053 PHP_METHOD(Phalcon_Tag, dateField) {
1054
1055 zend_long ZEPHIR_LAST_CALL_STATUS;
1056 zephir_fcall_cache_entry *_0 = NULL;
1057 zval *parameters, *_1;
1058
1059 ZEPHIR_MM_GROW();
1060 zephir_fetch_params(1, 1, 0, ¶meters);
1061
1062
1063
1064 ZEPHIR_INIT_VAR(_1);
1065 ZVAL_STRING(_1, "date", ZEPHIR_TEMP_PARAM_COPY);
1066 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters);
1067 zephir_check_temp_parameter(_1);
1068 zephir_check_call_status();
1069 RETURN_MM();
1070
1071 }
1072
1073 /**
1074 * Builds a HTML input[type="datetime"] tag
1075 *
1076 * @param array parameters
1077 * @return string
1078 */
PHP_METHOD(Phalcon_Tag,dateTimeField)1079 PHP_METHOD(Phalcon_Tag, dateTimeField) {
1080
1081 zend_long ZEPHIR_LAST_CALL_STATUS;
1082 zephir_fcall_cache_entry *_0 = NULL;
1083 zval *parameters, *_1;
1084
1085 ZEPHIR_MM_GROW();
1086 zephir_fetch_params(1, 1, 0, ¶meters);
1087
1088
1089
1090 ZEPHIR_INIT_VAR(_1);
1091 ZVAL_STRING(_1, "datetime", ZEPHIR_TEMP_PARAM_COPY);
1092 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters);
1093 zephir_check_temp_parameter(_1);
1094 zephir_check_call_status();
1095 RETURN_MM();
1096
1097 }
1098
1099 /**
1100 * Builds a HTML input[type="datetime-local"] tag
1101 *
1102 * @param array parameters
1103 * @return string
1104 */
PHP_METHOD(Phalcon_Tag,dateTimeLocalField)1105 PHP_METHOD(Phalcon_Tag, dateTimeLocalField) {
1106
1107 zend_long ZEPHIR_LAST_CALL_STATUS;
1108 zephir_fcall_cache_entry *_0 = NULL;
1109 zval *parameters, *_1;
1110
1111 ZEPHIR_MM_GROW();
1112 zephir_fetch_params(1, 1, 0, ¶meters);
1113
1114
1115
1116 ZEPHIR_INIT_VAR(_1);
1117 ZVAL_STRING(_1, "datetime-local", ZEPHIR_TEMP_PARAM_COPY);
1118 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters);
1119 zephir_check_temp_parameter(_1);
1120 zephir_check_call_status();
1121 RETURN_MM();
1122
1123 }
1124
1125 /**
1126 * Builds a HTML input[type="month"] tag
1127 *
1128 * @param array parameters
1129 * @return string
1130 */
PHP_METHOD(Phalcon_Tag,monthField)1131 PHP_METHOD(Phalcon_Tag, monthField) {
1132
1133 zend_long ZEPHIR_LAST_CALL_STATUS;
1134 zephir_fcall_cache_entry *_0 = NULL;
1135 zval *parameters, *_1;
1136
1137 ZEPHIR_MM_GROW();
1138 zephir_fetch_params(1, 1, 0, ¶meters);
1139
1140
1141
1142 ZEPHIR_INIT_VAR(_1);
1143 ZVAL_STRING(_1, "month", ZEPHIR_TEMP_PARAM_COPY);
1144 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters);
1145 zephir_check_temp_parameter(_1);
1146 zephir_check_call_status();
1147 RETURN_MM();
1148
1149 }
1150
1151 /**
1152 * Builds a HTML input[type="time"] tag
1153 *
1154 * @param array parameters
1155 * @return string
1156 */
PHP_METHOD(Phalcon_Tag,timeField)1157 PHP_METHOD(Phalcon_Tag, timeField) {
1158
1159 zend_long ZEPHIR_LAST_CALL_STATUS;
1160 zephir_fcall_cache_entry *_0 = NULL;
1161 zval *parameters, *_1;
1162
1163 ZEPHIR_MM_GROW();
1164 zephir_fetch_params(1, 1, 0, ¶meters);
1165
1166
1167
1168 ZEPHIR_INIT_VAR(_1);
1169 ZVAL_STRING(_1, "time", ZEPHIR_TEMP_PARAM_COPY);
1170 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters);
1171 zephir_check_temp_parameter(_1);
1172 zephir_check_call_status();
1173 RETURN_MM();
1174
1175 }
1176
1177 /**
1178 * Builds a HTML input[type="week"] tag
1179 *
1180 * @param array parameters
1181 * @return string
1182 */
PHP_METHOD(Phalcon_Tag,weekField)1183 PHP_METHOD(Phalcon_Tag, weekField) {
1184
1185 zend_long ZEPHIR_LAST_CALL_STATUS;
1186 zephir_fcall_cache_entry *_0 = NULL;
1187 zval *parameters, *_1;
1188
1189 ZEPHIR_MM_GROW();
1190 zephir_fetch_params(1, 1, 0, ¶meters);
1191
1192
1193
1194 ZEPHIR_INIT_VAR(_1);
1195 ZVAL_STRING(_1, "week", ZEPHIR_TEMP_PARAM_COPY);
1196 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters);
1197 zephir_check_temp_parameter(_1);
1198 zephir_check_call_status();
1199 RETURN_MM();
1200
1201 }
1202
1203 /**
1204 * Builds a HTML input[type="password"] tag
1205 *
1206 *<code>
1207 * echo Phalcon\Tag::passwordField(
1208 * [
1209 * "name",
1210 * "size" => 30,
1211 * ]
1212 * );
1213 *</code>
1214 *
1215 * @param array parameters
1216 * @return string
1217 */
PHP_METHOD(Phalcon_Tag,passwordField)1218 PHP_METHOD(Phalcon_Tag, passwordField) {
1219
1220 zend_long ZEPHIR_LAST_CALL_STATUS;
1221 zephir_fcall_cache_entry *_0 = NULL;
1222 zval *parameters, *_1;
1223
1224 ZEPHIR_MM_GROW();
1225 zephir_fetch_params(1, 1, 0, ¶meters);
1226
1227
1228
1229 ZEPHIR_INIT_VAR(_1);
1230 ZVAL_STRING(_1, "password", ZEPHIR_TEMP_PARAM_COPY);
1231 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters);
1232 zephir_check_temp_parameter(_1);
1233 zephir_check_call_status();
1234 RETURN_MM();
1235
1236 }
1237
1238 /**
1239 * Builds a HTML input[type="hidden"] tag
1240 *
1241 *<code>
1242 * echo Phalcon\Tag::hiddenField(
1243 * [
1244 * "name",
1245 * "value" => "mike",
1246 * ]
1247 * );
1248 *</code>
1249 *
1250 * @param array parameters
1251 * @return string
1252 */
PHP_METHOD(Phalcon_Tag,hiddenField)1253 PHP_METHOD(Phalcon_Tag, hiddenField) {
1254
1255 zend_long ZEPHIR_LAST_CALL_STATUS;
1256 zephir_fcall_cache_entry *_0 = NULL;
1257 zval *parameters, *_1;
1258
1259 ZEPHIR_MM_GROW();
1260 zephir_fetch_params(1, 1, 0, ¶meters);
1261
1262
1263
1264 ZEPHIR_INIT_VAR(_1);
1265 ZVAL_STRING(_1, "hidden", ZEPHIR_TEMP_PARAM_COPY);
1266 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters);
1267 zephir_check_temp_parameter(_1);
1268 zephir_check_call_status();
1269 RETURN_MM();
1270
1271 }
1272
1273 /**
1274 * Builds a HTML input[type="file"] tag
1275 *
1276 *<code>
1277 * echo Phalcon\Tag::fileField("file");
1278 *</code>
1279 *
1280 * @param array parameters
1281 * @return string
1282 */
PHP_METHOD(Phalcon_Tag,fileField)1283 PHP_METHOD(Phalcon_Tag, fileField) {
1284
1285 zend_long ZEPHIR_LAST_CALL_STATUS;
1286 zephir_fcall_cache_entry *_0 = NULL;
1287 zval *parameters, *_1;
1288
1289 ZEPHIR_MM_GROW();
1290 zephir_fetch_params(1, 1, 0, ¶meters);
1291
1292
1293
1294 ZEPHIR_INIT_VAR(_1);
1295 ZVAL_STRING(_1, "file", ZEPHIR_TEMP_PARAM_COPY);
1296 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters);
1297 zephir_check_temp_parameter(_1);
1298 zephir_check_call_status();
1299 RETURN_MM();
1300
1301 }
1302
1303 /**
1304 * Builds a HTML input[type="search"] tag
1305 *
1306 * @param array parameters
1307 * @return string
1308 */
PHP_METHOD(Phalcon_Tag,searchField)1309 PHP_METHOD(Phalcon_Tag, searchField) {
1310
1311 zend_long ZEPHIR_LAST_CALL_STATUS;
1312 zephir_fcall_cache_entry *_0 = NULL;
1313 zval *parameters, *_1;
1314
1315 ZEPHIR_MM_GROW();
1316 zephir_fetch_params(1, 1, 0, ¶meters);
1317
1318
1319
1320 ZEPHIR_INIT_VAR(_1);
1321 ZVAL_STRING(_1, "search", ZEPHIR_TEMP_PARAM_COPY);
1322 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters);
1323 zephir_check_temp_parameter(_1);
1324 zephir_check_call_status();
1325 RETURN_MM();
1326
1327 }
1328
1329 /**
1330 * Builds a HTML input[type="tel"] tag
1331 *
1332 * @param array parameters
1333 * @return string
1334 */
PHP_METHOD(Phalcon_Tag,telField)1335 PHP_METHOD(Phalcon_Tag, telField) {
1336
1337 zend_long ZEPHIR_LAST_CALL_STATUS;
1338 zephir_fcall_cache_entry *_0 = NULL;
1339 zval *parameters, *_1;
1340
1341 ZEPHIR_MM_GROW();
1342 zephir_fetch_params(1, 1, 0, ¶meters);
1343
1344
1345
1346 ZEPHIR_INIT_VAR(_1);
1347 ZVAL_STRING(_1, "tel", ZEPHIR_TEMP_PARAM_COPY);
1348 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters);
1349 zephir_check_temp_parameter(_1);
1350 zephir_check_call_status();
1351 RETURN_MM();
1352
1353 }
1354
1355 /**
1356 * Builds a HTML input[type="url"] tag
1357 *
1358 * @param array parameters
1359 * @return string
1360 */
PHP_METHOD(Phalcon_Tag,urlField)1361 PHP_METHOD(Phalcon_Tag, urlField) {
1362
1363 zend_long ZEPHIR_LAST_CALL_STATUS;
1364 zephir_fcall_cache_entry *_0 = NULL;
1365 zval *parameters, *_1;
1366
1367 ZEPHIR_MM_GROW();
1368 zephir_fetch_params(1, 1, 0, ¶meters);
1369
1370
1371
1372 ZEPHIR_INIT_VAR(_1);
1373 ZVAL_STRING(_1, "url", ZEPHIR_TEMP_PARAM_COPY);
1374 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters);
1375 zephir_check_temp_parameter(_1);
1376 zephir_check_call_status();
1377 RETURN_MM();
1378
1379 }
1380
1381 /**
1382 * Builds a HTML input[type="check"] tag
1383 *
1384 *<code>
1385 * echo Phalcon\Tag::checkField(
1386 * [
1387 * "terms",
1388 * "value" => "Y",
1389 * ]
1390 * );
1391 *</code>
1392 *
1393 * Volt syntax:
1394 *<code>
1395 * {{ check_field("terms") }}
1396 *</code>
1397 *
1398 * @param array parameters
1399 * @return string
1400 */
PHP_METHOD(Phalcon_Tag,checkField)1401 PHP_METHOD(Phalcon_Tag, checkField) {
1402
1403 zend_long ZEPHIR_LAST_CALL_STATUS;
1404 zephir_fcall_cache_entry *_0 = NULL;
1405 zval *parameters, *_1;
1406
1407 ZEPHIR_MM_GROW();
1408 zephir_fetch_params(1, 1, 0, ¶meters);
1409
1410
1411
1412 ZEPHIR_INIT_VAR(_1);
1413 ZVAL_STRING(_1, "checkbox", ZEPHIR_TEMP_PARAM_COPY);
1414 ZEPHIR_RETURN_CALL_SELF("_inputfieldchecked", &_0, 454, _1, parameters);
1415 zephir_check_temp_parameter(_1);
1416 zephir_check_call_status();
1417 RETURN_MM();
1418
1419 }
1420
1421 /**
1422 * Builds a HTML input[type="radio"] tag
1423 *
1424 *<code>
1425 * echo Phalcon\Tag::radioField(
1426 * [
1427 * "weather",
1428 * "value" => "hot",
1429 * ]
1430 * );
1431 *</code>
1432 *
1433 * Volt syntax:
1434 *<code>
1435 * {{ radio_field("Save") }}
1436 *</code>
1437 *
1438 * @param array parameters
1439 * @return string
1440 */
PHP_METHOD(Phalcon_Tag,radioField)1441 PHP_METHOD(Phalcon_Tag, radioField) {
1442
1443 zend_long ZEPHIR_LAST_CALL_STATUS;
1444 zephir_fcall_cache_entry *_0 = NULL;
1445 zval *parameters, *_1;
1446
1447 ZEPHIR_MM_GROW();
1448 zephir_fetch_params(1, 1, 0, ¶meters);
1449
1450
1451
1452 ZEPHIR_INIT_VAR(_1);
1453 ZVAL_STRING(_1, "radio", ZEPHIR_TEMP_PARAM_COPY);
1454 ZEPHIR_RETURN_CALL_SELF("_inputfieldchecked", &_0, 454, _1, parameters);
1455 zephir_check_temp_parameter(_1);
1456 zephir_check_call_status();
1457 RETURN_MM();
1458
1459 }
1460
1461 /**
1462 * Builds a HTML input[type="image"] tag
1463 *
1464 *<code>
1465 * echo Phalcon\Tag::imageInput(
1466 * [
1467 * "src" => "/img/button.png",
1468 * ]
1469 * );
1470 *</code>
1471 *
1472 * Volt syntax:
1473 *<code>
1474 * {{ image_input("src": "/img/button.png") }}
1475 *</code>
1476 *
1477 * @param array parameters
1478 * @return string
1479 */
PHP_METHOD(Phalcon_Tag,imageInput)1480 PHP_METHOD(Phalcon_Tag, imageInput) {
1481
1482 zend_long ZEPHIR_LAST_CALL_STATUS;
1483 zephir_fcall_cache_entry *_0 = NULL;
1484 zval *parameters, *_1, *_2;
1485
1486 ZEPHIR_MM_GROW();
1487 zephir_fetch_params(1, 1, 0, ¶meters);
1488
1489
1490
1491 ZEPHIR_INIT_VAR(_1);
1492 ZVAL_STRING(_1, "image", ZEPHIR_TEMP_PARAM_COPY);
1493 ZEPHIR_INIT_VAR(_2);
1494 ZVAL_BOOL(_2, 1);
1495 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters, _2);
1496 zephir_check_temp_parameter(_1);
1497 zephir_check_call_status();
1498 RETURN_MM();
1499
1500 }
1501
1502 /**
1503 * Builds a HTML input[type="submit"] tag
1504 *
1505 *<code>
1506 * echo Phalcon\Tag::submitButton("Save")
1507 *</code>
1508 *
1509 * Volt syntax:
1510 *<code>
1511 * {{ submit_button("Save") }}
1512 *</code>
1513 *
1514 * @param array parameters
1515 * @return string
1516 */
PHP_METHOD(Phalcon_Tag,submitButton)1517 PHP_METHOD(Phalcon_Tag, submitButton) {
1518
1519 zend_long ZEPHIR_LAST_CALL_STATUS;
1520 zephir_fcall_cache_entry *_0 = NULL;
1521 zval *parameters, *_1, *_2;
1522
1523 ZEPHIR_MM_GROW();
1524 zephir_fetch_params(1, 1, 0, ¶meters);
1525
1526
1527
1528 ZEPHIR_INIT_VAR(_1);
1529 ZVAL_STRING(_1, "submit", ZEPHIR_TEMP_PARAM_COPY);
1530 ZEPHIR_INIT_VAR(_2);
1531 ZVAL_BOOL(_2, 1);
1532 ZEPHIR_RETURN_CALL_SELF("_inputfield", &_0, 453, _1, parameters, _2);
1533 zephir_check_temp_parameter(_1);
1534 zephir_check_call_status();
1535 RETURN_MM();
1536
1537 }
1538
1539 /**
1540 * Builds a HTML SELECT tag using a PHP array for options
1541 *
1542 *<code>
1543 * echo Phalcon\Tag::selectStatic(
1544 * "status",
1545 * [
1546 * "A" => "Active",
1547 * "I" => "Inactive",
1548 * ]
1549 * );
1550 *</code>
1551 *
1552 * @param array parameters
1553 * @param array data
1554 * @return string
1555 */
PHP_METHOD(Phalcon_Tag,selectStatic)1556 PHP_METHOD(Phalcon_Tag, selectStatic) {
1557
1558 zend_long ZEPHIR_LAST_CALL_STATUS;
1559 zephir_fcall_cache_entry *_0 = NULL;
1560 zval *parameters, *data = NULL;
1561
1562 ZEPHIR_MM_GROW();
1563 zephir_fetch_params(1, 1, 1, ¶meters, &data);
1564
1565 if (!data) {
1566 data = ZEPHIR_GLOBAL(global_null);
1567 }
1568
1569
1570 ZEPHIR_RETURN_CALL_CE_STATIC(phalcon_tag_select_ce, "selectfield", &_0, 227, parameters, data);
1571 zephir_check_call_status();
1572 RETURN_MM();
1573
1574 }
1575
1576 /**
1577 * Builds a HTML SELECT tag using a Phalcon\Mvc\Model resultset as options
1578 *
1579 *<code>
1580 * echo Phalcon\Tag::select(
1581 * [
1582 * "robotId",
1583 * Robots::find("type = "mechanical""),
1584 * "using" => ["id", "name"],
1585 * ]
1586 * );
1587 *</code>
1588 *
1589 * Volt syntax:
1590 *<code>
1591 * {{ select("robotId", robots, "using": ["id", "name"]) }}
1592 *</code>
1593 *
1594 * @param array parameters
1595 * @param array data
1596 * @return string
1597 */
PHP_METHOD(Phalcon_Tag,select)1598 PHP_METHOD(Phalcon_Tag, select) {
1599
1600 zend_long ZEPHIR_LAST_CALL_STATUS;
1601 zephir_fcall_cache_entry *_0 = NULL;
1602 zval *parameters, *data = NULL;
1603
1604 ZEPHIR_MM_GROW();
1605 zephir_fetch_params(1, 1, 1, ¶meters, &data);
1606
1607 if (!data) {
1608 data = ZEPHIR_GLOBAL(global_null);
1609 }
1610
1611
1612 ZEPHIR_RETURN_CALL_CE_STATIC(phalcon_tag_select_ce, "selectfield", &_0, 227, parameters, data);
1613 zephir_check_call_status();
1614 RETURN_MM();
1615
1616 }
1617
1618 /**
1619 * Builds a HTML TEXTAREA tag
1620 *
1621 *<code>
1622 * echo Phalcon\Tag::textArea(
1623 * [
1624 * "comments",
1625 * "cols" => 10,
1626 * "rows" => 4,
1627 * ]
1628 * );
1629 *</code>
1630 *
1631 * Volt syntax:
1632 *<code>
1633 * {{ text_area("comments", "cols": 10, "rows": 4) }}
1634 *</code>
1635 *
1636 * @param array parameters
1637 * @return string
1638 */
PHP_METHOD(Phalcon_Tag,textArea)1639 PHP_METHOD(Phalcon_Tag, textArea) {
1640
1641 zend_long ZEPHIR_LAST_CALL_STATUS;
1642 zval *parameters, *params = NULL, *id = NULL, *name = NULL, *content = NULL, *code = NULL, *_1, *_2, *_0$$6;
1643
1644 ZEPHIR_MM_GROW();
1645 zephir_fetch_params(1, 1, 0, ¶meters);
1646
1647
1648
1649 if (Z_TYPE_P(parameters) != IS_ARRAY) {
1650 ZEPHIR_INIT_VAR(params);
1651 zephir_create_array(params, 1, 0 TSRMLS_CC);
1652 zephir_array_fast_append(params, parameters);
1653 } else {
1654 ZEPHIR_CPY_WRT(params, parameters);
1655 }
1656 if (!(zephir_array_isset_long(params, 0))) {
1657 if (zephir_array_isset_string(params, SS("id"))) {
1658 zephir_array_fetch_string(&_0$$6, params, SL("id"), PH_NOISY | PH_READONLY, "phalcon/tag.zep", 1027 TSRMLS_CC);
1659 zephir_array_update_long(¶ms, 0, &_0$$6, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY);
1660 }
1661 }
1662 ZEPHIR_OBS_VAR(id);
1663 zephir_array_fetch_long(&id, params, 0, PH_NOISY, "phalcon/tag.zep", 1031 TSRMLS_CC);
1664 if (!(zephir_array_isset_string(params, SS("name")))) {
1665 zephir_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE);
1666 } else {
1667 ZEPHIR_OBS_VAR(name);
1668 zephir_array_fetch_string(&name, params, SL("name"), PH_NOISY, "phalcon/tag.zep", 1035 TSRMLS_CC);
1669 if (ZEPHIR_IS_EMPTY(name)) {
1670 zephir_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE);
1671 }
1672 }
1673 if (!(zephir_array_isset_string(params, SS("id")))) {
1674 zephir_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE);
1675 }
1676 if (zephir_array_isset_string(params, SS("value"))) {
1677 ZEPHIR_OBS_VAR(content);
1678 zephir_array_fetch_string(&content, params, SL("value"), PH_NOISY, "phalcon/tag.zep", 1046 TSRMLS_CC);
1679 zephir_array_unset_string(¶ms, SS("value"), PH_SEPARATE);
1680 } else {
1681 ZEPHIR_CALL_SELF(&content, "getvalue", NULL, 0, id, params);
1682 zephir_check_call_status();
1683 }
1684 ZEPHIR_INIT_VAR(_1);
1685 ZVAL_STRING(_1, "<textarea", ZEPHIR_TEMP_PARAM_COPY);
1686 ZEPHIR_CALL_SELF(&code, "renderattributes", NULL, 0, _1, params);
1687 zephir_check_temp_parameter(_1);
1688 zephir_check_call_status();
1689 ZEPHIR_INIT_VAR(_2);
1690 ZEPHIR_CONCAT_SVS(_2, ">", content, "</textarea>");
1691 zephir_concat_self(&code, _2 TSRMLS_CC);
1692 RETURN_CCTOR(code);
1693
1694 }
1695
1696 /**
1697 * Builds a HTML FORM tag
1698 *
1699 * <code>
1700 * echo Phalcon\Tag::form("posts/save");
1701 *
1702 * echo Phalcon\Tag::form(
1703 * [
1704 * "posts/save",
1705 * "method" => "post",
1706 * ]
1707 * );
1708 * </code>
1709 *
1710 * Volt syntax:
1711 * <code>
1712 * {{ form("posts/save") }}
1713 * {{ form("posts/save", "method": "post") }}
1714 * </code>
1715 *
1716 * @param array parameters
1717 * @return string
1718 */
PHP_METHOD(Phalcon_Tag,form)1719 PHP_METHOD(Phalcon_Tag, form) {
1720
1721 zend_long ZEPHIR_LAST_CALL_STATUS;
1722 zval *parameters = NULL, *params = NULL, *paramsAction = NULL, *action = NULL, *code = NULL, *_3, *_0$$6, *_1$$7 = NULL, *_2$$8;
1723
1724 ZEPHIR_MM_GROW();
1725 zephir_fetch_params(1, 1, 0, ¶meters);
1726
1727 ZEPHIR_SEPARATE_PARAM(parameters);
1728
1729
1730 if (Z_TYPE_P(parameters) != IS_ARRAY) {
1731 ZEPHIR_INIT_VAR(params);
1732 zephir_create_array(params, 1, 0 TSRMLS_CC);
1733 zephir_array_fast_append(params, parameters);
1734 } else {
1735 ZEPHIR_CPY_WRT(params, parameters);
1736 }
1737 ZEPHIR_OBS_VAR(paramsAction);
1738 if (!(zephir_array_isset_long_fetch(¶msAction, params, 0, 0 TSRMLS_CC))) {
1739 ZEPHIR_OBS_NVAR(paramsAction);
1740 zephir_array_isset_string_fetch(¶msAction, params, SS("action"), 0 TSRMLS_CC);
1741 }
1742 if (!(zephir_array_isset_string(params, SS("method")))) {
1743 ZEPHIR_INIT_VAR(_0$$6);
1744 ZVAL_STRING(_0$$6, "post", 1);
1745 zephir_array_update_string(¶ms, SL("method"), &_0$$6, PH_COPY | PH_SEPARATE);
1746 }
1747 ZEPHIR_INIT_VAR(action);
1748 ZVAL_NULL(action);
1749 if (!(ZEPHIR_IS_EMPTY(paramsAction))) {
1750 ZEPHIR_CALL_SELF(&_1$$7, "geturlservice", NULL, 0);
1751 zephir_check_call_status();
1752 ZEPHIR_CALL_METHOD(&action, _1$$7, "get", NULL, 0, paramsAction);
1753 zephir_check_call_status();
1754 }
1755 ZEPHIR_OBS_NVAR(parameters);
1756 if (zephir_array_isset_string_fetch(¶meters, params, SS("parameters"), 0 TSRMLS_CC)) {
1757 ZEPHIR_INIT_VAR(_2$$8);
1758 ZEPHIR_CONCAT_SV(_2$$8, "?", parameters);
1759 zephir_concat_self(&action, _2$$8 TSRMLS_CC);
1760 zephir_array_unset_string(¶ms, SS("parameters"), PH_SEPARATE);
1761 }
1762 if (!(ZEPHIR_IS_EMPTY(action))) {
1763 zephir_array_update_string(¶ms, SL("action"), &action, PH_COPY | PH_SEPARATE);
1764 }
1765 ZEPHIR_INIT_VAR(_3);
1766 ZVAL_STRING(_3, "<form", ZEPHIR_TEMP_PARAM_COPY);
1767 ZEPHIR_CALL_SELF(&code, "renderattributes", NULL, 0, _3, params);
1768 zephir_check_temp_parameter(_3);
1769 zephir_check_call_status();
1770 zephir_concat_self_str(&code, SL(">") TSRMLS_CC);
1771 RETURN_CCTOR(code);
1772
1773 }
1774
1775 /**
1776 * Builds a HTML close FORM tag
1777 */
PHP_METHOD(Phalcon_Tag,endForm)1778 PHP_METHOD(Phalcon_Tag, endForm) {
1779
1780
1781
1782 RETURN_STRING("</form>", 1);
1783
1784 }
1785
1786 /**
1787 * Set the title of view content
1788 *
1789 *<code>
1790 * Phalcon\Tag::setTitle("Welcome to my Page");
1791 *</code>
1792 */
PHP_METHOD(Phalcon_Tag,setTitle)1793 PHP_METHOD(Phalcon_Tag, setTitle) {
1794
1795 zval *title_param = NULL;
1796 zval *title = NULL;
1797
1798 ZEPHIR_MM_GROW();
1799 zephir_fetch_params(1, 1, 0, &title_param);
1800
1801 zephir_get_strval(title, title_param);
1802
1803
1804 zephir_update_static_property_ce(phalcon_tag_ce, SL("_documentTitle"), &title TSRMLS_CC);
1805 ZEPHIR_MM_RESTORE();
1806
1807 }
1808
1809 /**
1810 * Set the title separator of view content
1811 *
1812 *<code>
1813 * Phalcon\Tag::setTitleSeparator("-");
1814 *</code>
1815 */
PHP_METHOD(Phalcon_Tag,setTitleSeparator)1816 PHP_METHOD(Phalcon_Tag, setTitleSeparator) {
1817
1818 zval *titleSeparator_param = NULL;
1819 zval *titleSeparator = NULL;
1820
1821 ZEPHIR_MM_GROW();
1822 zephir_fetch_params(1, 1, 0, &titleSeparator_param);
1823
1824 zephir_get_strval(titleSeparator, titleSeparator_param);
1825
1826
1827 zephir_update_static_property_ce(phalcon_tag_ce, SL("_documentTitleSeparator"), &titleSeparator TSRMLS_CC);
1828 ZEPHIR_MM_RESTORE();
1829
1830 }
1831
1832 /**
1833 * Appends a text to current document title
1834 */
PHP_METHOD(Phalcon_Tag,appendTitle)1835 PHP_METHOD(Phalcon_Tag, appendTitle) {
1836
1837 zval *title, *_0, *_1$$3;
1838
1839 ZEPHIR_MM_GROW();
1840 zephir_fetch_params(1, 1, 0, &title);
1841
1842
1843
1844 ZEPHIR_OBS_VAR(_0);
1845 zephir_read_static_property_ce(&_0, phalcon_tag_ce, SL("_documentAppendTitle") TSRMLS_CC);
1846 if (Z_TYPE_P(_0) == IS_NULL) {
1847 ZEPHIR_INIT_VAR(_1$$3);
1848 array_init(_1$$3);
1849 zephir_update_static_property_ce(phalcon_tag_ce, SL("_documentAppendTitle"), &_1$$3 TSRMLS_CC);
1850 }
1851 if (Z_TYPE_P(title) == IS_ARRAY) {
1852 zephir_update_static_property_ce(phalcon_tag_ce, SL("_documentAppendTitle"), &title TSRMLS_CC);
1853 } else {
1854 zephir_update_static_property_array_multi_ce(phalcon_tag_ce, SL("_documentAppendTitle"), &title TSRMLS_CC, SL("a"), 1);
1855 }
1856 ZEPHIR_MM_RESTORE();
1857
1858 }
1859
1860 /**
1861 * Prepends a text to current document title
1862 */
PHP_METHOD(Phalcon_Tag,prependTitle)1863 PHP_METHOD(Phalcon_Tag, prependTitle) {
1864
1865 zval *title, *_0, *_1$$3;
1866
1867 ZEPHIR_MM_GROW();
1868 zephir_fetch_params(1, 1, 0, &title);
1869
1870
1871
1872 ZEPHIR_OBS_VAR(_0);
1873 zephir_read_static_property_ce(&_0, phalcon_tag_ce, SL("_documentPrependTitle") TSRMLS_CC);
1874 if (Z_TYPE_P(_0) == IS_NULL) {
1875 ZEPHIR_INIT_VAR(_1$$3);
1876 array_init(_1$$3);
1877 zephir_update_static_property_ce(phalcon_tag_ce, SL("_documentPrependTitle"), &_1$$3 TSRMLS_CC);
1878 }
1879 if (Z_TYPE_P(title) == IS_ARRAY) {
1880 zephir_update_static_property_ce(phalcon_tag_ce, SL("_documentPrependTitle"), &title TSRMLS_CC);
1881 } else {
1882 zephir_update_static_property_array_multi_ce(phalcon_tag_ce, SL("_documentPrependTitle"), &title TSRMLS_CC, SL("a"), 1);
1883 }
1884 ZEPHIR_MM_RESTORE();
1885
1886 }
1887
1888 /**
1889 * Gets the current document title.
1890 * The title will be automatically escaped.
1891 *
1892 * <code>
1893 * echo Phalcon\Tag::getTitle();
1894 * </code>
1895 *
1896 * <code>
1897 * {{ get_title() }}
1898 * </code>
1899 */
PHP_METHOD(Phalcon_Tag,getTitle)1900 PHP_METHOD(Phalcon_Tag, getTitle) {
1901
1902 HashTable *_9$$5, *_14$$8;
1903 HashPosition _8$$5, _13$$8;
1904 zval *_1;
1905 zephir_fcall_cache_entry *_12 = NULL, *_17 = NULL;
1906 zend_long ZEPHIR_LAST_CALL_STATUS;
1907 zval *tags_param = NULL, *items = NULL, *output = NULL, *title = NULL, *documentTitle = NULL, *documentAppendTitle = NULL, *documentPrependTitle = NULL, *documentTitleSeparator = NULL, *escaper = NULL, *_0 = NULL, *_2, *_3, *_4, *_6, *_5$$3, *_7$$4, *tmp$$5 = NULL, **_10$$5, *_11$$6 = NULL, **_15$$8, *_16$$9 = NULL, *_18$$12;
1908 zend_bool tags;
1909
1910 ZEPHIR_MM_GROW();
1911 zephir_fetch_params(1, 0, 1, &tags_param);
1912
1913 if (!tags_param) {
1914 tags = 1;
1915 } else {
1916 tags = zephir_get_boolval(tags_param);
1917 }
1918
1919
1920 ZEPHIR_INIT_VAR(_1);
1921 zephir_create_array(_1, 1, 0 TSRMLS_CC);
1922 zephir_array_update_string(&_1, SL("escape"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
1923 ZEPHIR_CALL_SELF(&_0, "getescaper", NULL, 0, _1);
1924 zephir_check_call_status();
1925 ZEPHIR_CPY_WRT(escaper, _0);
1926 ZEPHIR_INIT_VAR(items);
1927 array_init(items);
1928 ZEPHIR_INIT_VAR(output);
1929 ZVAL_STRING(output, "", 1);
1930 _2 = zephir_fetch_static_property_ce(phalcon_tag_ce, SL("_documentTitle") TSRMLS_CC);
1931 ZEPHIR_CALL_METHOD(&documentTitle, escaper, "escapehtml", NULL, 0, _2);
1932 zephir_check_call_status();
1933 _3 = zephir_fetch_static_property_ce(phalcon_tag_ce, SL("_documentTitleSeparator") TSRMLS_CC);
1934 ZEPHIR_CALL_METHOD(&documentTitleSeparator, escaper, "escapehtml", NULL, 0, _3);
1935 zephir_check_call_status();
1936 ZEPHIR_OBS_VAR(_4);
1937 zephir_read_static_property_ce(&_4, phalcon_tag_ce, SL("_documentAppendTitle") TSRMLS_CC);
1938 if (Z_TYPE_P(_4) == IS_NULL) {
1939 ZEPHIR_INIT_VAR(_5$$3);
1940 array_init(_5$$3);
1941 zephir_update_static_property_ce(phalcon_tag_ce, SL("_documentAppendTitle"), &_5$$3 TSRMLS_CC);
1942 }
1943 ZEPHIR_OBS_VAR(documentAppendTitle);
1944 zephir_read_static_property_ce(&documentAppendTitle, phalcon_tag_ce, SL("_documentAppendTitle") TSRMLS_CC);
1945 ZEPHIR_OBS_VAR(_6);
1946 zephir_read_static_property_ce(&_6, phalcon_tag_ce, SL("_documentPrependTitle") TSRMLS_CC);
1947 if (Z_TYPE_P(_6) == IS_NULL) {
1948 ZEPHIR_INIT_VAR(_7$$4);
1949 array_init(_7$$4);
1950 zephir_update_static_property_ce(phalcon_tag_ce, SL("_documentPrependTitle"), &_7$$4 TSRMLS_CC);
1951 }
1952 ZEPHIR_OBS_VAR(documentPrependTitle);
1953 zephir_read_static_property_ce(&documentPrependTitle, phalcon_tag_ce, SL("_documentPrependTitle") TSRMLS_CC);
1954 if (!(ZEPHIR_IS_EMPTY(documentPrependTitle))) {
1955 ZEPHIR_CALL_FUNCTION(&tmp$$5, "array_reverse", NULL, 455, documentPrependTitle);
1956 zephir_check_call_status();
1957 zephir_is_iterable(tmp$$5, &_9$$5, &_8$$5, 0, 0, "phalcon/tag.zep", 1229);
1958 for (
1959 ; zend_hash_get_current_data_ex(_9$$5, (void**) &_10$$5, &_8$$5) == SUCCESS
1960 ; zend_hash_move_forward_ex(_9$$5, &_8$$5)
1961 ) {
1962 ZEPHIR_GET_HVALUE(title, _10$$5);
1963 ZEPHIR_CALL_METHOD(&_11$$6, escaper, "escapehtml", &_12, 0, title);
1964 zephir_check_call_status();
1965 zephir_array_append(&items, _11$$6, PH_SEPARATE, "phalcon/tag.zep", 1227);
1966 }
1967 }
1968 if (!(ZEPHIR_IS_EMPTY(documentTitle))) {
1969 zephir_array_append(&items, documentTitle, PH_SEPARATE, "phalcon/tag.zep", 1232);
1970 }
1971 if (!(ZEPHIR_IS_EMPTY(documentAppendTitle))) {
1972 zephir_is_iterable(documentAppendTitle, &_14$$8, &_13$$8, 0, 0, "phalcon/tag.zep", 1239);
1973 for (
1974 ; zend_hash_get_current_data_ex(_14$$8, (void**) &_15$$8, &_13$$8) == SUCCESS
1975 ; zend_hash_move_forward_ex(_14$$8, &_13$$8)
1976 ) {
1977 ZEPHIR_GET_HVALUE(title, _15$$8);
1978 ZEPHIR_CALL_METHOD(&_16$$9, escaper, "escapehtml", &_17, 0, title);
1979 zephir_check_call_status();
1980 zephir_array_append(&items, _16$$9, PH_SEPARATE, "phalcon/tag.zep", 1237);
1981 }
1982 }
1983 if (ZEPHIR_IS_EMPTY(documentTitleSeparator)) {
1984 ZEPHIR_INIT_NVAR(documentTitleSeparator);
1985 ZVAL_STRING(documentTitleSeparator, "", 1);
1986 }
1987 if (!(ZEPHIR_IS_EMPTY(items))) {
1988 ZEPHIR_INIT_NVAR(output);
1989 zephir_fast_join(output, documentTitleSeparator, items TSRMLS_CC);
1990 }
1991 if (tags) {
1992 ZEPHIR_INIT_VAR(_18$$12);
1993 ZEPHIR_GET_CONSTANT(_18$$12, "PHP_EOL");
1994 ZEPHIR_CONCAT_SVSV(return_value, "<title>", output, "</title>", _18$$12);
1995 RETURN_MM();
1996 }
1997 RETURN_CCTOR(output);
1998
1999 }
2000
2001 /**
2002 * Gets the current document title separator
2003 *
2004 * <code>
2005 * echo Phalcon\Tag::getTitleSeparator();
2006 * </code>
2007 *
2008 * <code>
2009 * {{ get_title_separator() }}
2010 * </code>
2011 */
PHP_METHOD(Phalcon_Tag,getTitleSeparator)2012 PHP_METHOD(Phalcon_Tag, getTitleSeparator) {
2013
2014 zval *_0;
2015
2016
2017 _0 = zephir_fetch_static_property_ce(phalcon_tag_ce, SL("_documentTitleSeparator") TSRMLS_CC);
2018 RETURN_CTORW(_0);
2019
2020 }
2021
2022 /**
2023 * Builds a LINK[rel="stylesheet"] tag
2024 *
2025 * <code>
2026 * echo Phalcon\Tag::stylesheetLink("http://fonts.googleapis.com/css?family=Rosario", false);
2027 * echo Phalcon\Tag::stylesheetLink("css/style.css");
2028 * </code>
2029 *
2030 * Volt Syntax:
2031 *<code>
2032 * {{ stylesheet_link("http://fonts.googleapis.com/css?family=Rosario", false) }}
2033 * {{ stylesheet_link("css/style.css") }}
2034 *</code>
2035 *
2036 * @param array parameters
2037 * @param boolean local
2038 * @return string
2039 */
PHP_METHOD(Phalcon_Tag,stylesheetLink)2040 PHP_METHOD(Phalcon_Tag, stylesheetLink) {
2041
2042 zend_long ZEPHIR_LAST_CALL_STATUS;
2043 zend_bool local;
2044 zval *parameters = NULL, *local_param = NULL, *params = NULL, *code = NULL, *_10, *_11, *_0$$3, *_1$$5, *_2$$7, *_3$$8, *_4$$10, *_5$$11, *_6$$12 = NULL, *_7$$12 = NULL, *_8$$12, *_9$$13, *_12$$14, *_13$$14, *_14$$15, *_15$$15;
2045
2046 ZEPHIR_MM_GROW();
2047 zephir_fetch_params(1, 0, 2, ¶meters, &local_param);
2048
2049 if (!parameters) {
2050 parameters = ZEPHIR_GLOBAL(global_null);
2051 }
2052 if (!local_param) {
2053 local = 1;
2054 } else {
2055 local = zephir_get_boolval(local_param);
2056 }
2057
2058
2059 if (Z_TYPE_P(parameters) != IS_ARRAY) {
2060 ZEPHIR_INIT_VAR(params);
2061 zephir_create_array(params, 2, 0 TSRMLS_CC);
2062 zephir_array_fast_append(params, parameters);
2063 ZEPHIR_INIT_VAR(_0$$3);
2064 ZVAL_BOOL(_0$$3, local);
2065 zephir_array_fast_append(params, _0$$3);
2066 } else {
2067 ZEPHIR_CPY_WRT(params, parameters);
2068 }
2069 if (zephir_array_isset_long(params, 1)) {
2070 ZEPHIR_OBS_VAR(_1$$5);
2071 zephir_array_fetch_long(&_1$$5, params, 1, PH_NOISY, "phalcon/tag.zep", 1301 TSRMLS_CC);
2072 local = zephir_get_boolval(_1$$5);
2073 } else {
2074 if (zephir_array_isset_string(params, SS("local"))) {
2075 ZEPHIR_OBS_VAR(_2$$7);
2076 zephir_array_fetch_string(&_2$$7, params, SL("local"), PH_NOISY, "phalcon/tag.zep", 1304 TSRMLS_CC);
2077 local = zephir_get_boolval(_2$$7);
2078 zephir_array_unset_string(¶ms, SS("local"), PH_SEPARATE);
2079 }
2080 }
2081 if (!(zephir_array_isset_string(params, SS("type")))) {
2082 ZEPHIR_INIT_VAR(_3$$8);
2083 ZVAL_STRING(_3$$8, "text/css", 1);
2084 zephir_array_update_string(¶ms, SL("type"), &_3$$8, PH_COPY | PH_SEPARATE);
2085 }
2086 if (!(zephir_array_isset_string(params, SS("href")))) {
2087 if (zephir_array_isset_long(params, 0)) {
2088 zephir_array_fetch_long(&_4$$10, params, 0, PH_NOISY | PH_READONLY, "phalcon/tag.zep", 1315 TSRMLS_CC);
2089 zephir_array_update_string(¶ms, SL("href"), &_4$$10, PH_COPY | PH_SEPARATE);
2090 } else {
2091 ZEPHIR_INIT_VAR(_5$$11);
2092 ZVAL_STRING(_5$$11, "", 1);
2093 zephir_array_update_string(¶ms, SL("href"), &_5$$11, PH_COPY | PH_SEPARATE);
2094 }
2095 }
2096 if (local == 1) {
2097 ZEPHIR_CALL_SELF(&_6$$12, "geturlservice", NULL, 0);
2098 zephir_check_call_status();
2099 zephir_array_fetch_string(&_8$$12, params, SL("href"), PH_NOISY | PH_READONLY, "phalcon/tag.zep", 1325 TSRMLS_CC);
2100 ZEPHIR_CALL_METHOD(&_7$$12, _6$$12, "getstatic", NULL, 0, _8$$12);
2101 zephir_check_call_status();
2102 zephir_array_update_string(¶ms, SL("href"), &_7$$12, PH_COPY | PH_SEPARATE);
2103 }
2104 if (!(zephir_array_isset_string(params, SS("rel")))) {
2105 ZEPHIR_INIT_VAR(_9$$13);
2106 ZVAL_STRING(_9$$13, "stylesheet", 1);
2107 zephir_array_update_string(¶ms, SL("rel"), &_9$$13, PH_COPY | PH_SEPARATE);
2108 }
2109 ZEPHIR_INIT_VAR(_10);
2110 ZVAL_STRING(_10, "<link", ZEPHIR_TEMP_PARAM_COPY);
2111 ZEPHIR_CALL_SELF(&code, "renderattributes", NULL, 0, _10, params);
2112 zephir_check_temp_parameter(_10);
2113 zephir_check_call_status();
2114 _11 = zephir_fetch_static_property_ce(phalcon_tag_ce, SL("_documentType") TSRMLS_CC);
2115 if (ZEPHIR_GT_LONG(_11, 5)) {
2116 ZEPHIR_INIT_VAR(_12$$14);
2117 ZEPHIR_GET_CONSTANT(_12$$14, "PHP_EOL");
2118 ZEPHIR_INIT_VAR(_13$$14);
2119 ZEPHIR_CONCAT_SV(_13$$14, " />", _12$$14);
2120 zephir_concat_self(&code, _13$$14 TSRMLS_CC);
2121 } else {
2122 ZEPHIR_INIT_VAR(_14$$15);
2123 ZEPHIR_GET_CONSTANT(_14$$15, "PHP_EOL");
2124 ZEPHIR_INIT_VAR(_15$$15);
2125 ZEPHIR_CONCAT_SV(_15$$15, ">", _14$$15);
2126 zephir_concat_self(&code, _15$$15 TSRMLS_CC);
2127 }
2128 RETURN_CCTOR(code);
2129
2130 }
2131
2132 /**
2133 * Builds a SCRIPT[type="javascript"] tag
2134 *
2135 * <code>
2136 * echo Phalcon\Tag::javascriptInclude("http://ajax.googleapis.com/ajax/libs/jquery/2.2.3/jquery.min.js", false);
2137 * echo Phalcon\Tag::javascriptInclude("javascript/jquery.js");
2138 * </code>
2139 *
2140 * Volt syntax:
2141 * <code>
2142 * {{ javascript_include("http://ajax.googleapis.com/ajax/libs/jquery/2.2.3/jquery.min.js", false) }}
2143 * {{ javascript_include("javascript/jquery.js") }}
2144 * </code>
2145 *
2146 * @param array parameters
2147 * @param boolean local
2148 * @return string
2149 */
PHP_METHOD(Phalcon_Tag,javascriptInclude)2150 PHP_METHOD(Phalcon_Tag, javascriptInclude) {
2151
2152 zend_long ZEPHIR_LAST_CALL_STATUS;
2153 zend_bool local;
2154 zval *parameters = NULL, *local_param = NULL, *params = NULL, *code = NULL, *_9 = NULL, *_10, *_0$$3, *_1$$5, *_2$$7, *_3$$8, *_4$$10, *_5$$11, *_6$$12 = NULL, *_7$$12 = NULL, *_8$$12;
2155
2156 ZEPHIR_MM_GROW();
2157 zephir_fetch_params(1, 0, 2, ¶meters, &local_param);
2158
2159 if (!parameters) {
2160 parameters = ZEPHIR_GLOBAL(global_null);
2161 }
2162 if (!local_param) {
2163 local = 1;
2164 } else {
2165 local = zephir_get_boolval(local_param);
2166 }
2167
2168
2169 if (Z_TYPE_P(parameters) != IS_ARRAY) {
2170 ZEPHIR_INIT_VAR(params);
2171 zephir_create_array(params, 2, 0 TSRMLS_CC);
2172 zephir_array_fast_append(params, parameters);
2173 ZEPHIR_INIT_VAR(_0$$3);
2174 ZVAL_BOOL(_0$$3, local);
2175 zephir_array_fast_append(params, _0$$3);
2176 } else {
2177 ZEPHIR_CPY_WRT(params, parameters);
2178 }
2179 if (zephir_array_isset_long(params, 1)) {
2180 ZEPHIR_OBS_VAR(_1$$5);
2181 zephir_array_fetch_long(&_1$$5, params, 1, PH_NOISY, "phalcon/tag.zep", 1375 TSRMLS_CC);
2182 local = zephir_get_boolval(_1$$5);
2183 } else {
2184 if (zephir_array_isset_string(params, SS("local"))) {
2185 ZEPHIR_OBS_VAR(_2$$7);
2186 zephir_array_fetch_string(&_2$$7, params, SL("local"), PH_NOISY, "phalcon/tag.zep", 1378 TSRMLS_CC);
2187 local = zephir_get_boolval(_2$$7);
2188 zephir_array_unset_string(¶ms, SS("local"), PH_SEPARATE);
2189 }
2190 }
2191 if (!(zephir_array_isset_string(params, SS("type")))) {
2192 ZEPHIR_INIT_VAR(_3$$8);
2193 ZVAL_STRING(_3$$8, "text/javascript", 1);
2194 zephir_array_update_string(¶ms, SL("type"), &_3$$8, PH_COPY | PH_SEPARATE);
2195 }
2196 if (!(zephir_array_isset_string(params, SS("src")))) {
2197 if (zephir_array_isset_long(params, 0)) {
2198 zephir_array_fetch_long(&_4$$10, params, 0, PH_NOISY | PH_READONLY, "phalcon/tag.zep", 1389 TSRMLS_CC);
2199 zephir_array_update_string(¶ms, SL("src"), &_4$$10, PH_COPY | PH_SEPARATE);
2200 } else {
2201 ZEPHIR_INIT_VAR(_5$$11);
2202 ZVAL_STRING(_5$$11, "", 1);
2203 zephir_array_update_string(¶ms, SL("src"), &_5$$11, PH_COPY | PH_SEPARATE);
2204 }
2205 }
2206 if (local == 1) {
2207 ZEPHIR_CALL_SELF(&_6$$12, "geturlservice", NULL, 0);
2208 zephir_check_call_status();
2209 zephir_array_fetch_string(&_8$$12, params, SL("src"), PH_NOISY | PH_READONLY, "phalcon/tag.zep", 1399 TSRMLS_CC);
2210 ZEPHIR_CALL_METHOD(&_7$$12, _6$$12, "getstatic", NULL, 0, _8$$12);
2211 zephir_check_call_status();
2212 zephir_array_update_string(¶ms, SL("src"), &_7$$12, PH_COPY | PH_SEPARATE);
2213 }
2214 ZEPHIR_INIT_VAR(_9);
2215 ZVAL_STRING(_9, "<script", ZEPHIR_TEMP_PARAM_COPY);
2216 ZEPHIR_CALL_SELF(&code, "renderattributes", NULL, 0, _9, params);
2217 zephir_check_temp_parameter(_9);
2218 zephir_check_call_status();
2219 ZEPHIR_INIT_NVAR(_9);
2220 ZEPHIR_GET_CONSTANT(_9, "PHP_EOL");
2221 ZEPHIR_INIT_VAR(_10);
2222 ZEPHIR_CONCAT_SV(_10, "></script>", _9);
2223 zephir_concat_self(&code, _10 TSRMLS_CC);
2224 RETURN_CCTOR(code);
2225
2226 }
2227
2228 /**
2229 * Builds HTML IMG tags
2230 *
2231 * <code>
2232 * echo Phalcon\Tag::image("img/bg.png");
2233 *
2234 * echo Phalcon\Tag::image(
2235 * [
2236 * "img/photo.jpg",
2237 * "alt" => "Some Photo",
2238 * ]
2239 * );
2240 * </code>
2241 *
2242 * Volt Syntax:
2243 * <code>
2244 * {{ image("img/bg.png") }}
2245 * {{ image("img/photo.jpg", "alt": "Some Photo") }}
2246 * {{ image("http://static.mywebsite.com/img/bg.png", false) }}
2247 * </code>
2248 *
2249 * @param array parameters
2250 * @param boolean local
2251 * @return string
2252 */
PHP_METHOD(Phalcon_Tag,image)2253 PHP_METHOD(Phalcon_Tag, image) {
2254
2255 zend_long ZEPHIR_LAST_CALL_STATUS;
2256 zend_bool local;
2257 zval *parameters = NULL, *local_param = NULL, *params = NULL, *code = NULL, *src = NULL, *_5, *_6, *_0$$5, *_1$$8, *_2$$9 = NULL, *_3$$9 = NULL, *_4$$9;
2258
2259 ZEPHIR_MM_GROW();
2260 zephir_fetch_params(1, 0, 2, ¶meters, &local_param);
2261
2262 if (!parameters) {
2263 parameters = ZEPHIR_GLOBAL(global_null);
2264 }
2265 if (!local_param) {
2266 local = 1;
2267 } else {
2268 local = zephir_get_boolval(local_param);
2269 }
2270
2271
2272 if (Z_TYPE_P(parameters) != IS_ARRAY) {
2273 ZEPHIR_INIT_VAR(params);
2274 zephir_create_array(params, 1, 0 TSRMLS_CC);
2275 zephir_array_fast_append(params, parameters);
2276 } else {
2277 ZEPHIR_CPY_WRT(params, parameters);
2278 if (zephir_array_isset_long(params, 1)) {
2279 ZEPHIR_OBS_VAR(_0$$5);
2280 zephir_array_fetch_long(&_0$$5, params, 1, PH_NOISY, "phalcon/tag.zep", 1442 TSRMLS_CC);
2281 local = zephir_get_boolval(_0$$5);
2282 }
2283 }
2284 if (!(zephir_array_isset_string(params, SS("src")))) {
2285 ZEPHIR_OBS_VAR(src);
2286 if (zephir_array_isset_long_fetch(&src, params, 0, 0 TSRMLS_CC)) {
2287 zephir_array_update_string(¶ms, SL("src"), &src, PH_COPY | PH_SEPARATE);
2288 } else {
2289 ZEPHIR_INIT_VAR(_1$$8);
2290 ZVAL_STRING(_1$$8, "", 1);
2291 zephir_array_update_string(¶ms, SL("src"), &_1$$8, PH_COPY | PH_SEPARATE);
2292 }
2293 }
2294 if (local) {
2295 ZEPHIR_CALL_SELF(&_2$$9, "geturlservice", NULL, 0);
2296 zephir_check_call_status();
2297 zephir_array_fetch_string(&_4$$9, params, SL("src"), PH_NOISY | PH_READONLY, "phalcon/tag.zep", 1458 TSRMLS_CC);
2298 ZEPHIR_CALL_METHOD(&_3$$9, _2$$9, "getstatic", NULL, 0, _4$$9);
2299 zephir_check_call_status();
2300 zephir_array_update_string(¶ms, SL("src"), &_3$$9, PH_COPY | PH_SEPARATE);
2301 }
2302 ZEPHIR_INIT_VAR(_5);
2303 ZVAL_STRING(_5, "<img", ZEPHIR_TEMP_PARAM_COPY);
2304 ZEPHIR_CALL_SELF(&code, "renderattributes", NULL, 0, _5, params);
2305 zephir_check_temp_parameter(_5);
2306 zephir_check_call_status();
2307 _6 = zephir_fetch_static_property_ce(phalcon_tag_ce, SL("_documentType") TSRMLS_CC);
2308 if (ZEPHIR_GT_LONG(_6, 5)) {
2309 zephir_concat_self_str(&code, SL(" />") TSRMLS_CC);
2310 } else {
2311 zephir_concat_self_str(&code, SL(">") TSRMLS_CC);
2312 }
2313 RETURN_CCTOR(code);
2314
2315 }
2316
2317 /**
2318 * Converts texts into URL-friendly titles
2319 *
2320 *<code>
2321 * echo Phalcon\Tag::friendlyTitle("These are big important news", "-")
2322 *</code>
2323 */
PHP_METHOD(Phalcon_Tag,friendlyTitle)2324 PHP_METHOD(Phalcon_Tag, friendlyTitle) {
2325
2326 HashTable *_7$$6;
2327 HashPosition _6$$6;
2328 zend_long ZEPHIR_LAST_CALL_STATUS;
2329 zend_bool lowercase, _5$$4;
2330 zval *text_param = NULL, *separator_param = NULL, *lowercase_param = NULL, *replace = NULL, *friendly = NULL, *locale = NULL, *search = NULL, _0 = zval_used_for_init, *_1 = NULL, *_13 = NULL, *_14, *_16 = NULL, _2$$3 = zval_used_for_init, _3$$3 = zval_used_for_init, *_4$$3 = NULL, **_8$$6, *_9$$7 = NULL, _10$$7 = zval_used_for_init, *_11$$8, _12$$8, *_15$$9, _17$$10;
2331 zval *text = NULL, *separator = NULL;
2332
2333 ZEPHIR_MM_GROW();
2334 zephir_fetch_params(1, 1, 3, &text_param, &separator_param, &lowercase_param, &replace);
2335
2336 zephir_get_strval(text, text_param);
2337 if (!separator_param) {
2338 ZEPHIR_INIT_VAR(separator);
2339 ZVAL_STRING(separator, "-", 1);
2340 } else {
2341 zephir_get_strval(separator, separator_param);
2342 }
2343 if (!lowercase_param) {
2344 lowercase = 1;
2345 } else {
2346 lowercase = zephir_get_boolval(lowercase_param);
2347 }
2348 if (!replace) {
2349 replace = ZEPHIR_GLOBAL(global_null);
2350 }
2351
2352
2353 ZEPHIR_SINIT_VAR(_0);
2354 ZVAL_STRING(&_0, "iconv", 0);
2355 ZEPHIR_CALL_FUNCTION(&_1, "extension_loaded", NULL, 149, &_0);
2356 zephir_check_call_status();
2357 if (zephir_is_true(_1)) {
2358 ZEPHIR_SINIT_VAR(_2$$3);
2359 ZVAL_LONG(&_2$$3, 6);
2360 ZEPHIR_SINIT_VAR(_3$$3);
2361 ZVAL_STRING(&_3$$3, "en_US.UTF-8", 0);
2362 ZEPHIR_CALL_FUNCTION(&locale, "setlocale", NULL, 456, &_2$$3, &_3$$3);
2363 zephir_check_call_status();
2364 ZEPHIR_SINIT_NVAR(_2$$3);
2365 ZVAL_STRING(&_2$$3, "UTF-8", 0);
2366 ZEPHIR_SINIT_NVAR(_3$$3);
2367 ZVAL_STRING(&_3$$3, "ASCII//TRANSLIT", 0);
2368 ZEPHIR_CALL_FUNCTION(&_4$$3, "iconv", NULL, 410, &_2$$3, &_3$$3, text);
2369 zephir_check_call_status();
2370 zephir_get_strval(text, _4$$3);
2371 }
2372 if (zephir_is_true(replace)) {
2373 _5$$4 = Z_TYPE_P(replace) != IS_ARRAY;
2374 if (_5$$4) {
2375 _5$$4 = Z_TYPE_P(replace) != IS_STRING;
2376 }
2377 if (_5$$4) {
2378 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_tag_exception_ce, "Parameter replace must be an array or a string", "phalcon/tag.zep", 1497);
2379 return;
2380 }
2381 if (Z_TYPE_P(replace) == IS_ARRAY) {
2382 zephir_is_iterable(replace, &_7$$6, &_6$$6, 0, 0, "phalcon/tag.zep", 1503);
2383 for (
2384 ; zend_hash_get_current_data_ex(_7$$6, (void**) &_8$$6, &_6$$6) == SUCCESS
2385 ; zend_hash_move_forward_ex(_7$$6, &_6$$6)
2386 ) {
2387 ZEPHIR_GET_HVALUE(search, _8$$6);
2388 ZEPHIR_INIT_NVAR(_9$$7);
2389 ZEPHIR_SINIT_NVAR(_10$$7);
2390 ZVAL_STRING(&_10$$7, " ", 0);
2391 zephir_fast_str_replace(&_9$$7, search, &_10$$7, text TSRMLS_CC);
2392 zephir_get_strval(text, _9$$7);
2393 }
2394 } else {
2395 ZEPHIR_INIT_VAR(_11$$8);
2396 ZEPHIR_SINIT_VAR(_12$$8);
2397 ZVAL_STRING(&_12$$8, " ", 0);
2398 zephir_fast_str_replace(&_11$$8, replace, &_12$$8, text TSRMLS_CC);
2399 zephir_get_strval(text, _11$$8);
2400 }
2401 }
2402 ZEPHIR_INIT_VAR(_13);
2403 ZVAL_STRING(_13, "/[^a-zA-Z0-9\\/_|+ -]/", ZEPHIR_TEMP_PARAM_COPY);
2404 ZEPHIR_INIT_VAR(_14);
2405 ZVAL_STRING(_14, "", ZEPHIR_TEMP_PARAM_COPY);
2406 ZEPHIR_CALL_FUNCTION(&friendly, "preg_replace", NULL, 42, _13, _14, text);
2407 zephir_check_temp_parameter(_13);
2408 zephir_check_temp_parameter(_14);
2409 zephir_check_call_status();
2410 if (lowercase) {
2411 ZEPHIR_INIT_VAR(_15$$9);
2412 zephir_fast_strtolower(_15$$9, friendly);
2413 ZEPHIR_CPY_WRT(friendly, _15$$9);
2414 }
2415 ZEPHIR_INIT_NVAR(_13);
2416 ZVAL_STRING(_13, "/[\\/_|+ -]+/", ZEPHIR_TEMP_PARAM_COPY);
2417 ZEPHIR_CALL_FUNCTION(&_16, "preg_replace", NULL, 42, _13, separator, friendly);
2418 zephir_check_temp_parameter(_13);
2419 zephir_check_call_status();
2420 ZEPHIR_CPY_WRT(friendly, _16);
2421 ZEPHIR_INIT_NVAR(_13);
2422 zephir_fast_trim(_13, friendly, separator, ZEPHIR_TRIM_BOTH TSRMLS_CC);
2423 ZEPHIR_CPY_WRT(friendly, _13);
2424 ZEPHIR_SINIT_NVAR(_0);
2425 ZVAL_STRING(&_0, "iconv", 0);
2426 ZEPHIR_CALL_FUNCTION(&_16, "extension_loaded", NULL, 149, &_0);
2427 zephir_check_call_status();
2428 if (zephir_is_true(_16)) {
2429 ZEPHIR_SINIT_VAR(_17$$10);
2430 ZVAL_LONG(&_17$$10, 6);
2431 ZEPHIR_CALL_FUNCTION(NULL, "setlocale", NULL, 456, &_17$$10, locale);
2432 zephir_check_call_status();
2433 }
2434 RETURN_CCTOR(friendly);
2435
2436 }
2437
2438 /**
2439 * Set the document type of content
2440 */
PHP_METHOD(Phalcon_Tag,setDocType)2441 PHP_METHOD(Phalcon_Tag, setDocType) {
2442
2443 zend_bool _0;
2444 zval *doctype_param = NULL, *_1$$3, *_2$$4;
2445 zend_long doctype;
2446
2447 zephir_fetch_params(0, 1, 0, &doctype_param);
2448
2449 doctype = zephir_get_intval(doctype_param);
2450
2451
2452 _0 = doctype < 1;
2453 if (!(_0)) {
2454 _0 = doctype > 11;
2455 }
2456 if (_0) {
2457 ZEPHIR_INIT_ZVAL_NREF(_1$$3);
2458 ZVAL_LONG(_1$$3, 5);
2459 zephir_update_static_property_ce(phalcon_tag_ce, SL("_documentType"), &_1$$3 TSRMLS_CC);
2460 } else {
2461 ZEPHIR_INIT_ZVAL_NREF(_2$$4);
2462 ZVAL_LONG(_2$$4, doctype);
2463 zephir_update_static_property_ce(phalcon_tag_ce, SL("_documentType"), &_2$$4 TSRMLS_CC);
2464 }
2465
2466 }
2467
2468 /**
2469 * Get the document type declaration of content
2470 */
PHP_METHOD(Phalcon_Tag,getDocType)2471 PHP_METHOD(Phalcon_Tag, getDocType) {
2472
2473 zval *_0, *_1$$3, *_2$$4, *_3$$4, *_4$$5, *_5$$5, *_6$$6, *_7$$6, *_8$$7, *_9$$7, *_10$$8, *_11$$8, *_12$$9, *_13$$9, *_14$$10, *_15$$10, *_16$$11, *_17$$11, *_18$$12;
2474
2475 ZEPHIR_MM_GROW();
2476
2477 _0 = zephir_fetch_static_property_ce(phalcon_tag_ce, SL("_documentType") TSRMLS_CC);
2478 do {
2479 if (ZEPHIR_IS_LONG(_0, 1)) {
2480 ZEPHIR_INIT_VAR(_1$$3);
2481 ZEPHIR_GET_CONSTANT(_1$$3, "PHP_EOL");
2482 ZEPHIR_CONCAT_SV(return_value, "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">", _1$$3);
2483 RETURN_MM();
2484 }
2485 if (ZEPHIR_IS_LONG(_0, 2)) {
2486 ZEPHIR_INIT_VAR(_2$$4);
2487 ZEPHIR_GET_CONSTANT(_2$$4, "PHP_EOL");
2488 ZEPHIR_INIT_VAR(_3$$4);
2489 ZEPHIR_GET_CONSTANT(_3$$4, "PHP_EOL");
2490 ZEPHIR_CONCAT_SVSV(return_value, "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"", _2$$4, "\t\"http://www.w3.org/TR/html4/strict.dtd\">", _3$$4);
2491 RETURN_MM();
2492 }
2493 if (ZEPHIR_IS_LONG(_0, 3)) {
2494 ZEPHIR_INIT_VAR(_4$$5);
2495 ZEPHIR_GET_CONSTANT(_4$$5, "PHP_EOL");
2496 ZEPHIR_INIT_VAR(_5$$5);
2497 ZEPHIR_GET_CONSTANT(_5$$5, "PHP_EOL");
2498 ZEPHIR_CONCAT_SVSV(return_value, "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\"", _4$$5, "\t\"http://www.w3.org/TR/html4/loose.dtd\">", _5$$5);
2499 RETURN_MM();
2500 }
2501 if (ZEPHIR_IS_LONG(_0, 4)) {
2502 ZEPHIR_INIT_VAR(_6$$6);
2503 ZEPHIR_GET_CONSTANT(_6$$6, "PHP_EOL");
2504 ZEPHIR_INIT_VAR(_7$$6);
2505 ZEPHIR_GET_CONSTANT(_7$$6, "PHP_EOL");
2506 ZEPHIR_CONCAT_SVSV(return_value, "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Frameset//EN\"", _6$$6, "\t\"http://www.w3.org/TR/html4/frameset.dtd\">", _7$$6);
2507 RETURN_MM();
2508 }
2509 if (ZEPHIR_IS_LONG(_0, 6)) {
2510 ZEPHIR_INIT_VAR(_8$$7);
2511 ZEPHIR_GET_CONSTANT(_8$$7, "PHP_EOL");
2512 ZEPHIR_INIT_VAR(_9$$7);
2513 ZEPHIR_GET_CONSTANT(_9$$7, "PHP_EOL");
2514 ZEPHIR_CONCAT_SVSV(return_value, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"", _8$$7, "\t\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">", _9$$7);
2515 RETURN_MM();
2516 }
2517 if (ZEPHIR_IS_LONG(_0, 7)) {
2518 ZEPHIR_INIT_VAR(_10$$8);
2519 ZEPHIR_GET_CONSTANT(_10$$8, "PHP_EOL");
2520 ZEPHIR_INIT_VAR(_11$$8);
2521 ZEPHIR_GET_CONSTANT(_11$$8, "PHP_EOL");
2522 ZEPHIR_CONCAT_SVSV(return_value, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"", _10$$8, "\t\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">", _11$$8);
2523 RETURN_MM();
2524 }
2525 if (ZEPHIR_IS_LONG(_0, 8)) {
2526 ZEPHIR_INIT_VAR(_12$$9);
2527 ZEPHIR_GET_CONSTANT(_12$$9, "PHP_EOL");
2528 ZEPHIR_INIT_VAR(_13$$9);
2529 ZEPHIR_GET_CONSTANT(_13$$9, "PHP_EOL");
2530 ZEPHIR_CONCAT_SVSV(return_value, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Frameset//EN\"", _12$$9, "\t\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd\">", _13$$9);
2531 RETURN_MM();
2532 }
2533 if (ZEPHIR_IS_LONG(_0, 9)) {
2534 ZEPHIR_INIT_VAR(_14$$10);
2535 ZEPHIR_GET_CONSTANT(_14$$10, "PHP_EOL");
2536 ZEPHIR_INIT_VAR(_15$$10);
2537 ZEPHIR_GET_CONSTANT(_15$$10, "PHP_EOL");
2538 ZEPHIR_CONCAT_SVSV(return_value, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\"", _14$$10, "\t\"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\">", _15$$10);
2539 RETURN_MM();
2540 }
2541 if (ZEPHIR_IS_LONG(_0, 10)) {
2542 ZEPHIR_INIT_VAR(_16$$11);
2543 ZEPHIR_GET_CONSTANT(_16$$11, "PHP_EOL");
2544 ZEPHIR_INIT_VAR(_17$$11);
2545 ZEPHIR_GET_CONSTANT(_17$$11, "PHP_EOL");
2546 ZEPHIR_CONCAT_SVSV(return_value, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 2.0//EN\"", _16$$11, "\t\"http://www.w3.org/MarkUp/DTD/xhtml2.dtd\">", _17$$11);
2547 RETURN_MM();
2548 }
2549 if (ZEPHIR_IS_LONG(_0, 5) || ZEPHIR_IS_LONG(_0, 11)) {
2550 ZEPHIR_INIT_VAR(_18$$12);
2551 ZEPHIR_GET_CONSTANT(_18$$12, "PHP_EOL");
2552 ZEPHIR_CONCAT_SV(return_value, "<!DOCTYPE html>", _18$$12);
2553 RETURN_MM();
2554 }
2555 } while(0);
2556
2557 RETURN_MM_STRING("", 1);
2558
2559 }
2560
2561 /**
2562 * Builds a HTML tag
2563 */
PHP_METHOD(Phalcon_Tag,tagHtml)2564 PHP_METHOD(Phalcon_Tag, tagHtml) {
2565
2566 zend_long ZEPHIR_LAST_CALL_STATUS;
2567 zend_bool selfClose, onlyStart, useEol;
2568 zval *tagName_param = NULL, *parameters = NULL, *selfClose_param = NULL, *onlyStart_param = NULL, *useEol_param = NULL, *params = NULL, *localCode = NULL, *_1, *_3$$11;
2569 zval *tagName = NULL, *_0, *_2$$10;
2570
2571 ZEPHIR_MM_GROW();
2572 zephir_fetch_params(1, 1, 4, &tagName_param, ¶meters, &selfClose_param, &onlyStart_param, &useEol_param);
2573
2574 zephir_get_strval(tagName, tagName_param);
2575 if (!parameters) {
2576 parameters = ZEPHIR_GLOBAL(global_null);
2577 }
2578 if (!selfClose_param) {
2579 selfClose = 0;
2580 } else {
2581 selfClose = zephir_get_boolval(selfClose_param);
2582 }
2583 if (!onlyStart_param) {
2584 onlyStart = 0;
2585 } else {
2586 onlyStart = zephir_get_boolval(onlyStart_param);
2587 }
2588 if (!useEol_param) {
2589 useEol = 0;
2590 } else {
2591 useEol = zephir_get_boolval(useEol_param);
2592 }
2593
2594
2595 if (Z_TYPE_P(parameters) != IS_ARRAY) {
2596 ZEPHIR_INIT_VAR(params);
2597 zephir_create_array(params, 1, 0 TSRMLS_CC);
2598 zephir_array_fast_append(params, parameters);
2599 } else {
2600 ZEPHIR_CPY_WRT(params, parameters);
2601 }
2602 ZEPHIR_INIT_VAR(_0);
2603 ZEPHIR_CONCAT_SV(_0, "<", tagName);
2604 ZEPHIR_CALL_SELF(&localCode, "renderattributes", NULL, 0, _0, params);
2605 zephir_check_call_status();
2606 _1 = zephir_fetch_static_property_ce(phalcon_tag_ce, SL("_documentType") TSRMLS_CC);
2607 if (ZEPHIR_GT_LONG(_1, 5)) {
2608 if (selfClose) {
2609 zephir_concat_self_str(&localCode, SL(" />") TSRMLS_CC);
2610 } else {
2611 zephir_concat_self_str(&localCode, SL(">") TSRMLS_CC);
2612 }
2613 } else {
2614 if (onlyStart) {
2615 zephir_concat_self_str(&localCode, SL(">") TSRMLS_CC);
2616 } else {
2617 ZEPHIR_INIT_VAR(_2$$10);
2618 ZEPHIR_CONCAT_SVS(_2$$10, "></", tagName, ">");
2619 zephir_concat_self(&localCode, _2$$10 TSRMLS_CC);
2620 }
2621 }
2622 if (useEol) {
2623 ZEPHIR_INIT_VAR(_3$$11);
2624 ZEPHIR_GET_CONSTANT(_3$$11, "PHP_EOL");
2625 zephir_concat_self(&localCode, _3$$11 TSRMLS_CC);
2626 }
2627 RETURN_CCTOR(localCode);
2628
2629 }
2630
2631 /**
2632 * Builds a HTML tag closing tag
2633 *
2634 *<code>
2635 * echo Phalcon\Tag::tagHtmlClose("script", true);
2636 *</code>
2637 */
PHP_METHOD(Phalcon_Tag,tagHtmlClose)2638 PHP_METHOD(Phalcon_Tag, tagHtmlClose) {
2639
2640 zend_bool useEol;
2641 zval *tagName_param = NULL, *useEol_param = NULL, *_0$$3;
2642 zval *tagName = NULL;
2643
2644 ZEPHIR_MM_GROW();
2645 zephir_fetch_params(1, 1, 1, &tagName_param, &useEol_param);
2646
2647 zephir_get_strval(tagName, tagName_param);
2648 if (!useEol_param) {
2649 useEol = 0;
2650 } else {
2651 useEol = zephir_get_boolval(useEol_param);
2652 }
2653
2654
2655 if (useEol) {
2656 ZEPHIR_INIT_VAR(_0$$3);
2657 ZEPHIR_GET_CONSTANT(_0$$3, "PHP_EOL");
2658 ZEPHIR_CONCAT_SVSV(return_value, "</", tagName, ">", _0$$3);
2659 RETURN_MM();
2660 }
2661 ZEPHIR_CONCAT_SVS(return_value, "</", tagName, ">");
2662 RETURN_MM();
2663
2664 }
2665
2666
