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/object.h"
16 #include "kernel/operators.h"
17 #include "kernel/memory.h"
18 #include "kernel/fcall.h"
19 #include "ext/spl/spl_exceptions.h"
20 #include "kernel/exception.h"
21 #include "kernel/array.h"
22 #include "kernel/concat.h"
23 #include "kernel/string.h"
24
25
26 /**
27 * This file is part of the Phalcon Framework.
28 *
29 * (c) Phalcon Team <team@phalcon.io>
30 *
31 * For the full copyright and license information, please view the LICENSE.txt
32 * file that was distributed with this source code.
33 */
34 /**
35 * Phalcon\Tag is designed to simplify building of HTML tags.
36 * It provides a set of helpers to generate HTML in a dynamic way.
37 * This component is a class that you can extend to add more helpers.
38 */
ZEPHIR_INIT_CLASS(Phalcon_Tag)39 ZEPHIR_INIT_CLASS(Phalcon_Tag) {
40
41 ZEPHIR_REGISTER_CLASS(Phalcon, Tag, phalcon, tag, phalcon_tag_method_entry, 0);
42
43 zend_declare_property_bool(phalcon_tag_ce, SL("autoEscape"), 1, ZEND_ACC_PROTECTED|ZEND_ACC_STATIC);
44
45 /**
46 * DI Container
47 */
48 zend_declare_property_null(phalcon_tag_ce, SL("container"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC);
49
50 /**
51 * Pre-assigned values for components
52 */
53 zend_declare_property_null(phalcon_tag_ce, SL("displayValues"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC);
54
55 zend_declare_property_null(phalcon_tag_ce, SL("documentAppendTitle"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC);
56
57 zend_declare_property_null(phalcon_tag_ce, SL("documentPrependTitle"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC);
58
59 /**
60 * HTML document title
61 */
62 zend_declare_property_null(phalcon_tag_ce, SL("documentTitle"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC);
63
64 zend_declare_property_null(phalcon_tag_ce, SL("documentTitleSeparator"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC);
65
66 zend_declare_property_long(phalcon_tag_ce, SL("documentType"), 11, ZEND_ACC_PROTECTED|ZEND_ACC_STATIC);
67
68 zend_declare_property_null(phalcon_tag_ce, SL("escaperService"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC);
69
70 zend_declare_property_null(phalcon_tag_ce, SL("urlService"), ZEND_ACC_PROTECTED|ZEND_ACC_STATIC);
71
72 zephir_declare_class_constant_long(phalcon_tag_ce, SL("HTML32"), 1);
73
74 zephir_declare_class_constant_long(phalcon_tag_ce, SL("HTML401_STRICT"), 2);
75
76 zephir_declare_class_constant_long(phalcon_tag_ce, SL("HTML401_TRANSITIONAL"), 3);
77
78 zephir_declare_class_constant_long(phalcon_tag_ce, SL("HTML401_FRAMESET"), 4);
79
80 zephir_declare_class_constant_long(phalcon_tag_ce, SL("HTML5"), 5);
81
82 zephir_declare_class_constant_long(phalcon_tag_ce, SL("XHTML10_STRICT"), 6);
83
84 zephir_declare_class_constant_long(phalcon_tag_ce, SL("XHTML10_TRANSITIONAL"), 7);
85
86 zephir_declare_class_constant_long(phalcon_tag_ce, SL("XHTML10_FRAMESET"), 8);
87
88 zephir_declare_class_constant_long(phalcon_tag_ce, SL("XHTML11"), 9);
89
90 zephir_declare_class_constant_long(phalcon_tag_ce, SL("XHTML20"), 10);
91
92 zephir_declare_class_constant_long(phalcon_tag_ce, SL("XHTML5"), 11);
93
94 return SUCCESS;
95
96 }
97
98 /**
99 * Appends a text to current document title
100 */
PHP_METHOD(Phalcon_Tag,appendTitle)101 PHP_METHOD(Phalcon_Tag, appendTitle) {
102
103 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
104 zval *title, title_sub, _0, _1$$3;
105 zval *this_ptr = getThis();
106
107 ZVAL_UNDEF(&title_sub);
108 ZVAL_UNDEF(&_0);
109 ZVAL_UNDEF(&_1$$3);
110
111 ZEPHIR_MM_GROW();
112 zephir_fetch_params(1, 1, 0, &title);
113
114
115
116 zephir_read_static_property_ce(&_0, phalcon_tag_ce, SL("documentAppendTitle"), PH_NOISY_CC | PH_READONLY);
117 if (Z_TYPE_P(&_0) == IS_NULL) {
118 ZEPHIR_INIT_VAR(&_1$$3);
119 array_init(&_1$$3);
120 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("documentAppendTitle"), &_1$$3);
121 }
122 if (Z_TYPE_P(title) == IS_ARRAY) {
123 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("documentAppendTitle"), title);
124 } else {
125 zephir_update_static_property_array_multi_ce(phalcon_tag_ce, SL("documentAppendTitle"), title, SL("a"), 1);
126 }
127 ZEPHIR_MM_RESTORE();
128
129 }
130
131 /**
132 * Builds a HTML input[type="check"] tag
133 *
134 * @param array parameters = [
135 * 'class' => '',
136 * 'id' => '',
137 * 'name' => ''
138 * 'value' => ''
139 * ]
140 */
PHP_METHOD(Phalcon_Tag,checkField)141 PHP_METHOD(Phalcon_Tag, checkField) {
142
143 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
144 zend_long ZEPHIR_LAST_CALL_STATUS;
145 zephir_fcall_cache_entry *_0 = NULL;
146 zval *parameters, parameters_sub, _1;
147 zval *this_ptr = getThis();
148
149 ZVAL_UNDEF(¶meters_sub);
150 ZVAL_UNDEF(&_1);
151
152 ZEPHIR_MM_GROW();
153 zephir_fetch_params(1, 1, 0, ¶meters);
154
155
156
157 ZEPHIR_INIT_VAR(&_1);
158 ZVAL_STRING(&_1, "checkbox");
159 ZEPHIR_RETURN_CALL_SELF("inputfieldchecked", &_0, 0, &_1, parameters);
160 zephir_check_call_status();
161 RETURN_MM();
162
163 }
164
165 /**
166 * Builds a HTML input[type="color"] tag
167 *
168 * @param array parameters = [
169 * 'class' => '',
170 * 'id' => '',
171 * 'name' => ''
172 * 'value' => ''
173 * ]
174 */
PHP_METHOD(Phalcon_Tag,colorField)175 PHP_METHOD(Phalcon_Tag, colorField) {
176
177 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
178 zend_long ZEPHIR_LAST_CALL_STATUS;
179 zephir_fcall_cache_entry *_0 = NULL;
180 zval *parameters, parameters_sub, _1;
181 zval *this_ptr = getThis();
182
183 ZVAL_UNDEF(¶meters_sub);
184 ZVAL_UNDEF(&_1);
185
186 ZEPHIR_MM_GROW();
187 zephir_fetch_params(1, 1, 0, ¶meters);
188
189
190
191 ZEPHIR_INIT_VAR(&_1);
192 ZVAL_STRING(&_1, "color");
193 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters);
194 zephir_check_call_status();
195 RETURN_MM();
196
197 }
198
199 /**
200 * Builds a HTML input[type="date"] tag
201 *
202 * @param array parameters = [
203 * 'class' => '',
204 * 'id' => '',
205 * 'name' => ''
206 * 'value' => ''
207 * ]
208 */
PHP_METHOD(Phalcon_Tag,dateField)209 PHP_METHOD(Phalcon_Tag, dateField) {
210
211 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
212 zend_long ZEPHIR_LAST_CALL_STATUS;
213 zephir_fcall_cache_entry *_0 = NULL;
214 zval *parameters, parameters_sub, _1;
215 zval *this_ptr = getThis();
216
217 ZVAL_UNDEF(¶meters_sub);
218 ZVAL_UNDEF(&_1);
219
220 ZEPHIR_MM_GROW();
221 zephir_fetch_params(1, 1, 0, ¶meters);
222
223
224
225 ZEPHIR_INIT_VAR(&_1);
226 ZVAL_STRING(&_1, "date");
227 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters);
228 zephir_check_call_status();
229 RETURN_MM();
230
231 }
232
233 /**
234 * Builds a HTML input[type="datetime"] tag
235 *
236 * @param array parameters = [
237 * 'class' => '',
238 * 'id' => '',
239 * 'name' => ''
240 * 'value' => ''
241 * ]
242 */
PHP_METHOD(Phalcon_Tag,dateTimeField)243 PHP_METHOD(Phalcon_Tag, dateTimeField) {
244
245 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
246 zend_long ZEPHIR_LAST_CALL_STATUS;
247 zephir_fcall_cache_entry *_0 = NULL;
248 zval *parameters, parameters_sub, _1;
249 zval *this_ptr = getThis();
250
251 ZVAL_UNDEF(¶meters_sub);
252 ZVAL_UNDEF(&_1);
253
254 ZEPHIR_MM_GROW();
255 zephir_fetch_params(1, 1, 0, ¶meters);
256
257
258
259 ZEPHIR_INIT_VAR(&_1);
260 ZVAL_STRING(&_1, "datetime");
261 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters);
262 zephir_check_call_status();
263 RETURN_MM();
264
265 }
266
267 /**
268 * Builds a HTML input[type="datetime-local"] tag
269 *
270 * @param array parameters = [
271 * 'class' => '',
272 * 'id' => '',
273 * 'name' => ''
274 * 'value' => ''
275 * ]
276 */
PHP_METHOD(Phalcon_Tag,dateTimeLocalField)277 PHP_METHOD(Phalcon_Tag, dateTimeLocalField) {
278
279 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
280 zend_long ZEPHIR_LAST_CALL_STATUS;
281 zephir_fcall_cache_entry *_0 = NULL;
282 zval *parameters, parameters_sub, _1;
283 zval *this_ptr = getThis();
284
285 ZVAL_UNDEF(¶meters_sub);
286 ZVAL_UNDEF(&_1);
287
288 ZEPHIR_MM_GROW();
289 zephir_fetch_params(1, 1, 0, ¶meters);
290
291
292
293 ZEPHIR_INIT_VAR(&_1);
294 ZVAL_STRING(&_1, "datetime-local");
295 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters);
296 zephir_check_call_status();
297 RETURN_MM();
298
299 }
300
301 /**
302 * Alias of Phalcon\Tag::setDefault()
303 */
PHP_METHOD(Phalcon_Tag,displayTo)304 PHP_METHOD(Phalcon_Tag, displayTo) {
305
306 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
307 zend_long ZEPHIR_LAST_CALL_STATUS;
308 zval *id_param = NULL, *value, value_sub;
309 zval id;
310 zval *this_ptr = getThis();
311
312 ZVAL_UNDEF(&id);
313 ZVAL_UNDEF(&value_sub);
314
315 ZEPHIR_MM_GROW();
316 zephir_fetch_params(1, 2, 0, &id_param, &value);
317
318 if (UNEXPECTED(Z_TYPE_P(id_param) != IS_STRING && Z_TYPE_P(id_param) != IS_NULL)) {
319 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'id' must be of the type string"));
320 RETURN_MM_NULL();
321 }
322 if (EXPECTED(Z_TYPE_P(id_param) == IS_STRING)) {
323 zephir_get_strval(&id, id_param);
324 } else {
325 ZEPHIR_INIT_VAR(&id);
326 ZVAL_EMPTY_STRING(&id);
327 }
328
329
330 ZEPHIR_CALL_SELF(NULL, "setdefault", NULL, 0, &id, value);
331 zephir_check_call_status();
332 ZEPHIR_MM_RESTORE();
333
334 }
335
336 /**
337 * Builds a HTML input[type="email"] tag
338 *
339 * @param array parameters = [
340 * 'class' => '',
341 * 'id' => '',
342 * 'name' => ''
343 * 'value' => ''
344 * ]
345 */
PHP_METHOD(Phalcon_Tag,emailField)346 PHP_METHOD(Phalcon_Tag, emailField) {
347
348 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
349 zend_long ZEPHIR_LAST_CALL_STATUS;
350 zephir_fcall_cache_entry *_0 = NULL;
351 zval *parameters, parameters_sub, _1;
352 zval *this_ptr = getThis();
353
354 ZVAL_UNDEF(¶meters_sub);
355 ZVAL_UNDEF(&_1);
356
357 ZEPHIR_MM_GROW();
358 zephir_fetch_params(1, 1, 0, ¶meters);
359
360
361
362 ZEPHIR_INIT_VAR(&_1);
363 ZVAL_STRING(&_1, "email");
364 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters);
365 zephir_check_call_status();
366 RETURN_MM();
367
368 }
369
370 /**
371 * Builds a HTML close FORM tag
372 */
PHP_METHOD(Phalcon_Tag,endForm)373 PHP_METHOD(Phalcon_Tag, endForm) {
374
375 zval *this_ptr = getThis();
376
377
378 RETURN_STRING("</form>");
379
380 }
381
382 /**
383 * Builds a HTML input[type="file"] tag
384 *
385 * @param array parameters = [
386 * 'class' => '',
387 * 'id' => '',
388 * 'name' => ''
389 * 'value' => ''
390 * ]
391 */
PHP_METHOD(Phalcon_Tag,fileField)392 PHP_METHOD(Phalcon_Tag, fileField) {
393
394 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
395 zend_long ZEPHIR_LAST_CALL_STATUS;
396 zephir_fcall_cache_entry *_0 = NULL;
397 zval *parameters, parameters_sub, _1;
398 zval *this_ptr = getThis();
399
400 ZVAL_UNDEF(¶meters_sub);
401 ZVAL_UNDEF(&_1);
402
403 ZEPHIR_MM_GROW();
404 zephir_fetch_params(1, 1, 0, ¶meters);
405
406
407
408 ZEPHIR_INIT_VAR(&_1);
409 ZVAL_STRING(&_1, "file");
410 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters);
411 zephir_check_call_status();
412 RETURN_MM();
413
414 }
415
416 /**
417 * Builds a HTML FORM tag
418 *
419 * @param array parameters = [
420 * 'method' => 'post',
421 * 'action' => '',
422 * 'parameters' => '',
423 * 'name' => '',
424 * 'class' => '',
425 * 'id' => ''
426 * ]
427 */
PHP_METHOD(Phalcon_Tag,form)428 PHP_METHOD(Phalcon_Tag, form) {
429
430 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
431 zend_long ZEPHIR_LAST_CALL_STATUS;
432 zval *parameters = NULL, parameters_sub, params, paramsAction, action, code, _3, _0$$6, _1$$7, _2$$8;
433 zval *this_ptr = getThis();
434
435 ZVAL_UNDEF(¶meters_sub);
436 ZVAL_UNDEF(¶ms);
437 ZVAL_UNDEF(¶msAction);
438 ZVAL_UNDEF(&action);
439 ZVAL_UNDEF(&code);
440 ZVAL_UNDEF(&_3);
441 ZVAL_UNDEF(&_0$$6);
442 ZVAL_UNDEF(&_1$$7);
443 ZVAL_UNDEF(&_2$$8);
444
445 ZEPHIR_MM_GROW();
446 zephir_fetch_params(1, 1, 0, ¶meters);
447
448 ZEPHIR_SEPARATE_PARAM(parameters);
449
450
451 if (Z_TYPE_P(parameters) != IS_ARRAY) {
452 ZEPHIR_INIT_VAR(¶ms);
453 zephir_create_array(¶ms, 1, 0);
454 zephir_array_fast_append(¶ms, parameters);
455 } else {
456 ZEPHIR_CPY_WRT(¶ms, parameters);
457 }
458 ZEPHIR_OBS_VAR(¶msAction);
459 if (!(zephir_array_isset_long_fetch(¶msAction, ¶ms, 0, 0))) {
460 ZEPHIR_OBS_NVAR(¶msAction);
461 zephir_array_isset_string_fetch(¶msAction, ¶ms, SL("action"), 0);
462 }
463 if (!(zephir_array_isset_string(¶ms, SL("method")))) {
464 ZEPHIR_INIT_VAR(&_0$$6);
465 ZVAL_STRING(&_0$$6, "post");
466 zephir_array_update_string(¶ms, SL("method"), &_0$$6, PH_COPY | PH_SEPARATE);
467 }
468 ZEPHIR_INIT_VAR(&action);
469 ZVAL_NULL(&action);
470 if (!(ZEPHIR_IS_EMPTY(¶msAction))) {
471 ZEPHIR_CALL_SELF(&_1$$7, "geturlservice", NULL, 0);
472 zephir_check_call_status();
473 ZEPHIR_CALL_METHOD(&action, &_1$$7, "get", NULL, 0, ¶msAction);
474 zephir_check_call_status();
475 }
476 ZEPHIR_OBS_NVAR(parameters);
477 if (zephir_array_isset_string_fetch(parameters, ¶ms, SL("parameters"), 0)) {
478 ZEPHIR_INIT_VAR(&_2$$8);
479 ZEPHIR_CONCAT_SV(&_2$$8, "?", parameters);
480 zephir_concat_self(&action, &_2$$8);
481 }
482 if (!(ZEPHIR_IS_EMPTY(&action))) {
483 zephir_array_update_string(¶ms, SL("action"), &action, PH_COPY | PH_SEPARATE);
484 }
485 ZEPHIR_INIT_VAR(&_3);
486 ZVAL_STRING(&_3, "<form");
487 ZEPHIR_CALL_SELF(&code, "renderattributes", NULL, 0, &_3, ¶ms);
488 zephir_check_call_status();
489 zephir_concat_self_str(&code, SL(">"));
490 RETURN_CCTOR(&code);
491
492 }
493
494 /**
495 * Converts texts into URL-friendly titles
496 */
PHP_METHOD(Phalcon_Tag,friendlyTitle)497 PHP_METHOD(Phalcon_Tag, friendlyTitle) {
498
499 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
500 zend_long ZEPHIR_LAST_CALL_STATUS;
501 zephir_fcall_cache_entry *_0 = NULL;
502 zend_bool lowercase;
503 zval *text_param = NULL, *separator_param = NULL, *lowercase_param = NULL, *replace = NULL, replace_sub, __$null, ex, _2, _1$$3, _3$$4, _4$$4;
504 zval text, separator;
505 zval *this_ptr = getThis();
506
507 ZVAL_UNDEF(&text);
508 ZVAL_UNDEF(&separator);
509 ZVAL_UNDEF(&replace_sub);
510 ZVAL_NULL(&__$null);
511 ZVAL_UNDEF(&ex);
512 ZVAL_UNDEF(&_2);
513 ZVAL_UNDEF(&_1$$3);
514 ZVAL_UNDEF(&_3$$4);
515 ZVAL_UNDEF(&_4$$4);
516
517 ZEPHIR_MM_GROW();
518 zephir_fetch_params(1, 1, 3, &text_param, &separator_param, &lowercase_param, &replace);
519
520 zephir_get_strval(&text, text_param);
521 if (!separator_param) {
522 ZEPHIR_INIT_VAR(&separator);
523 ZVAL_STRING(&separator, "-");
524 } else {
525 zephir_get_strval(&separator, separator_param);
526 }
527 if (!lowercase_param) {
528 lowercase = 1;
529 } else {
530 lowercase = zephir_get_boolval(lowercase_param);
531 }
532 if (!replace) {
533 replace = &replace_sub;
534 replace = &__$null;
535 }
536
537
538
539 /* try_start_1: */
540
541 if (lowercase) {
542 ZVAL_BOOL(&_1$$3, 1);
543 } else {
544 ZVAL_BOOL(&_1$$3, 0);
545 }
546 ZEPHIR_RETURN_CALL_CE_STATIC(phalcon_helper_str_ce, "friendly", &_0, 0, &text, &separator, &_1$$3, replace);
547 zephir_check_call_status_or_jump(try_end_1);
548 RETURN_MM();
549
550 try_end_1:
551
552 if (EG(exception)) {
553 ZEPHIR_INIT_VAR(&_2);
554 ZVAL_OBJ(&_2, EG(exception));
555 Z_ADDREF_P(&_2);
556 if (zephir_instance_of_ev(&_2, phalcon_helper_exception_ce)) {
557 zend_clear_exception(TSRMLS_C);
558 ZEPHIR_CPY_WRT(&ex, &_2);
559 ZEPHIR_INIT_VAR(&_3$$4);
560 object_init_ex(&_3$$4, phalcon_tag_exception_ce);
561 ZEPHIR_CALL_METHOD(&_4$$4, &ex, "getmessage", NULL, 0);
562 zephir_check_call_status();
563 ZEPHIR_CALL_METHOD(NULL, &_3$$4, "__construct", NULL, 8, &_4$$4);
564 zephir_check_call_status();
565 zephir_throw_exception_debug(&_3$$4, "phalcon/Tag.zep", 279);
566 ZEPHIR_MM_RESTORE();
567 return;
568 }
569 }
570
571 }
572
573 /**
574 * Get the document type declaration of content
575 */
PHP_METHOD(Phalcon_Tag,getDocType)576 PHP_METHOD(Phalcon_Tag, getDocType) {
577
578 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;
579 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
580 zval *this_ptr = getThis();
581
582 ZVAL_UNDEF(&_0);
583 ZVAL_UNDEF(&_1$$3);
584 ZVAL_UNDEF(&_2$$4);
585 ZVAL_UNDEF(&_3$$4);
586 ZVAL_UNDEF(&_4$$5);
587 ZVAL_UNDEF(&_5$$5);
588 ZVAL_UNDEF(&_6$$6);
589 ZVAL_UNDEF(&_7$$6);
590 ZVAL_UNDEF(&_8$$7);
591 ZVAL_UNDEF(&_9$$7);
592 ZVAL_UNDEF(&_10$$8);
593 ZVAL_UNDEF(&_11$$8);
594 ZVAL_UNDEF(&_12$$9);
595 ZVAL_UNDEF(&_13$$9);
596 ZVAL_UNDEF(&_14$$10);
597 ZVAL_UNDEF(&_15$$10);
598 ZVAL_UNDEF(&_16$$11);
599 ZVAL_UNDEF(&_17$$11);
600 ZVAL_UNDEF(&_18$$12);
601
602 ZEPHIR_MM_GROW();
603
604 zephir_read_static_property_ce(&_0, phalcon_tag_ce, SL("documentType"), PH_NOISY_CC | PH_READONLY);
605 do {
606 if (ZEPHIR_IS_LONG(&_0, 1)) {
607 ZEPHIR_INIT_VAR(&_1$$3);
608 ZEPHIR_GET_CONSTANT(&_1$$3, "PHP_EOL");
609 ZEPHIR_CONCAT_SV(return_value, "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">", &_1$$3);
610 RETURN_MM();
611 }
612 if (ZEPHIR_IS_LONG(&_0, 2)) {
613 ZEPHIR_INIT_VAR(&_2$$4);
614 ZEPHIR_GET_CONSTANT(&_2$$4, "PHP_EOL");
615 ZEPHIR_INIT_VAR(&_3$$4);
616 ZEPHIR_GET_CONSTANT(&_3$$4, "PHP_EOL");
617 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);
618 RETURN_MM();
619 }
620 if (ZEPHIR_IS_LONG(&_0, 3)) {
621 ZEPHIR_INIT_VAR(&_4$$5);
622 ZEPHIR_GET_CONSTANT(&_4$$5, "PHP_EOL");
623 ZEPHIR_INIT_VAR(&_5$$5);
624 ZEPHIR_GET_CONSTANT(&_5$$5, "PHP_EOL");
625 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);
626 RETURN_MM();
627 }
628 if (ZEPHIR_IS_LONG(&_0, 4)) {
629 ZEPHIR_INIT_VAR(&_6$$6);
630 ZEPHIR_GET_CONSTANT(&_6$$6, "PHP_EOL");
631 ZEPHIR_INIT_VAR(&_7$$6);
632 ZEPHIR_GET_CONSTANT(&_7$$6, "PHP_EOL");
633 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);
634 RETURN_MM();
635 }
636 if (ZEPHIR_IS_LONG(&_0, 6)) {
637 ZEPHIR_INIT_VAR(&_8$$7);
638 ZEPHIR_GET_CONSTANT(&_8$$7, "PHP_EOL");
639 ZEPHIR_INIT_VAR(&_9$$7);
640 ZEPHIR_GET_CONSTANT(&_9$$7, "PHP_EOL");
641 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);
642 RETURN_MM();
643 }
644 if (ZEPHIR_IS_LONG(&_0, 7)) {
645 ZEPHIR_INIT_VAR(&_10$$8);
646 ZEPHIR_GET_CONSTANT(&_10$$8, "PHP_EOL");
647 ZEPHIR_INIT_VAR(&_11$$8);
648 ZEPHIR_GET_CONSTANT(&_11$$8, "PHP_EOL");
649 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);
650 RETURN_MM();
651 }
652 if (ZEPHIR_IS_LONG(&_0, 8)) {
653 ZEPHIR_INIT_VAR(&_12$$9);
654 ZEPHIR_GET_CONSTANT(&_12$$9, "PHP_EOL");
655 ZEPHIR_INIT_VAR(&_13$$9);
656 ZEPHIR_GET_CONSTANT(&_13$$9, "PHP_EOL");
657 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);
658 RETURN_MM();
659 }
660 if (ZEPHIR_IS_LONG(&_0, 9)) {
661 ZEPHIR_INIT_VAR(&_14$$10);
662 ZEPHIR_GET_CONSTANT(&_14$$10, "PHP_EOL");
663 ZEPHIR_INIT_VAR(&_15$$10);
664 ZEPHIR_GET_CONSTANT(&_15$$10, "PHP_EOL");
665 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);
666 RETURN_MM();
667 }
668 if (ZEPHIR_IS_LONG(&_0, 10)) {
669 ZEPHIR_INIT_VAR(&_16$$11);
670 ZEPHIR_GET_CONSTANT(&_16$$11, "PHP_EOL");
671 ZEPHIR_INIT_VAR(&_17$$11);
672 ZEPHIR_GET_CONSTANT(&_17$$11, "PHP_EOL");
673 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);
674 RETURN_MM();
675 }
676 if (ZEPHIR_IS_LONG(&_0, 5) || ZEPHIR_IS_LONG(&_0, 11)) {
677 ZEPHIR_INIT_VAR(&_18$$12);
678 ZEPHIR_GET_CONSTANT(&_18$$12, "PHP_EOL");
679 ZEPHIR_CONCAT_SV(return_value, "<!DOCTYPE html>", &_18$$12);
680 RETURN_MM();
681 }
682 } while(0);
683
684 RETURN_MM_STRING("");
685
686 }
687
688 /**
689 * Obtains the 'escaper' service if required
690 */
PHP_METHOD(Phalcon_Tag,getEscaper)691 PHP_METHOD(Phalcon_Tag, getEscaper) {
692
693 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
694 zend_long ZEPHIR_LAST_CALL_STATUS;
695 zval *params_param = NULL, autoescape;
696 zval params;
697 zval *this_ptr = getThis();
698
699 ZVAL_UNDEF(¶ms);
700 ZVAL_UNDEF(&autoescape);
701
702 ZEPHIR_MM_GROW();
703 zephir_fetch_params(1, 1, 0, ¶ms_param);
704
705 ZEPHIR_OBS_COPY_OR_DUP(¶ms, params_param);
706
707
708 ZEPHIR_OBS_VAR(&autoescape);
709 if (!(zephir_array_isset_string_fetch(&autoescape, ¶ms, SL("escape"), 0))) {
710 ZEPHIR_OBS_NVAR(&autoescape);
711 zephir_read_static_property_ce(&autoescape, phalcon_tag_ce, SL("autoEscape"), PH_NOISY_CC);
712 }
713 if (!(zephir_is_true(&autoescape))) {
714 RETURN_MM_NULL();
715 }
716 ZEPHIR_RETURN_CALL_SELF("getescaperservice", NULL, 0);
717 zephir_check_call_status();
718 RETURN_MM();
719
720 }
721
722 /**
723 * Internally gets the request dispatcher
724 */
PHP_METHOD(Phalcon_Tag,getDI)725 PHP_METHOD(Phalcon_Tag, getDI) {
726
727 zval di;
728 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
729 zend_long ZEPHIR_LAST_CALL_STATUS;
730 zephir_fcall_cache_entry *_0 = NULL;
731 zval *this_ptr = getThis();
732
733 ZVAL_UNDEF(&di);
734
735 ZEPHIR_MM_GROW();
736
737 ZEPHIR_OBS_VAR(&di);
738 zephir_read_static_property_ce(&di, phalcon_tag_ce, SL("container"), PH_NOISY_CC);
739 if (Z_TYPE_P(&di) != IS_OBJECT) {
740 ZEPHIR_CALL_CE_STATIC(&di, phalcon_di_ce, "getdefault", &_0, 0);
741 zephir_check_call_status();
742 }
743 RETURN_CCTOR(&di);
744
745 }
746
747 /**
748 * Returns an Escaper service from the default DI
749 */
PHP_METHOD(Phalcon_Tag,getEscaperService)750 PHP_METHOD(Phalcon_Tag, getEscaperService) {
751
752 zval escaper, container, _0$$4, _1$$4, _3$$4, _4$$3, _5$$3;
753 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
754 zephir_fcall_cache_entry *_2 = NULL;
755 zend_long ZEPHIR_LAST_CALL_STATUS;
756 zval *this_ptr = getThis();
757
758 ZVAL_UNDEF(&escaper);
759 ZVAL_UNDEF(&container);
760 ZVAL_UNDEF(&_0$$4);
761 ZVAL_UNDEF(&_1$$4);
762 ZVAL_UNDEF(&_3$$4);
763 ZVAL_UNDEF(&_4$$3);
764 ZVAL_UNDEF(&_5$$3);
765
766 ZEPHIR_MM_GROW();
767
768 ZEPHIR_OBS_VAR(&escaper);
769 zephir_read_static_property_ce(&escaper, phalcon_tag_ce, SL("escaperService"), PH_NOISY_CC);
770 if (Z_TYPE_P(&escaper) != IS_OBJECT) {
771 ZEPHIR_CALL_SELF(&container, "getdi", NULL, 0);
772 zephir_check_call_status();
773 if (UNEXPECTED(Z_TYPE_P(&container) != IS_OBJECT)) {
774 ZEPHIR_INIT_VAR(&_0$$4);
775 object_init_ex(&_0$$4, phalcon_tag_exception_ce);
776 ZEPHIR_INIT_VAR(&_3$$4);
777 ZVAL_STRING(&_3$$4, "the 'escaper' service");
778 ZEPHIR_CALL_CE_STATIC(&_1$$4, phalcon_tag_exception_ce, "containerservicenotfound", &_2, 0, &_3$$4);
779 zephir_check_call_status();
780 ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 8, &_1$$4);
781 zephir_check_call_status();
782 zephir_throw_exception_debug(&_0$$4, "phalcon/Tag.zep", 374);
783 ZEPHIR_MM_RESTORE();
784 return;
785 }
786 ZEPHIR_INIT_VAR(&_5$$3);
787 ZVAL_STRING(&_5$$3, "escaper");
788 ZEPHIR_CALL_METHOD(&_4$$3, &container, "getshared", NULL, 0, &_5$$3);
789 zephir_check_call_status();
790 ZEPHIR_CPY_WRT(&escaper, &_4$$3);
791 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("escaperService"), &escaper);
792 }
793 RETURN_CCTOR(&escaper);
794
795 }
796
797 /**
798 * Gets the current document title. The title will be automatically escaped.
799 */
PHP_METHOD(Phalcon_Tag,getTitle)800 PHP_METHOD(Phalcon_Tag, getTitle) {
801
802 zval _1;
803 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
804 zephir_fcall_cache_entry *_10 = NULL, *_12 = NULL, *_19 = NULL, *_21 = NULL;
805 zend_long ZEPHIR_LAST_CALL_STATUS;
806 zval *prepend_param = NULL, *append_param = NULL, __$true, items, output, title, documentTitle, documentAppendTitle, documentPrependTitle, documentTitleSeparator, escaper, _0, _2, _3, _4$$3, _6$$3, _5$$4, tmp$$5, *_7$$5, _8$$5, _9$$6, _11$$7, _13$$9, _15$$9, _14$$10, *_16$$11, _17$$11, _18$$12, _20$$13;
807 zend_bool prepend, append;
808 zval *this_ptr = getThis();
809
810 ZVAL_BOOL(&__$true, 1);
811 ZVAL_UNDEF(&items);
812 ZVAL_UNDEF(&output);
813 ZVAL_UNDEF(&title);
814 ZVAL_UNDEF(&documentTitle);
815 ZVAL_UNDEF(&documentAppendTitle);
816 ZVAL_UNDEF(&documentPrependTitle);
817 ZVAL_UNDEF(&documentTitleSeparator);
818 ZVAL_UNDEF(&escaper);
819 ZVAL_UNDEF(&_0);
820 ZVAL_UNDEF(&_2);
821 ZVAL_UNDEF(&_3);
822 ZVAL_UNDEF(&_4$$3);
823 ZVAL_UNDEF(&_6$$3);
824 ZVAL_UNDEF(&_5$$4);
825 ZVAL_UNDEF(&tmp$$5);
826 ZVAL_UNDEF(&_8$$5);
827 ZVAL_UNDEF(&_9$$6);
828 ZVAL_UNDEF(&_11$$7);
829 ZVAL_UNDEF(&_13$$9);
830 ZVAL_UNDEF(&_15$$9);
831 ZVAL_UNDEF(&_14$$10);
832 ZVAL_UNDEF(&_17$$11);
833 ZVAL_UNDEF(&_18$$12);
834 ZVAL_UNDEF(&_20$$13);
835 ZVAL_UNDEF(&_1);
836
837 ZEPHIR_MM_GROW();
838 zephir_fetch_params(1, 0, 2, &prepend_param, &append_param);
839
840 if (!prepend_param) {
841 prepend = 1;
842 } else {
843 prepend = zephir_get_boolval(prepend_param);
844 }
845 if (!append_param) {
846 append = 1;
847 } else {
848 append = zephir_get_boolval(append_param);
849 }
850
851
852 ZEPHIR_INIT_VAR(&_1);
853 zephir_create_array(&_1, 1, 0);
854 zephir_array_update_string(&_1, SL("escape"), &__$true, PH_COPY | PH_SEPARATE);
855 ZEPHIR_CALL_SELF(&_0, "getescaper", NULL, 0, &_1);
856 zephir_check_call_status();
857 ZEPHIR_CPY_WRT(&escaper, &_0);
858 ZEPHIR_INIT_VAR(&items);
859 array_init(&items);
860 ZEPHIR_INIT_VAR(&output);
861 ZVAL_STRING(&output, "");
862 zephir_read_static_property_ce(&_2, phalcon_tag_ce, SL("documentTitle"), PH_NOISY_CC | PH_READONLY);
863 ZEPHIR_CALL_METHOD(&documentTitle, &escaper, "escapehtml", NULL, 0, &_2);
864 zephir_check_call_status();
865 zephir_read_static_property_ce(&_3, phalcon_tag_ce, SL("documentTitleSeparator"), PH_NOISY_CC | PH_READONLY);
866 ZEPHIR_CALL_METHOD(&documentTitleSeparator, &escaper, "escapehtml", NULL, 0, &_3);
867 zephir_check_call_status();
868 if (prepend) {
869 zephir_read_static_property_ce(&_4$$3, phalcon_tag_ce, SL("documentPrependTitle"), PH_NOISY_CC | PH_READONLY);
870 if (Z_TYPE_P(&_4$$3) == IS_NULL) {
871 ZEPHIR_INIT_VAR(&_5$$4);
872 array_init(&_5$$4);
873 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("documentPrependTitle"), &_5$$4);
874 }
875 ZEPHIR_OBS_VAR(&_6$$3);
876 zephir_read_static_property_ce(&_6$$3, phalcon_tag_ce, SL("documentPrependTitle"), PH_NOISY_CC);
877 ZEPHIR_CPY_WRT(&documentPrependTitle, &_6$$3);
878 if (!(ZEPHIR_IS_EMPTY(&documentPrependTitle))) {
879 ZEPHIR_CALL_FUNCTION(&tmp$$5, "array_reverse", NULL, 0, &documentPrependTitle);
880 zephir_check_call_status();
881 zephir_is_iterable(&tmp$$5, 0, "phalcon/Tag.zep", 414);
882 if (Z_TYPE_P(&tmp$$5) == IS_ARRAY) {
883 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&tmp$$5), _7$$5)
884 {
885 ZEPHIR_INIT_NVAR(&title);
886 ZVAL_COPY(&title, _7$$5);
887 ZEPHIR_CALL_METHOD(&_9$$6, &escaper, "escapehtml", &_10, 0, &title);
888 zephir_check_call_status();
889 zephir_array_append(&items, &_9$$6, PH_SEPARATE, "phalcon/Tag.zep", 412);
890 } ZEND_HASH_FOREACH_END();
891 } else {
892 ZEPHIR_CALL_METHOD(NULL, &tmp$$5, "rewind", NULL, 0);
893 zephir_check_call_status();
894 while (1) {
895 ZEPHIR_CALL_METHOD(&_8$$5, &tmp$$5, "valid", NULL, 0);
896 zephir_check_call_status();
897 if (!zend_is_true(&_8$$5)) {
898 break;
899 }
900 ZEPHIR_CALL_METHOD(&title, &tmp$$5, "current", NULL, 0);
901 zephir_check_call_status();
902 ZEPHIR_CALL_METHOD(&_11$$7, &escaper, "escapehtml", &_12, 0, &title);
903 zephir_check_call_status();
904 zephir_array_append(&items, &_11$$7, PH_SEPARATE, "phalcon/Tag.zep", 412);
905 ZEPHIR_CALL_METHOD(NULL, &tmp$$5, "next", NULL, 0);
906 zephir_check_call_status();
907 }
908 }
909 ZEPHIR_INIT_NVAR(&title);
910 }
911 }
912 if (!(ZEPHIR_IS_EMPTY(&documentTitle))) {
913 zephir_array_append(&items, &documentTitle, PH_SEPARATE, "phalcon/Tag.zep", 418);
914 }
915 if (append) {
916 zephir_read_static_property_ce(&_13$$9, phalcon_tag_ce, SL("documentAppendTitle"), PH_NOISY_CC | PH_READONLY);
917 if (Z_TYPE_P(&_13$$9) == IS_NULL) {
918 ZEPHIR_INIT_VAR(&_14$$10);
919 array_init(&_14$$10);
920 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("documentAppendTitle"), &_14$$10);
921 }
922 ZEPHIR_OBS_VAR(&_15$$9);
923 zephir_read_static_property_ce(&_15$$9, phalcon_tag_ce, SL("documentAppendTitle"), PH_NOISY_CC);
924 ZEPHIR_CPY_WRT(&documentAppendTitle, &_15$$9);
925 if (!(ZEPHIR_IS_EMPTY(&documentAppendTitle))) {
926 zephir_is_iterable(&documentAppendTitle, 0, "phalcon/Tag.zep", 432);
927 if (Z_TYPE_P(&documentAppendTitle) == IS_ARRAY) {
928 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&documentAppendTitle), _16$$11)
929 {
930 ZEPHIR_INIT_NVAR(&title);
931 ZVAL_COPY(&title, _16$$11);
932 ZEPHIR_CALL_METHOD(&_18$$12, &escaper, "escapehtml", &_19, 0, &title);
933 zephir_check_call_status();
934 zephir_array_append(&items, &_18$$12, PH_SEPARATE, "phalcon/Tag.zep", 430);
935 } ZEND_HASH_FOREACH_END();
936 } else {
937 ZEPHIR_CALL_METHOD(NULL, &documentAppendTitle, "rewind", NULL, 0);
938 zephir_check_call_status();
939 while (1) {
940 ZEPHIR_CALL_METHOD(&_17$$11, &documentAppendTitle, "valid", NULL, 0);
941 zephir_check_call_status();
942 if (!zend_is_true(&_17$$11)) {
943 break;
944 }
945 ZEPHIR_CALL_METHOD(&title, &documentAppendTitle, "current", NULL, 0);
946 zephir_check_call_status();
947 ZEPHIR_CALL_METHOD(&_20$$13, &escaper, "escapehtml", &_21, 0, &title);
948 zephir_check_call_status();
949 zephir_array_append(&items, &_20$$13, PH_SEPARATE, "phalcon/Tag.zep", 430);
950 ZEPHIR_CALL_METHOD(NULL, &documentAppendTitle, "next", NULL, 0);
951 zephir_check_call_status();
952 }
953 }
954 ZEPHIR_INIT_NVAR(&title);
955 }
956 }
957 if (ZEPHIR_IS_EMPTY(&documentTitleSeparator)) {
958 ZEPHIR_INIT_NVAR(&documentTitleSeparator);
959 ZVAL_STRING(&documentTitleSeparator, "");
960 }
961 if (!(ZEPHIR_IS_EMPTY(&items))) {
962 ZEPHIR_INIT_NVAR(&output);
963 zephir_fast_join(&output, &documentTitleSeparator, &items);
964 }
965 RETURN_CCTOR(&output);
966
967 }
968
969 /**
970 * Gets the current document title separator
971 */
PHP_METHOD(Phalcon_Tag,getTitleSeparator)972 PHP_METHOD(Phalcon_Tag, getTitleSeparator) {
973
974 zval _0;
975 zval *this_ptr = getThis();
976
977 ZVAL_UNDEF(&_0);
978
979
980 zephir_read_static_property_ce(&_0, phalcon_tag_ce, SL("documentTitleSeparator"), PH_NOISY_CC | PH_READONLY);
981 RETURN_CTORW(&_0);
982
983 }
984
985 /**
986 * Returns a URL service from the default DI
987 */
PHP_METHOD(Phalcon_Tag,getUrlService)988 PHP_METHOD(Phalcon_Tag, getUrlService) {
989
990 zval url, container, _0$$4, _1$$4, _3$$4, _4$$3, _5$$3;
991 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
992 zephir_fcall_cache_entry *_2 = NULL;
993 zend_long ZEPHIR_LAST_CALL_STATUS;
994 zval *this_ptr = getThis();
995
996 ZVAL_UNDEF(&url);
997 ZVAL_UNDEF(&container);
998 ZVAL_UNDEF(&_0$$4);
999 ZVAL_UNDEF(&_1$$4);
1000 ZVAL_UNDEF(&_3$$4);
1001 ZVAL_UNDEF(&_4$$3);
1002 ZVAL_UNDEF(&_5$$3);
1003
1004 ZEPHIR_MM_GROW();
1005
1006 ZEPHIR_OBS_VAR(&url);
1007 zephir_read_static_property_ce(&url, phalcon_tag_ce, SL("urlService"), PH_NOISY_CC);
1008 if (Z_TYPE_P(&url) != IS_OBJECT) {
1009 ZEPHIR_CALL_SELF(&container, "getdi", NULL, 0);
1010 zephir_check_call_status();
1011 if (UNEXPECTED(Z_TYPE_P(&container) != IS_OBJECT)) {
1012 ZEPHIR_INIT_VAR(&_0$$4);
1013 object_init_ex(&_0$$4, phalcon_tag_exception_ce);
1014 ZEPHIR_INIT_VAR(&_3$$4);
1015 ZVAL_STRING(&_3$$4, "the 'url' service");
1016 ZEPHIR_CALL_CE_STATIC(&_1$$4, phalcon_tag_exception_ce, "containerservicenotfound", &_2, 0, &_3$$4);
1017 zephir_check_call_status();
1018 ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 8, &_1$$4);
1019 zephir_check_call_status();
1020 zephir_throw_exception_debug(&_0$$4, "phalcon/Tag.zep", 469);
1021 ZEPHIR_MM_RESTORE();
1022 return;
1023 }
1024 ZEPHIR_INIT_VAR(&_5$$3);
1025 ZVAL_STRING(&_5$$3, "url");
1026 ZEPHIR_CALL_METHOD(&_4$$3, &container, "getshared", NULL, 0, &_5$$3);
1027 zephir_check_call_status();
1028 ZEPHIR_CPY_WRT(&url, &_4$$3);
1029 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("urlService"), &url);
1030 }
1031 RETURN_CCTOR(&url);
1032
1033 }
1034
1035 /**
1036 * Every helper calls this function to check whether a component has a
1037 * predefined value using Phalcon\Tag::setDefault() or value from $_POST
1038 */
PHP_METHOD(Phalcon_Tag,getValue)1039 PHP_METHOD(Phalcon_Tag, getValue) {
1040
1041 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
1042 zval params;
1043 zval *name, name_sub, *params_param = NULL, _POST, value, _0$$3;
1044 zval *this_ptr = getThis();
1045
1046 ZVAL_UNDEF(&name_sub);
1047 ZVAL_UNDEF(&_POST);
1048 ZVAL_UNDEF(&value);
1049 ZVAL_UNDEF(&_0$$3);
1050 ZVAL_UNDEF(¶ms);
1051
1052 ZEPHIR_MM_GROW();
1053 zephir_get_global(&_POST, SL("_POST"));
1054 zephir_fetch_params(1, 1, 1, &name, ¶ms_param);
1055
1056 if (!params_param) {
1057 ZEPHIR_INIT_VAR(¶ms);
1058 array_init(¶ms);
1059 } else {
1060 zephir_get_arrval(¶ms, params_param);
1061 }
1062
1063
1064 ZEPHIR_OBS_VAR(&value);
1065 if (!(zephir_array_isset_string_fetch(&value, ¶ms, SL("value"), 0))) {
1066 ZEPHIR_OBS_NVAR(&value);
1067 zephir_read_static_property_ce(&_0$$3, phalcon_tag_ce, SL("displayValues"), PH_NOISY_CC | PH_READONLY);
1068 if (!(zephir_array_isset_fetch(&value, &_0$$3, name, 0))) {
1069 ZEPHIR_OBS_NVAR(&value);
1070 if (!(zephir_array_isset_fetch(&value, &_POST, name, 0))) {
1071 RETURN_MM_NULL();
1072 }
1073 }
1074 }
1075 RETURN_CCTOR(&value);
1076
1077 }
1078
1079 /**
1080 * Check if a helper has a default value set using Phalcon\Tag::setDefault()
1081 * or value from $_POST
1082 */
PHP_METHOD(Phalcon_Tag,hasValue)1083 PHP_METHOD(Phalcon_Tag, hasValue) {
1084
1085 zend_bool _1;
1086 zval *name, name_sub, _POST, _0;
1087 zval *this_ptr = getThis();
1088
1089 ZVAL_UNDEF(&name_sub);
1090 ZVAL_UNDEF(&_POST);
1091 ZVAL_UNDEF(&_0);
1092
1093 zephir_get_global(&_POST, SL("_POST"));
1094 zephir_fetch_params_without_memory_grow(1, 0, &name);
1095
1096
1097
1098 zephir_read_static_property_ce(&_0, phalcon_tag_ce, SL("displayValues"), PH_NOISY_CC | PH_READONLY);
1099 _1 = zephir_array_isset(&_0, name);
1100 if (!(_1)) {
1101 _1 = zephir_array_isset(&_POST, name);
1102 }
1103 RETURN_BOOL(_1);
1104
1105 }
1106
1107 /**
1108 * Builds a HTML input[type="hidden"] tag
1109 *
1110 * @param array parameters = [
1111 * 'class' => '',
1112 * 'name' => '',
1113 * 'src' => '',
1114 * 'id' => '',
1115 * 'value' => ''
1116 * ]
1117 */
PHP_METHOD(Phalcon_Tag,hiddenField)1118 PHP_METHOD(Phalcon_Tag, hiddenField) {
1119
1120 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
1121 zend_long ZEPHIR_LAST_CALL_STATUS;
1122 zephir_fcall_cache_entry *_0 = NULL;
1123 zval *parameters, parameters_sub, _1;
1124 zval *this_ptr = getThis();
1125
1126 ZVAL_UNDEF(¶meters_sub);
1127 ZVAL_UNDEF(&_1);
1128
1129 ZEPHIR_MM_GROW();
1130 zephir_fetch_params(1, 1, 0, ¶meters);
1131
1132
1133
1134 ZEPHIR_INIT_VAR(&_1);
1135 ZVAL_STRING(&_1, "hidden");
1136 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters);
1137 zephir_check_call_status();
1138 RETURN_MM();
1139
1140 }
1141
1142 /**
1143 * Builds HTML IMG tags
1144 *
1145 * @param array|string parameters = [
1146 * 'src' => '',
1147 * 'class' => '',
1148 * 'id' => '',
1149 * 'name' => ''
1150 * ]
1151 */
PHP_METHOD(Phalcon_Tag,image)1152 PHP_METHOD(Phalcon_Tag, image) {
1153
1154 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
1155 zend_long ZEPHIR_LAST_CALL_STATUS;
1156 zend_bool local;
1157 zval *parameters = NULL, parameters_sub, *local_param = NULL, __$null, params, code, src, _5, _6, _0$$5, _1$$8, _2$$9, _3$$9, _4$$9;
1158 zval *this_ptr = getThis();
1159
1160 ZVAL_UNDEF(¶meters_sub);
1161 ZVAL_NULL(&__$null);
1162 ZVAL_UNDEF(¶ms);
1163 ZVAL_UNDEF(&code);
1164 ZVAL_UNDEF(&src);
1165 ZVAL_UNDEF(&_5);
1166 ZVAL_UNDEF(&_6);
1167 ZVAL_UNDEF(&_0$$5);
1168 ZVAL_UNDEF(&_1$$8);
1169 ZVAL_UNDEF(&_2$$9);
1170 ZVAL_UNDEF(&_3$$9);
1171 ZVAL_UNDEF(&_4$$9);
1172
1173 ZEPHIR_MM_GROW();
1174 zephir_fetch_params(1, 0, 2, ¶meters, &local_param);
1175
1176 if (!parameters) {
1177 parameters = ¶meters_sub;
1178 parameters = &__$null;
1179 }
1180 if (!local_param) {
1181 local = 1;
1182 } else {
1183 local = zephir_get_boolval(local_param);
1184 }
1185
1186
1187 if (Z_TYPE_P(parameters) != IS_ARRAY) {
1188 ZEPHIR_INIT_VAR(¶ms);
1189 zephir_create_array(¶ms, 1, 0);
1190 zephir_array_fast_append(¶ms, parameters);
1191 } else {
1192 ZEPHIR_CPY_WRT(¶ms, parameters);
1193 if (zephir_array_isset_long(¶ms, 1)) {
1194 ZEPHIR_OBS_VAR(&_0$$5);
1195 zephir_array_fetch_long(&_0$$5, ¶ms, 1, PH_NOISY, "phalcon/Tag.zep", 552);
1196 local = zephir_get_boolval(&_0$$5);
1197 }
1198 }
1199 if (!(zephir_array_isset_string(¶ms, SL("src")))) {
1200 ZEPHIR_OBS_VAR(&src);
1201 if (zephir_array_isset_long_fetch(&src, ¶ms, 0, 0)) {
1202 zephir_array_update_string(¶ms, SL("src"), &src, PH_COPY | PH_SEPARATE);
1203 } else {
1204 ZEPHIR_INIT_VAR(&_1$$8);
1205 ZVAL_STRING(&_1$$8, "");
1206 zephir_array_update_string(¶ms, SL("src"), &_1$$8, PH_COPY | PH_SEPARATE);
1207 }
1208 }
1209 if (local) {
1210 ZEPHIR_CALL_SELF(&_2$$9, "geturlservice", NULL, 0);
1211 zephir_check_call_status();
1212 zephir_array_fetch_string(&_4$$9, ¶ms, SL("src"), PH_NOISY | PH_READONLY, "phalcon/Tag.zep", 568);
1213 ZEPHIR_CALL_METHOD(&_3$$9, &_2$$9, "getstatic", NULL, 0, &_4$$9);
1214 zephir_check_call_status();
1215 zephir_array_update_string(¶ms, SL("src"), &_3$$9, PH_COPY | PH_SEPARATE);
1216 }
1217 ZEPHIR_INIT_VAR(&_5);
1218 ZVAL_STRING(&_5, "<img");
1219 ZEPHIR_CALL_SELF(&code, "renderattributes", NULL, 0, &_5, ¶ms);
1220 zephir_check_call_status();
1221 zephir_read_static_property_ce(&_6, phalcon_tag_ce, SL("documentType"), PH_NOISY_CC | PH_READONLY);
1222 if (ZEPHIR_GT_LONG(&_6, 5)) {
1223 zephir_concat_self_str(&code, SL(" />"));
1224 } else {
1225 zephir_concat_self_str(&code, SL(">"));
1226 }
1227 RETURN_CCTOR(&code);
1228
1229 }
1230
1231 /**
1232 * Builds a HTML input[type="image"] tag
1233 *
1234 * @param array parameters = [
1235 * 'class' => '',
1236 * 'name' => '',
1237 * 'src' => '',
1238 * 'id' => ''
1239 * ]
1240 */
PHP_METHOD(Phalcon_Tag,imageInput)1241 PHP_METHOD(Phalcon_Tag, imageInput) {
1242
1243 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
1244 zend_long ZEPHIR_LAST_CALL_STATUS;
1245 zephir_fcall_cache_entry *_0 = NULL;
1246 zval *parameters, parameters_sub, _1, _2;
1247 zval *this_ptr = getThis();
1248
1249 ZVAL_UNDEF(¶meters_sub);
1250 ZVAL_UNDEF(&_1);
1251 ZVAL_UNDEF(&_2);
1252
1253 ZEPHIR_MM_GROW();
1254 zephir_fetch_params(1, 1, 0, ¶meters);
1255
1256
1257
1258 ZEPHIR_INIT_VAR(&_1);
1259 ZVAL_STRING(&_1, "image");
1260 ZVAL_BOOL(&_2, 1);
1261 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters, &_2);
1262 zephir_check_call_status();
1263 RETURN_MM();
1264
1265 }
1266
1267 /**
1268 * Builds a SCRIPT[type="javascript"] tag
1269 *
1270 * @param array|string parameters = [
1271 * 'local' => false,
1272 * 'src' => '',
1273 * 'type' => 'text/javascript'
1274 * 'rel' => ''
1275 * ]
1276 */
PHP_METHOD(Phalcon_Tag,javascriptInclude)1277 PHP_METHOD(Phalcon_Tag, javascriptInclude) {
1278
1279 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
1280 zend_long ZEPHIR_LAST_CALL_STATUS;
1281 zend_bool local, _3;
1282 zval *parameters = NULL, parameters_sub, *local_param = NULL, __$null, params, code, _4, _11, _12, _0$$3, _1$$5, _2$$7, _5$$8, _6$$10, _7$$11, _8$$12, _9$$12, _10$$12;
1283 zval *this_ptr = getThis();
1284
1285 ZVAL_UNDEF(¶meters_sub);
1286 ZVAL_NULL(&__$null);
1287 ZVAL_UNDEF(¶ms);
1288 ZVAL_UNDEF(&code);
1289 ZVAL_UNDEF(&_4);
1290 ZVAL_UNDEF(&_11);
1291 ZVAL_UNDEF(&_12);
1292 ZVAL_UNDEF(&_0$$3);
1293 ZVAL_UNDEF(&_1$$5);
1294 ZVAL_UNDEF(&_2$$7);
1295 ZVAL_UNDEF(&_5$$8);
1296 ZVAL_UNDEF(&_6$$10);
1297 ZVAL_UNDEF(&_7$$11);
1298 ZVAL_UNDEF(&_8$$12);
1299 ZVAL_UNDEF(&_9$$12);
1300 ZVAL_UNDEF(&_10$$12);
1301
1302 ZEPHIR_MM_GROW();
1303 zephir_fetch_params(1, 0, 2, ¶meters, &local_param);
1304
1305 if (!parameters) {
1306 parameters = ¶meters_sub;
1307 parameters = &__$null;
1308 }
1309 if (!local_param) {
1310 local = 1;
1311 } else {
1312 local = zephir_get_boolval(local_param);
1313 }
1314
1315
1316 if (Z_TYPE_P(parameters) != IS_ARRAY) {
1317 ZEPHIR_INIT_VAR(¶ms);
1318 zephir_create_array(¶ms, 2, 0);
1319 zephir_array_fast_append(¶ms, parameters);
1320 ZEPHIR_INIT_VAR(&_0$$3);
1321 ZVAL_BOOL(&_0$$3, local);
1322 zephir_array_fast_append(¶ms, &_0$$3);
1323 } else {
1324 ZEPHIR_CPY_WRT(¶ms, parameters);
1325 }
1326 if (zephir_array_isset_long(¶ms, 1)) {
1327 ZEPHIR_OBS_VAR(&_1$$5);
1328 zephir_array_fetch_long(&_1$$5, ¶ms, 1, PH_NOISY, "phalcon/Tag.zep", 621);
1329 local = zephir_get_boolval(&_1$$5);
1330 } else {
1331 if (zephir_array_isset_string(¶ms, SL("local"))) {
1332 ZEPHIR_OBS_VAR(&_2$$7);
1333 zephir_array_fetch_string(&_2$$7, ¶ms, SL("local"), PH_NOISY, "phalcon/Tag.zep", 624);
1334 local = zephir_get_boolval(&_2$$7);
1335 zephir_array_unset_string(¶ms, SL("local"), PH_SEPARATE);
1336 }
1337 }
1338 _3 = !(zephir_array_isset_string(¶ms, SL("type")));
1339 if (_3) {
1340 zephir_read_static_property_ce(&_4, phalcon_tag_ce, SL("documentType"), PH_NOISY_CC | PH_READONLY);
1341 _3 = ZEPHIR_LT_LONG(&_4, 5);
1342 }
1343 if (_3) {
1344 ZEPHIR_INIT_VAR(&_5$$8);
1345 ZVAL_STRING(&_5$$8, "text/javascript");
1346 zephir_array_update_string(¶ms, SL("type"), &_5$$8, PH_COPY | PH_SEPARATE);
1347 }
1348 if (!(zephir_array_isset_string(¶ms, SL("src")))) {
1349 if (zephir_array_isset_long(¶ms, 0)) {
1350 zephir_array_fetch_long(&_6$$10, ¶ms, 0, PH_NOISY | PH_READONLY, "phalcon/Tag.zep", 636);
1351 zephir_array_update_string(¶ms, SL("src"), &_6$$10, PH_COPY | PH_SEPARATE);
1352 } else {
1353 ZEPHIR_INIT_VAR(&_7$$11);
1354 ZVAL_STRING(&_7$$11, "");
1355 zephir_array_update_string(¶ms, SL("src"), &_7$$11, PH_COPY | PH_SEPARATE);
1356 }
1357 }
1358 if (local) {
1359 ZEPHIR_CALL_SELF(&_8$$12, "geturlservice", NULL, 0);
1360 zephir_check_call_status();
1361 zephir_array_fetch_string(&_10$$12, ¶ms, SL("src"), PH_NOISY | PH_READONLY, "phalcon/Tag.zep", 646);
1362 ZEPHIR_CALL_METHOD(&_9$$12, &_8$$12, "getstatic", NULL, 0, &_10$$12);
1363 zephir_check_call_status();
1364 zephir_array_update_string(¶ms, SL("src"), &_9$$12, PH_COPY | PH_SEPARATE);
1365 }
1366 ZEPHIR_INIT_VAR(&_11);
1367 ZVAL_STRING(&_11, "<script");
1368 ZEPHIR_CALL_SELF(&code, "renderattributes", NULL, 0, &_11, ¶ms);
1369 zephir_check_call_status();
1370 ZEPHIR_INIT_NVAR(&_11);
1371 ZEPHIR_GET_CONSTANT(&_11, "PHP_EOL");
1372 ZEPHIR_INIT_VAR(&_12);
1373 ZEPHIR_CONCAT_SV(&_12, "></script>", &_11);
1374 zephir_concat_self(&code, &_12);
1375 RETURN_CCTOR(&code);
1376
1377 }
1378
1379 /**
1380 * Builds a HTML A tag using framework conventions
1381 *
1382 * @param parameters array|string = [
1383 * 'action' => '',
1384 * 'text' => '',
1385 * 'local' => false,
1386 * 'query' => '',
1387 * 'class' => '',
1388 * 'name' => '',
1389 * 'href' => '',
1390 * 'id' => ''
1391 * ]
1392 */
PHP_METHOD(Phalcon_Tag,linkTo)1393 PHP_METHOD(Phalcon_Tag, linkTo) {
1394
1395 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
1396 zend_long ZEPHIR_LAST_CALL_STATUS;
1397 zval *parameters, parameters_sub, *text = NULL, text_sub, *local = NULL, local_sub, __$null, __$true, params, action, query, url, code, _0, _1, _2;
1398 zval *this_ptr = getThis();
1399
1400 ZVAL_UNDEF(¶meters_sub);
1401 ZVAL_UNDEF(&text_sub);
1402 ZVAL_UNDEF(&local_sub);
1403 ZVAL_NULL(&__$null);
1404 ZVAL_BOOL(&__$true, 1);
1405 ZVAL_UNDEF(¶ms);
1406 ZVAL_UNDEF(&action);
1407 ZVAL_UNDEF(&query);
1408 ZVAL_UNDEF(&url);
1409 ZVAL_UNDEF(&code);
1410 ZVAL_UNDEF(&_0);
1411 ZVAL_UNDEF(&_1);
1412 ZVAL_UNDEF(&_2);
1413
1414 ZEPHIR_MM_GROW();
1415 zephir_fetch_params(1, 1, 2, ¶meters, &text, &local);
1416
1417 if (!text) {
1418 text = &text_sub;
1419 ZEPHIR_CPY_WRT(text, &__$null);
1420 } else {
1421 ZEPHIR_SEPARATE_PARAM(text);
1422 }
1423 if (!local) {
1424 local = &local_sub;
1425 ZEPHIR_CPY_WRT(local, &__$true);
1426 } else {
1427 ZEPHIR_SEPARATE_PARAM(local);
1428 }
1429
1430
1431 if (Z_TYPE_P(parameters) != IS_ARRAY) {
1432 ZEPHIR_INIT_VAR(¶ms);
1433 zephir_create_array(¶ms, 3, 0);
1434 zephir_array_fast_append(¶ms, parameters);
1435 zephir_array_fast_append(¶ms, text);
1436 zephir_array_fast_append(¶ms, local);
1437 } else {
1438 ZEPHIR_CPY_WRT(¶ms, parameters);
1439 }
1440 ZEPHIR_OBS_VAR(&action);
1441 if (!(zephir_array_isset_long_fetch(&action, ¶ms, 0, 0))) {
1442 ZEPHIR_OBS_NVAR(&action);
1443 if (!(zephir_array_isset_string_fetch(&action, ¶ms, SL("action"), 0))) {
1444 ZEPHIR_INIT_NVAR(&action);
1445 ZVAL_STRING(&action, "");
1446 } else {
1447 zephir_array_unset_string(¶ms, SL("action"), PH_SEPARATE);
1448 }
1449 }
1450 ZEPHIR_OBS_NVAR(text);
1451 if (!(zephir_array_isset_long_fetch(text, ¶ms, 1, 0))) {
1452 ZEPHIR_OBS_NVAR(text);
1453 if (!(zephir_array_isset_string_fetch(text, ¶ms, SL("text"), 0))) {
1454 ZEPHIR_INIT_NVAR(text);
1455 ZVAL_STRING(text, "");
1456 } else {
1457 zephir_array_unset_string(¶ms, SL("text"), PH_SEPARATE);
1458 }
1459 }
1460 ZEPHIR_OBS_NVAR(local);
1461 if (!(zephir_array_isset_long_fetch(local, ¶ms, 2, 0))) {
1462 ZEPHIR_OBS_NVAR(local);
1463 if (!(zephir_array_isset_string_fetch(local, ¶ms, SL("local"), 0))) {
1464 ZEPHIR_INIT_NVAR(local);
1465 ZVAL_BOOL(local, 1);
1466 } else {
1467 zephir_array_unset_string(¶ms, SL("local"), PH_SEPARATE);
1468 }
1469 }
1470 ZEPHIR_OBS_VAR(&query);
1471 if (zephir_array_isset_string_fetch(&query, ¶ms, SL("query"), 0)) {
1472 zephir_array_unset_string(¶ms, SL("query"), PH_SEPARATE);
1473 } else {
1474 ZEPHIR_INIT_NVAR(&query);
1475 ZVAL_NULL(&query);
1476 }
1477 ZEPHIR_CALL_SELF(&url, "geturlservice", NULL, 0);
1478 zephir_check_call_status();
1479 ZEPHIR_CALL_METHOD(&_0, &url, "get", NULL, 0, &action, &query, local);
1480 zephir_check_call_status();
1481 zephir_array_update_string(¶ms, SL("href"), &_0, PH_COPY | PH_SEPARATE);
1482 ZEPHIR_INIT_VAR(&_1);
1483 ZVAL_STRING(&_1, "<a");
1484 ZEPHIR_CALL_SELF(&code, "renderattributes", NULL, 0, &_1, ¶ms);
1485 zephir_check_call_status();
1486 ZEPHIR_INIT_VAR(&_2);
1487 ZEPHIR_CONCAT_SVS(&_2, ">", text, "</a>");
1488 zephir_concat_self(&code, &_2);
1489 RETURN_CCTOR(&code);
1490
1491 }
1492
1493 /**
1494 * Builds a HTML input[type="month"] tag
1495 *
1496 * @param array parameters = [
1497 * 'class' => '',
1498 * 'name' => '',
1499 * 'src' => '',
1500 * 'id' => '',
1501 * 'value' => ''
1502 * ]
1503 */
PHP_METHOD(Phalcon_Tag,monthField)1504 PHP_METHOD(Phalcon_Tag, monthField) {
1505
1506 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
1507 zend_long ZEPHIR_LAST_CALL_STATUS;
1508 zephir_fcall_cache_entry *_0 = NULL;
1509 zval *parameters, parameters_sub, _1;
1510 zval *this_ptr = getThis();
1511
1512 ZVAL_UNDEF(¶meters_sub);
1513 ZVAL_UNDEF(&_1);
1514
1515 ZEPHIR_MM_GROW();
1516 zephir_fetch_params(1, 1, 0, ¶meters);
1517
1518
1519
1520 ZEPHIR_INIT_VAR(&_1);
1521 ZVAL_STRING(&_1, "month");
1522 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters);
1523 zephir_check_call_status();
1524 RETURN_MM();
1525
1526 }
1527
1528 /**
1529 * Builds a HTML input[type="number"] tag
1530 *
1531 * @param array parameters = [
1532 * 'class' => '',
1533 * 'name' => '',
1534 * 'src' => '',
1535 * 'id' => '',
1536 * 'value' => ''
1537 * ]
1538 */
PHP_METHOD(Phalcon_Tag,numericField)1539 PHP_METHOD(Phalcon_Tag, numericField) {
1540
1541 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
1542 zend_long ZEPHIR_LAST_CALL_STATUS;
1543 zephir_fcall_cache_entry *_0 = NULL;
1544 zval *parameters, parameters_sub, _1;
1545 zval *this_ptr = getThis();
1546
1547 ZVAL_UNDEF(¶meters_sub);
1548 ZVAL_UNDEF(&_1);
1549
1550 ZEPHIR_MM_GROW();
1551 zephir_fetch_params(1, 1, 0, ¶meters);
1552
1553
1554
1555 ZEPHIR_INIT_VAR(&_1);
1556 ZVAL_STRING(&_1, "number");
1557 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters);
1558 zephir_check_call_status();
1559 RETURN_MM();
1560
1561 }
1562
1563 /**
1564 * Builds a HTML input[type="password"] tag
1565 *
1566 * @param array parameters = [
1567 * 'class' => '',
1568 * 'name' => '',
1569 * 'src' => '',
1570 * 'id' => '',
1571 * 'value' => ''
1572 * ]
1573 */
PHP_METHOD(Phalcon_Tag,passwordField)1574 PHP_METHOD(Phalcon_Tag, passwordField) {
1575
1576 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
1577 zend_long ZEPHIR_LAST_CALL_STATUS;
1578 zephir_fcall_cache_entry *_0 = NULL;
1579 zval *parameters, parameters_sub, _1;
1580 zval *this_ptr = getThis();
1581
1582 ZVAL_UNDEF(¶meters_sub);
1583 ZVAL_UNDEF(&_1);
1584
1585 ZEPHIR_MM_GROW();
1586 zephir_fetch_params(1, 1, 0, ¶meters);
1587
1588
1589
1590 ZEPHIR_INIT_VAR(&_1);
1591 ZVAL_STRING(&_1, "password");
1592 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters);
1593 zephir_check_call_status();
1594 RETURN_MM();
1595
1596 }
1597
1598 /**
1599 * Prepends a text to current document title
1600 */
PHP_METHOD(Phalcon_Tag,prependTitle)1601 PHP_METHOD(Phalcon_Tag, prependTitle) {
1602
1603 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
1604 zval *title, title_sub, _0, _1$$3;
1605 zval *this_ptr = getThis();
1606
1607 ZVAL_UNDEF(&title_sub);
1608 ZVAL_UNDEF(&_0);
1609 ZVAL_UNDEF(&_1$$3);
1610
1611 ZEPHIR_MM_GROW();
1612 zephir_fetch_params(1, 1, 0, &title);
1613
1614
1615
1616 zephir_read_static_property_ce(&_0, phalcon_tag_ce, SL("documentPrependTitle"), PH_NOISY_CC | PH_READONLY);
1617 if (Z_TYPE_P(&_0) == IS_NULL) {
1618 ZEPHIR_INIT_VAR(&_1$$3);
1619 array_init(&_1$$3);
1620 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("documentPrependTitle"), &_1$$3);
1621 }
1622 if (Z_TYPE_P(title) == IS_ARRAY) {
1623 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("documentPrependTitle"), title);
1624 } else {
1625 zephir_update_static_property_array_multi_ce(phalcon_tag_ce, SL("documentPrependTitle"), title, SL("a"), 1);
1626 }
1627 ZEPHIR_MM_RESTORE();
1628
1629 }
1630
1631 /**
1632 * Parses the preload element passed and sets the necessary link headers
1633 */
PHP_METHOD(Phalcon_Tag,preload)1634 PHP_METHOD(Phalcon_Tag, preload) {
1635
1636 zval _10$$5;
1637 zend_bool _1;
1638 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
1639 zend_long ZEPHIR_LAST_CALL_STATUS;
1640 zval *parameters, parameters_sub, attributes, container, header, href, link, params, response, _2, _3, _0$$3, _4$$7, _5$$5, _6$$5, _7$$5, _8$$5, _9$$5;
1641 zval *this_ptr = getThis();
1642
1643 ZVAL_UNDEF(¶meters_sub);
1644 ZVAL_UNDEF(&attributes);
1645 ZVAL_UNDEF(&container);
1646 ZVAL_UNDEF(&header);
1647 ZVAL_UNDEF(&href);
1648 ZVAL_UNDEF(&link);
1649 ZVAL_UNDEF(¶ms);
1650 ZVAL_UNDEF(&response);
1651 ZVAL_UNDEF(&_2);
1652 ZVAL_UNDEF(&_3);
1653 ZVAL_UNDEF(&_0$$3);
1654 ZVAL_UNDEF(&_4$$7);
1655 ZVAL_UNDEF(&_5$$5);
1656 ZVAL_UNDEF(&_6$$5);
1657 ZVAL_UNDEF(&_7$$5);
1658 ZVAL_UNDEF(&_8$$5);
1659 ZVAL_UNDEF(&_9$$5);
1660 ZVAL_UNDEF(&_10$$5);
1661
1662 ZEPHIR_MM_GROW();
1663 zephir_fetch_params(1, 1, 0, ¶meters);
1664
1665
1666
1667 ZEPHIR_INIT_VAR(¶ms);
1668 array_init(¶ms);
1669 if (Z_TYPE_P(parameters) != IS_ARRAY) {
1670 ZEPHIR_INIT_VAR(&_0$$3);
1671 zephir_create_array(&_0$$3, 1, 0);
1672 zephir_array_fast_append(&_0$$3, parameters);
1673 ZEPHIR_CPY_WRT(¶ms, &_0$$3);
1674 } else {
1675 ZEPHIR_CPY_WRT(¶ms, parameters);
1676 }
1677 ZEPHIR_OBS_VAR(&href);
1678 zephir_array_isset_long_fetch(&href, ¶ms, 0, 0);
1679 ZEPHIR_CALL_SELF(&container, "getdi", NULL, 0);
1680 zephir_check_call_status();
1681 _1 = zephir_is_true(&container);
1682 if (_1) {
1683 ZEPHIR_INIT_VAR(&_3);
1684 ZVAL_STRING(&_3, "response");
1685 ZEPHIR_CALL_METHOD(&_2, &container, "has", NULL, 0, &_3);
1686 zephir_check_call_status();
1687 _1 = zephir_is_true(&_2);
1688 }
1689 if (_1) {
1690 if (zephir_array_isset_long(¶ms, 1)) {
1691 ZEPHIR_OBS_VAR(&attributes);
1692 zephir_array_fetch_long(&attributes, ¶ms, 1, PH_NOISY, "phalcon/Tag.zep", 809);
1693 } else {
1694 ZEPHIR_INIT_VAR(&_4$$7);
1695 zephir_create_array(&_4$$7, 1, 0);
1696 add_assoc_stringl_ex(&_4$$7, SL("as"), SL("style"));
1697 ZEPHIR_CPY_WRT(&attributes, &_4$$7);
1698 }
1699 ZEPHIR_INIT_VAR(&_5$$5);
1700 ZVAL_STRING(&_5$$5, "response");
1701 ZEPHIR_CALL_METHOD(&response, &container, "get", NULL, 0, &_5$$5);
1702 zephir_check_call_status();
1703 ZEPHIR_INIT_VAR(&link);
1704 object_init_ex(&link, phalcon_html_link_link_ce);
1705 ZEPHIR_INIT_NVAR(&_5$$5);
1706 ZEPHIR_INIT_VAR(&_6$$5);
1707 ZVAL_STRING(&_6$$5, "'");
1708 ZEPHIR_INIT_VAR(&_7$$5);
1709 ZVAL_STRING(&_7$$5, "");
1710 zephir_fast_str_replace(&_5$$5, &_6$$5, &_7$$5, &href);
1711 ZEPHIR_INIT_VAR(&_8$$5);
1712 ZVAL_STRING(&_8$$5, "preload");
1713 ZEPHIR_CALL_METHOD(NULL, &link, "__construct", NULL, 0, &_8$$5, &_5$$5, &attributes);
1714 zephir_check_call_status();
1715 ZEPHIR_INIT_NVAR(&_8$$5);
1716 object_init_ex(&_8$$5, phalcon_html_link_serializer_header_ce);
1717 if (zephir_has_constructor(&_8$$5)) {
1718 ZEPHIR_CALL_METHOD(NULL, &_8$$5, "__construct", NULL, 0);
1719 zephir_check_call_status();
1720 }
1721 ZEPHIR_INIT_VAR(&_10$$5);
1722 zephir_create_array(&_10$$5, 1, 0);
1723 zephir_array_fast_append(&_10$$5, &link);
1724 ZEPHIR_CALL_METHOD(&_9$$5, &_8$$5, "serialize", NULL, 0, &_10$$5);
1725 zephir_check_call_status();
1726 ZEPHIR_INIT_VAR(&header);
1727 ZEPHIR_CONCAT_SV(&header, "Link: ", &_9$$5);
1728 ZEPHIR_CALL_METHOD(NULL, &response, "setrawheader", NULL, 0, &header);
1729 zephir_check_call_status();
1730 }
1731 RETURN_CCTOR(&href);
1732
1733 }
1734
1735 /**
1736 * Builds a HTML input[type="radio"] tag
1737 *
1738 * @param array parameters = [
1739 * 'class' => '',
1740 * 'name' => '',
1741 * 'src' => '',
1742 * 'id' => '',
1743 * 'value' => ''
1744 * ]
1745 */
PHP_METHOD(Phalcon_Tag,radioField)1746 PHP_METHOD(Phalcon_Tag, radioField) {
1747
1748 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
1749 zend_long ZEPHIR_LAST_CALL_STATUS;
1750 zephir_fcall_cache_entry *_0 = NULL;
1751 zval *parameters, parameters_sub, _1;
1752 zval *this_ptr = getThis();
1753
1754 ZVAL_UNDEF(¶meters_sub);
1755 ZVAL_UNDEF(&_1);
1756
1757 ZEPHIR_MM_GROW();
1758 zephir_fetch_params(1, 1, 0, ¶meters);
1759
1760
1761
1762 ZEPHIR_INIT_VAR(&_1);
1763 ZVAL_STRING(&_1, "radio");
1764 ZEPHIR_RETURN_CALL_SELF("inputfieldchecked", &_0, 0, &_1, parameters);
1765 zephir_check_call_status();
1766 RETURN_MM();
1767
1768 }
1769
1770 /**
1771 * Builds a HTML input[type="range"] tag
1772 *
1773 * @param array parameters = [
1774 * 'class' => '',
1775 * 'name' => '',
1776 * 'src' => '',
1777 * 'id' => '',
1778 * 'value' => ''
1779 * ]
1780 */
PHP_METHOD(Phalcon_Tag,rangeField)1781 PHP_METHOD(Phalcon_Tag, rangeField) {
1782
1783 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
1784 zend_long ZEPHIR_LAST_CALL_STATUS;
1785 zephir_fcall_cache_entry *_0 = NULL;
1786 zval *parameters, parameters_sub, _1;
1787 zval *this_ptr = getThis();
1788
1789 ZVAL_UNDEF(¶meters_sub);
1790 ZVAL_UNDEF(&_1);
1791
1792 ZEPHIR_MM_GROW();
1793 zephir_fetch_params(1, 1, 0, ¶meters);
1794
1795
1796
1797 ZEPHIR_INIT_VAR(&_1);
1798 ZVAL_STRING(&_1, "range");
1799 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters);
1800 zephir_check_call_status();
1801 RETURN_MM();
1802
1803 }
1804
1805 /**
1806 * Renders parameters keeping order in their HTML attributes
1807 *
1808 * @param array attributes = [
1809 * 'rel' => null,
1810 * 'type' => null,
1811 * 'for' => null,
1812 * 'src' => null,
1813 * 'href' => null,
1814 * 'action' => null,
1815 * 'id' => null,
1816 * 'name' => null,
1817 * 'value' => null,
1818 * 'class' => null
1819 * ]
1820 */
PHP_METHOD(Phalcon_Tag,renderAttributes)1821 PHP_METHOD(Phalcon_Tag, renderAttributes) {
1822
1823 zend_bool _13$$11, _14$$12, _21$$16, _22$$17;
1824 zend_string *_3, *_7, *_12;
1825 zend_ulong _2, _6, _11;
1826 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
1827 zephir_fcall_cache_entry *_18 = NULL, *_19 = NULL, *_26 = NULL;
1828 zend_long ZEPHIR_LAST_CALL_STATUS;
1829 zval attributes;
1830 zval *code_param = NULL, *attributes_param = NULL, __$null, order, escaper, attrs, attribute, value, escaped, key, newCode, *_0, _1, *_4, _5, _8, *_9, _10, _20$$12, _15$$13, _16$$13, _17$$13, _27$$17, _23$$18, _24$$18, _25$$18;
1831 zval code;
1832 zval *this_ptr = getThis();
1833
1834 ZVAL_UNDEF(&code);
1835 ZVAL_NULL(&__$null);
1836 ZVAL_UNDEF(&order);
1837 ZVAL_UNDEF(&escaper);
1838 ZVAL_UNDEF(&attrs);
1839 ZVAL_UNDEF(&attribute);
1840 ZVAL_UNDEF(&value);
1841 ZVAL_UNDEF(&escaped);
1842 ZVAL_UNDEF(&key);
1843 ZVAL_UNDEF(&newCode);
1844 ZVAL_UNDEF(&_1);
1845 ZVAL_UNDEF(&_5);
1846 ZVAL_UNDEF(&_8);
1847 ZVAL_UNDEF(&_10);
1848 ZVAL_UNDEF(&_20$$12);
1849 ZVAL_UNDEF(&_15$$13);
1850 ZVAL_UNDEF(&_16$$13);
1851 ZVAL_UNDEF(&_17$$13);
1852 ZVAL_UNDEF(&_27$$17);
1853 ZVAL_UNDEF(&_23$$18);
1854 ZVAL_UNDEF(&_24$$18);
1855 ZVAL_UNDEF(&_25$$18);
1856 ZVAL_UNDEF(&attributes);
1857
1858 ZEPHIR_MM_GROW();
1859 zephir_fetch_params(1, 2, 0, &code_param, &attributes_param);
1860
1861 if (UNEXPECTED(Z_TYPE_P(code_param) != IS_STRING && Z_TYPE_P(code_param) != IS_NULL)) {
1862 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'code' must be of the type string"));
1863 RETURN_MM_NULL();
1864 }
1865 if (EXPECTED(Z_TYPE_P(code_param) == IS_STRING)) {
1866 zephir_get_strval(&code, code_param);
1867 } else {
1868 ZEPHIR_INIT_VAR(&code);
1869 ZVAL_EMPTY_STRING(&code);
1870 }
1871 ZEPHIR_OBS_COPY_OR_DUP(&attributes, attributes_param);
1872
1873
1874 ZEPHIR_INIT_VAR(&order);
1875 zephir_create_array(&order, 10, 0);
1876 zephir_array_update_string(&order, SL("rel"), &__$null, PH_COPY | PH_SEPARATE);
1877 zephir_array_update_string(&order, SL("type"), &__$null, PH_COPY | PH_SEPARATE);
1878 zephir_array_update_string(&order, SL("for"), &__$null, PH_COPY | PH_SEPARATE);
1879 zephir_array_update_string(&order, SL("src"), &__$null, PH_COPY | PH_SEPARATE);
1880 zephir_array_update_string(&order, SL("href"), &__$null, PH_COPY | PH_SEPARATE);
1881 zephir_array_update_string(&order, SL("action"), &__$null, PH_COPY | PH_SEPARATE);
1882 zephir_array_update_string(&order, SL("id"), &__$null, PH_COPY | PH_SEPARATE);
1883 zephir_array_update_string(&order, SL("name"), &__$null, PH_COPY | PH_SEPARATE);
1884 zephir_array_update_string(&order, SL("value"), &__$null, PH_COPY | PH_SEPARATE);
1885 zephir_array_update_string(&order, SL("class"), &__$null, PH_COPY | PH_SEPARATE);
1886 ZEPHIR_INIT_VAR(&attrs);
1887 array_init(&attrs);
1888 zephir_is_iterable(&order, 0, "phalcon/Tag.zep", 904);
1889 if (Z_TYPE_P(&order) == IS_ARRAY) {
1890 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&order), _2, _3, _0)
1891 {
1892 ZEPHIR_INIT_NVAR(&key);
1893 if (_3 != NULL) {
1894 ZVAL_STR_COPY(&key, _3);
1895 } else {
1896 ZVAL_LONG(&key, _2);
1897 }
1898 ZEPHIR_INIT_NVAR(&value);
1899 ZVAL_COPY(&value, _0);
1900 ZEPHIR_OBS_NVAR(&attribute);
1901 if (zephir_array_isset_fetch(&attribute, &attributes, &key, 0)) {
1902 zephir_array_update_zval(&attrs, &key, &attribute, PH_COPY | PH_SEPARATE);
1903 }
1904 } ZEND_HASH_FOREACH_END();
1905 } else {
1906 ZEPHIR_CALL_METHOD(NULL, &order, "rewind", NULL, 0);
1907 zephir_check_call_status();
1908 while (1) {
1909 ZEPHIR_CALL_METHOD(&_1, &order, "valid", NULL, 0);
1910 zephir_check_call_status();
1911 if (!zend_is_true(&_1)) {
1912 break;
1913 }
1914 ZEPHIR_CALL_METHOD(&key, &order, "key", NULL, 0);
1915 zephir_check_call_status();
1916 ZEPHIR_CALL_METHOD(&value, &order, "current", NULL, 0);
1917 zephir_check_call_status();
1918 ZEPHIR_OBS_NVAR(&attribute);
1919 if (zephir_array_isset_fetch(&attribute, &attributes, &key, 0)) {
1920 zephir_array_update_zval(&attrs, &key, &attribute, PH_COPY | PH_SEPARATE);
1921 }
1922 ZEPHIR_CALL_METHOD(NULL, &order, "next", NULL, 0);
1923 zephir_check_call_status();
1924 }
1925 }
1926 ZEPHIR_INIT_NVAR(&value);
1927 ZEPHIR_INIT_NVAR(&key);
1928 zephir_is_iterable(&attributes, 0, "phalcon/Tag.zep", 910);
1929 if (Z_TYPE_P(&attributes) == IS_ARRAY) {
1930 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&attributes), _6, _7, _4)
1931 {
1932 ZEPHIR_INIT_NVAR(&key);
1933 if (_7 != NULL) {
1934 ZVAL_STR_COPY(&key, _7);
1935 } else {
1936 ZVAL_LONG(&key, _6);
1937 }
1938 ZEPHIR_INIT_NVAR(&value);
1939 ZVAL_COPY(&value, _4);
1940 if (!(zephir_array_isset(&attrs, &key))) {
1941 zephir_array_update_zval(&attrs, &key, &value, PH_COPY | PH_SEPARATE);
1942 }
1943 } ZEND_HASH_FOREACH_END();
1944 } else {
1945 ZEPHIR_CALL_METHOD(NULL, &attributes, "rewind", NULL, 0);
1946 zephir_check_call_status();
1947 while (1) {
1948 ZEPHIR_CALL_METHOD(&_5, &attributes, "valid", NULL, 0);
1949 zephir_check_call_status();
1950 if (!zend_is_true(&_5)) {
1951 break;
1952 }
1953 ZEPHIR_CALL_METHOD(&key, &attributes, "key", NULL, 0);
1954 zephir_check_call_status();
1955 ZEPHIR_CALL_METHOD(&value, &attributes, "current", NULL, 0);
1956 zephir_check_call_status();
1957 if (!(zephir_array_isset(&attrs, &key))) {
1958 zephir_array_update_zval(&attrs, &key, &value, PH_COPY | PH_SEPARATE);
1959 }
1960 ZEPHIR_CALL_METHOD(NULL, &attributes, "next", NULL, 0);
1961 zephir_check_call_status();
1962 }
1963 }
1964 ZEPHIR_INIT_NVAR(&value);
1965 ZEPHIR_INIT_NVAR(&key);
1966 ZEPHIR_CALL_SELF(&_8, "getescaper", NULL, 0, &attributes);
1967 zephir_check_call_status();
1968 ZEPHIR_CPY_WRT(&escaper, &_8);
1969 zephir_array_unset_string(&attrs, SL("escape"), PH_SEPARATE);
1970 ZEPHIR_CPY_WRT(&newCode, &code);
1971 zephir_is_iterable(&attrs, 0, "phalcon/Tag.zep", 934);
1972 if (Z_TYPE_P(&attrs) == IS_ARRAY) {
1973 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&attrs), _11, _12, _9)
1974 {
1975 ZEPHIR_INIT_NVAR(&key);
1976 if (_12 != NULL) {
1977 ZVAL_STR_COPY(&key, _12);
1978 } else {
1979 ZVAL_LONG(&key, _11);
1980 }
1981 ZEPHIR_INIT_NVAR(&value);
1982 ZVAL_COPY(&value, _9);
1983 _13$$11 = Z_TYPE_P(&key) == IS_STRING;
1984 if (_13$$11) {
1985 _13$$11 = Z_TYPE_P(&value) != IS_NULL;
1986 }
1987 if (_13$$11) {
1988 _14$$12 = Z_TYPE_P(&value) == IS_ARRAY;
1989 if (!(_14$$12)) {
1990 _14$$12 = Z_TYPE_P(&value) == IS_RESOURCE;
1991 }
1992 if (UNEXPECTED(_14$$12)) {
1993 ZEPHIR_INIT_NVAR(&_15$$13);
1994 object_init_ex(&_15$$13, phalcon_tag_exception_ce);
1995 ZEPHIR_INIT_NVAR(&_16$$13);
1996 zephir_gettype(&_16$$13, &value);
1997 ZEPHIR_INIT_NVAR(&_17$$13);
1998 ZEPHIR_CONCAT_SVSVS(&_17$$13, "Value at index: '", &key, "' type: '", &_16$$13, "' cannot be rendered");
1999 ZEPHIR_CALL_METHOD(NULL, &_15$$13, "__construct", &_18, 8, &_17$$13);
2000 zephir_check_call_status();
2001 zephir_throw_exception_debug(&_15$$13, "phalcon/Tag.zep", 921);
2002 ZEPHIR_MM_RESTORE();
2003 return;
2004 }
2005 if (zephir_is_true(&escaper)) {
2006 ZEPHIR_CALL_METHOD(&escaped, &escaper, "escapehtmlattr", &_19, 0, &value);
2007 zephir_check_call_status();
2008 } else {
2009 ZEPHIR_CPY_WRT(&escaped, &value);
2010 }
2011 ZEPHIR_INIT_NVAR(&_20$$12);
2012 ZEPHIR_CONCAT_SVSVS(&_20$$12, " ", &key, "=\"", &escaped, "\"");
2013 zephir_concat_self(&newCode, &_20$$12);
2014 }
2015 } ZEND_HASH_FOREACH_END();
2016 } else {
2017 ZEPHIR_CALL_METHOD(NULL, &attrs, "rewind", NULL, 0);
2018 zephir_check_call_status();
2019 while (1) {
2020 ZEPHIR_CALL_METHOD(&_10, &attrs, "valid", NULL, 0);
2021 zephir_check_call_status();
2022 if (!zend_is_true(&_10)) {
2023 break;
2024 }
2025 ZEPHIR_CALL_METHOD(&key, &attrs, "key", NULL, 0);
2026 zephir_check_call_status();
2027 ZEPHIR_CALL_METHOD(&value, &attrs, "current", NULL, 0);
2028 zephir_check_call_status();
2029 _21$$16 = Z_TYPE_P(&key) == IS_STRING;
2030 if (_21$$16) {
2031 _21$$16 = Z_TYPE_P(&value) != IS_NULL;
2032 }
2033 if (_21$$16) {
2034 _22$$17 = Z_TYPE_P(&value) == IS_ARRAY;
2035 if (!(_22$$17)) {
2036 _22$$17 = Z_TYPE_P(&value) == IS_RESOURCE;
2037 }
2038 if (UNEXPECTED(_22$$17)) {
2039 ZEPHIR_INIT_NVAR(&_23$$18);
2040 object_init_ex(&_23$$18, phalcon_tag_exception_ce);
2041 ZEPHIR_INIT_NVAR(&_24$$18);
2042 zephir_gettype(&_24$$18, &value);
2043 ZEPHIR_INIT_NVAR(&_25$$18);
2044 ZEPHIR_CONCAT_SVSVS(&_25$$18, "Value at index: '", &key, "' type: '", &_24$$18, "' cannot be rendered");
2045 ZEPHIR_CALL_METHOD(NULL, &_23$$18, "__construct", &_18, 8, &_25$$18);
2046 zephir_check_call_status();
2047 zephir_throw_exception_debug(&_23$$18, "phalcon/Tag.zep", 921);
2048 ZEPHIR_MM_RESTORE();
2049 return;
2050 }
2051 if (zephir_is_true(&escaper)) {
2052 ZEPHIR_CALL_METHOD(&escaped, &escaper, "escapehtmlattr", &_26, 0, &value);
2053 zephir_check_call_status();
2054 } else {
2055 ZEPHIR_CPY_WRT(&escaped, &value);
2056 }
2057 ZEPHIR_INIT_NVAR(&_27$$17);
2058 ZEPHIR_CONCAT_SVSVS(&_27$$17, " ", &key, "=\"", &escaped, "\"");
2059 zephir_concat_self(&newCode, &_27$$17);
2060 }
2061 ZEPHIR_CALL_METHOD(NULL, &attrs, "next", NULL, 0);
2062 zephir_check_call_status();
2063 }
2064 }
2065 ZEPHIR_INIT_NVAR(&value);
2066 ZEPHIR_INIT_NVAR(&key);
2067 RETURN_CCTOR(&newCode);
2068
2069 }
2070
2071 /**
2072 * Renders the title with title tags. The title is automatically escaped
2073 */
PHP_METHOD(Phalcon_Tag,renderTitle)2074 PHP_METHOD(Phalcon_Tag, renderTitle) {
2075
2076 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2077 zend_long ZEPHIR_LAST_CALL_STATUS;
2078 zval *prepend_param = NULL, *append_param = NULL, _0, _1, _2, _3;
2079 zend_bool prepend, append;
2080 zval *this_ptr = getThis();
2081
2082 ZVAL_UNDEF(&_0);
2083 ZVAL_UNDEF(&_1);
2084 ZVAL_UNDEF(&_2);
2085 ZVAL_UNDEF(&_3);
2086
2087 ZEPHIR_MM_GROW();
2088 zephir_fetch_params(1, 0, 2, &prepend_param, &append_param);
2089
2090 if (!prepend_param) {
2091 prepend = 1;
2092 } else {
2093 prepend = zephir_get_boolval(prepend_param);
2094 }
2095 if (!append_param) {
2096 append = 1;
2097 } else {
2098 append = zephir_get_boolval(append_param);
2099 }
2100
2101
2102 if (prepend) {
2103 ZVAL_BOOL(&_1, 1);
2104 } else {
2105 ZVAL_BOOL(&_1, 0);
2106 }
2107 if (append) {
2108 ZVAL_BOOL(&_2, 1);
2109 } else {
2110 ZVAL_BOOL(&_2, 0);
2111 }
2112 ZEPHIR_CALL_SELF(&_0, "gettitle", NULL, 0, &_1, &_2);
2113 zephir_check_call_status();
2114 ZEPHIR_INIT_VAR(&_3);
2115 ZEPHIR_GET_CONSTANT(&_3, "PHP_EOL");
2116 ZEPHIR_CONCAT_SVSV(return_value, "<title>", &_0, "</title>", &_3);
2117 RETURN_MM();
2118
2119 }
2120
2121 /**
2122 * Resets the request and internal values to avoid those fields will have
2123 * any default value.
2124 *
2125 * @deprecated Will be removed in 4.0.0
2126 */
PHP_METHOD(Phalcon_Tag,resetInput)2127 PHP_METHOD(Phalcon_Tag, resetInput) {
2128
2129 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2130 zval __$null, _0, _1, _2;
2131 zval *this_ptr = getThis();
2132
2133 ZVAL_NULL(&__$null);
2134 ZVAL_UNDEF(&_0);
2135 ZVAL_UNDEF(&_1);
2136 ZVAL_UNDEF(&_2);
2137
2138 ZEPHIR_MM_GROW();
2139
2140 ZEPHIR_INIT_VAR(&_0);
2141 array_init(&_0);
2142 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("displayValues"), &_0);
2143 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("documentTitle"), &__$null);
2144 ZEPHIR_INIT_VAR(&_1);
2145 array_init(&_1);
2146 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("documentAppendTitle"), &_1);
2147 ZEPHIR_INIT_VAR(&_2);
2148 array_init(&_2);
2149 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("documentPrependTitle"), &_2);
2150 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("documentTitleSeparator"), &__$null);
2151 ZEPHIR_MM_RESTORE();
2152
2153 }
2154
2155 /**
2156 * Builds a HTML input[type="search"] tag
2157 *
2158 * @param array parameters = [
2159 * 'class' => '',
2160 * 'name' => '',
2161 * 'src' => '',
2162 * 'id' => '',
2163 * 'value' => ''
2164 * ]
2165 */
PHP_METHOD(Phalcon_Tag,searchField)2166 PHP_METHOD(Phalcon_Tag, searchField) {
2167
2168 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2169 zend_long ZEPHIR_LAST_CALL_STATUS;
2170 zephir_fcall_cache_entry *_0 = NULL;
2171 zval *parameters, parameters_sub, _1;
2172 zval *this_ptr = getThis();
2173
2174 ZVAL_UNDEF(¶meters_sub);
2175 ZVAL_UNDEF(&_1);
2176
2177 ZEPHIR_MM_GROW();
2178 zephir_fetch_params(1, 1, 0, ¶meters);
2179
2180
2181
2182 ZEPHIR_INIT_VAR(&_1);
2183 ZVAL_STRING(&_1, "search");
2184 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters);
2185 zephir_check_call_status();
2186 RETURN_MM();
2187
2188 }
2189
2190 /**
2191 * Builds a HTML SELECT tag using a Phalcon\Mvc\Model resultset as options
2192 *
2193 * @param array parameters = [
2194 * 'id' => '',
2195 * 'name' => '',
2196 * 'value' => '',
2197 * 'useEmpty' => false,
2198 * 'emptyValue' => '',
2199 * 'emptyText' => '',
2200 * ]
2201 */
PHP_METHOD(Phalcon_Tag,select)2202 PHP_METHOD(Phalcon_Tag, select) {
2203
2204 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2205 zend_long ZEPHIR_LAST_CALL_STATUS;
2206 zephir_fcall_cache_entry *_0 = NULL;
2207 zval *parameters, parameters_sub, *data = NULL, data_sub, __$null;
2208 zval *this_ptr = getThis();
2209
2210 ZVAL_UNDEF(¶meters_sub);
2211 ZVAL_UNDEF(&data_sub);
2212 ZVAL_NULL(&__$null);
2213
2214 ZEPHIR_MM_GROW();
2215 zephir_fetch_params(1, 1, 1, ¶meters, &data);
2216
2217 if (!data) {
2218 data = &data_sub;
2219 data = &__$null;
2220 }
2221
2222
2223 ZEPHIR_RETURN_CALL_CE_STATIC(phalcon_tag_select_ce, "selectfield", &_0, 0, parameters, data);
2224 zephir_check_call_status();
2225 RETURN_MM();
2226
2227 }
2228
2229 /**
2230 * Builds a HTML SELECT tag using a PHP array for options
2231 *
2232 * @param array parameters = [
2233 * 'id' => '',
2234 * 'name' => '',
2235 * 'value' => '',
2236 * 'useEmpty' => false,
2237 * 'emptyValue' => '',
2238 * 'emptyText' => '',
2239 * ]
2240 */
PHP_METHOD(Phalcon_Tag,selectStatic)2241 PHP_METHOD(Phalcon_Tag, selectStatic) {
2242
2243 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2244 zend_long ZEPHIR_LAST_CALL_STATUS;
2245 zephir_fcall_cache_entry *_0 = NULL;
2246 zval *parameters, parameters_sub, *data = NULL, data_sub, __$null;
2247 zval *this_ptr = getThis();
2248
2249 ZVAL_UNDEF(¶meters_sub);
2250 ZVAL_UNDEF(&data_sub);
2251 ZVAL_NULL(&__$null);
2252
2253 ZEPHIR_MM_GROW();
2254 zephir_fetch_params(1, 1, 1, ¶meters, &data);
2255
2256 if (!data) {
2257 data = &data_sub;
2258 data = &__$null;
2259 }
2260
2261
2262 ZEPHIR_RETURN_CALL_CE_STATIC(phalcon_tag_select_ce, "selectfield", &_0, 0, parameters, data);
2263 zephir_check_call_status();
2264 RETURN_MM();
2265
2266 }
2267
2268 /**
2269 * Set autoescape mode in generated HTML
2270 */
PHP_METHOD(Phalcon_Tag,setAutoescape)2271 PHP_METHOD(Phalcon_Tag, setAutoescape) {
2272
2273 zval *autoescape_param = NULL, _0;
2274 zend_bool autoescape;
2275 zval *this_ptr = getThis();
2276
2277 ZVAL_UNDEF(&_0);
2278
2279 zephir_fetch_params_without_memory_grow(1, 0, &autoescape_param);
2280
2281 autoescape = zephir_get_boolval(autoescape_param);
2282
2283
2284 ZEPHIR_INIT_ZVAL_NREF(_0);
2285 ZVAL_BOOL(&_0, autoescape);
2286 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("autoEscape"), &_0);
2287
2288 }
2289
2290 /**
2291 * Assigns default values to generated tags by helpers
2292 */
PHP_METHOD(Phalcon_Tag,setDefault)2293 PHP_METHOD(Phalcon_Tag, setDefault) {
2294
2295 zend_bool _0$$3;
2296 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2297 zval *id_param = NULL, *value, value_sub;
2298 zval id;
2299 zval *this_ptr = getThis();
2300
2301 ZVAL_UNDEF(&id);
2302 ZVAL_UNDEF(&value_sub);
2303
2304 ZEPHIR_MM_GROW();
2305 zephir_fetch_params(1, 2, 0, &id_param, &value);
2306
2307 if (UNEXPECTED(Z_TYPE_P(id_param) != IS_STRING && Z_TYPE_P(id_param) != IS_NULL)) {
2308 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'id' must be of the type string"));
2309 RETURN_MM_NULL();
2310 }
2311 if (EXPECTED(Z_TYPE_P(id_param) == IS_STRING)) {
2312 zephir_get_strval(&id, id_param);
2313 } else {
2314 ZEPHIR_INIT_VAR(&id);
2315 ZVAL_EMPTY_STRING(&id);
2316 }
2317
2318
2319 if (Z_TYPE_P(value) != IS_NULL) {
2320 _0$$3 = Z_TYPE_P(value) == IS_ARRAY;
2321 if (!(_0$$3)) {
2322 _0$$3 = Z_TYPE_P(value) == IS_OBJECT;
2323 }
2324 if (UNEXPECTED(_0$$3)) {
2325 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_tag_exception_ce, "Only scalar values can be assigned to UI components", "phalcon/Tag.zep", 1027);
2326 return;
2327 }
2328 }
2329 zephir_update_static_property_array_multi_ce(phalcon_tag_ce, SL("displayValues"), value, SL("z"), 1, &id);
2330 ZEPHIR_MM_RESTORE();
2331
2332 }
2333
2334 /**
2335 * Assigns default values to generated tags by helpers
2336 */
PHP_METHOD(Phalcon_Tag,setDefaults)2337 PHP_METHOD(Phalcon_Tag, setDefaults) {
2338
2339 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2340 zend_bool merge, _0;
2341 zval *values_param = NULL, *merge_param = NULL, _1, _2$$3, _3$$3;
2342 zval values;
2343 zval *this_ptr = getThis();
2344
2345 ZVAL_UNDEF(&values);
2346 ZVAL_UNDEF(&_1);
2347 ZVAL_UNDEF(&_2$$3);
2348 ZVAL_UNDEF(&_3$$3);
2349
2350 ZEPHIR_MM_GROW();
2351 zephir_fetch_params(1, 1, 1, &values_param, &merge_param);
2352
2353 ZEPHIR_OBS_COPY_OR_DUP(&values, values_param);
2354 if (!merge_param) {
2355 merge = 0;
2356 } else {
2357 merge = zephir_get_boolval(merge_param);
2358 }
2359
2360
2361 _0 = merge;
2362 if (_0) {
2363 ZEPHIR_OBS_VAR(&_1);
2364 zephir_read_static_property_ce(&_1, phalcon_tag_ce, SL("displayValues"), PH_NOISY_CC);
2365 _0 = Z_TYPE_P(&_1) == IS_ARRAY;
2366 }
2367 if (_0) {
2368 ZEPHIR_INIT_VAR(&_2$$3);
2369 zephir_read_static_property_ce(&_3$$3, phalcon_tag_ce, SL("displayValues"), PH_NOISY_CC | PH_READONLY);
2370 zephir_fast_array_merge(&_2$$3, &_3$$3, &values);
2371 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("displayValues"), &_2$$3);
2372 } else {
2373 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("displayValues"), &values);
2374 }
2375 ZEPHIR_MM_RESTORE();
2376
2377 }
2378
2379 /**
2380 * Sets the dependency injector container.
2381 */
PHP_METHOD(Phalcon_Tag,setDI)2382 PHP_METHOD(Phalcon_Tag, setDI) {
2383
2384 zval *container, container_sub;
2385 zval *this_ptr = getThis();
2386
2387 ZVAL_UNDEF(&container_sub);
2388
2389 zephir_fetch_params_without_memory_grow(1, 0, &container);
2390
2391
2392
2393 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("container"), container);
2394
2395 }
2396
2397 /**
2398 * Set the document type of content
2399 */
PHP_METHOD(Phalcon_Tag,setDocType)2400 PHP_METHOD(Phalcon_Tag, setDocType) {
2401
2402 zend_bool _0;
2403 zval *doctype_param = NULL, _1$$3, _2$$4;
2404 zend_long doctype;
2405 zval *this_ptr = getThis();
2406
2407 ZVAL_UNDEF(&_1$$3);
2408 ZVAL_UNDEF(&_2$$4);
2409
2410 zephir_fetch_params_without_memory_grow(1, 0, &doctype_param);
2411
2412 doctype = zephir_get_intval(doctype_param);
2413
2414
2415 _0 = doctype < 1;
2416 if (!(_0)) {
2417 _0 = doctype > 11;
2418 }
2419 if (_0) {
2420 ZEPHIR_INIT_ZVAL_NREF(_1$$3);
2421 ZVAL_LONG(&_1$$3, 5);
2422 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("documentType"), &_1$$3);
2423 } else {
2424 ZEPHIR_INIT_ZVAL_NREF(_2$$4);
2425 ZVAL_LONG(&_2$$4, doctype);
2426 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("documentType"), &_2$$4);
2427 }
2428
2429 }
2430
2431 /**
2432 * Set the title of view content
2433 */
PHP_METHOD(Phalcon_Tag,setTitle)2434 PHP_METHOD(Phalcon_Tag, setTitle) {
2435
2436 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2437 zval *title_param = NULL;
2438 zval title;
2439 zval *this_ptr = getThis();
2440
2441 ZVAL_UNDEF(&title);
2442
2443 ZEPHIR_MM_GROW();
2444 zephir_fetch_params(1, 1, 0, &title_param);
2445
2446 zephir_get_strval(&title, title_param);
2447
2448
2449 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("documentTitle"), &title);
2450 ZEPHIR_MM_RESTORE();
2451
2452 }
2453
2454 /**
2455 * Set the title separator of view content
2456 */
PHP_METHOD(Phalcon_Tag,setTitleSeparator)2457 PHP_METHOD(Phalcon_Tag, setTitleSeparator) {
2458
2459 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2460 zval *titleSeparator_param = NULL;
2461 zval titleSeparator;
2462 zval *this_ptr = getThis();
2463
2464 ZVAL_UNDEF(&titleSeparator);
2465
2466 ZEPHIR_MM_GROW();
2467 zephir_fetch_params(1, 1, 0, &titleSeparator_param);
2468
2469 zephir_get_strval(&titleSeparator, titleSeparator_param);
2470
2471
2472 zephir_update_static_property_ce(phalcon_tag_ce, ZEND_STRL("documentTitleSeparator"), &titleSeparator);
2473 ZEPHIR_MM_RESTORE();
2474
2475 }
2476
2477 /**
2478 * Builds a LINK[rel="stylesheet"] tag
2479 */
PHP_METHOD(Phalcon_Tag,stylesheetLink)2480 PHP_METHOD(Phalcon_Tag, stylesheetLink) {
2481
2482 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2483 zend_long ZEPHIR_LAST_CALL_STATUS;
2484 zend_bool local;
2485 zval *parameters = NULL, parameters_sub, *local_param = NULL, __$null, params, code, _10, _11, _0$$3, _1$$5, _2$$7, _3$$8, _4$$10, _5$$11, _6$$12, _7$$12, _8$$12, _9$$13, _12$$14, _13$$14, _14$$15, _15$$15;
2486 zval *this_ptr = getThis();
2487
2488 ZVAL_UNDEF(¶meters_sub);
2489 ZVAL_NULL(&__$null);
2490 ZVAL_UNDEF(¶ms);
2491 ZVAL_UNDEF(&code);
2492 ZVAL_UNDEF(&_10);
2493 ZVAL_UNDEF(&_11);
2494 ZVAL_UNDEF(&_0$$3);
2495 ZVAL_UNDEF(&_1$$5);
2496 ZVAL_UNDEF(&_2$$7);
2497 ZVAL_UNDEF(&_3$$8);
2498 ZVAL_UNDEF(&_4$$10);
2499 ZVAL_UNDEF(&_5$$11);
2500 ZVAL_UNDEF(&_6$$12);
2501 ZVAL_UNDEF(&_7$$12);
2502 ZVAL_UNDEF(&_8$$12);
2503 ZVAL_UNDEF(&_9$$13);
2504 ZVAL_UNDEF(&_12$$14);
2505 ZVAL_UNDEF(&_13$$14);
2506 ZVAL_UNDEF(&_14$$15);
2507 ZVAL_UNDEF(&_15$$15);
2508
2509 ZEPHIR_MM_GROW();
2510 zephir_fetch_params(1, 0, 2, ¶meters, &local_param);
2511
2512 if (!parameters) {
2513 parameters = ¶meters_sub;
2514 parameters = &__$null;
2515 }
2516 if (!local_param) {
2517 local = 1;
2518 } else {
2519 local = zephir_get_boolval(local_param);
2520 }
2521
2522
2523 if (Z_TYPE_P(parameters) != IS_ARRAY) {
2524 ZEPHIR_INIT_VAR(¶ms);
2525 zephir_create_array(¶ms, 2, 0);
2526 zephir_array_fast_append(¶ms, parameters);
2527 ZEPHIR_INIT_VAR(&_0$$3);
2528 ZVAL_BOOL(&_0$$3, local);
2529 zephir_array_fast_append(¶ms, &_0$$3);
2530 } else {
2531 ZEPHIR_CPY_WRT(¶ms, parameters);
2532 }
2533 if (zephir_array_isset_long(¶ms, 1)) {
2534 ZEPHIR_OBS_VAR(&_1$$5);
2535 zephir_array_fetch_long(&_1$$5, ¶ms, 1, PH_NOISY, "phalcon/Tag.zep", 1096);
2536 local = zephir_get_boolval(&_1$$5);
2537 } else {
2538 if (zephir_array_isset_string(¶ms, SL("local"))) {
2539 ZEPHIR_OBS_VAR(&_2$$7);
2540 zephir_array_fetch_string(&_2$$7, ¶ms, SL("local"), PH_NOISY, "phalcon/Tag.zep", 1099);
2541 local = zephir_get_boolval(&_2$$7);
2542 zephir_array_unset_string(¶ms, SL("local"), PH_SEPARATE);
2543 }
2544 }
2545 if (!(zephir_array_isset_string(¶ms, SL("type")))) {
2546 ZEPHIR_INIT_VAR(&_3$$8);
2547 ZVAL_STRING(&_3$$8, "text/css");
2548 zephir_array_update_string(¶ms, SL("type"), &_3$$8, PH_COPY | PH_SEPARATE);
2549 }
2550 if (!(zephir_array_isset_string(¶ms, SL("href")))) {
2551 if (zephir_array_isset_long(¶ms, 0)) {
2552 zephir_array_fetch_long(&_4$$10, ¶ms, 0, PH_NOISY | PH_READONLY, "phalcon/Tag.zep", 1111);
2553 zephir_array_update_string(¶ms, SL("href"), &_4$$10, PH_COPY | PH_SEPARATE);
2554 } else {
2555 ZEPHIR_INIT_VAR(&_5$$11);
2556 ZVAL_STRING(&_5$$11, "");
2557 zephir_array_update_string(¶ms, SL("href"), &_5$$11, PH_COPY | PH_SEPARATE);
2558 }
2559 }
2560 if (local) {
2561 ZEPHIR_CALL_SELF(&_6$$12, "geturlservice", NULL, 0);
2562 zephir_check_call_status();
2563 zephir_array_fetch_string(&_8$$12, ¶ms, SL("href"), PH_NOISY | PH_READONLY, "phalcon/Tag.zep", 1123);
2564 ZEPHIR_CALL_METHOD(&_7$$12, &_6$$12, "getstatic", NULL, 0, &_8$$12);
2565 zephir_check_call_status();
2566 zephir_array_update_string(¶ms, SL("href"), &_7$$12, PH_COPY | PH_SEPARATE);
2567 }
2568 if (!(zephir_array_isset_string(¶ms, SL("rel")))) {
2569 ZEPHIR_INIT_VAR(&_9$$13);
2570 ZVAL_STRING(&_9$$13, "stylesheet");
2571 zephir_array_update_string(¶ms, SL("rel"), &_9$$13, PH_COPY | PH_SEPARATE);
2572 }
2573 ZEPHIR_INIT_VAR(&_10);
2574 ZVAL_STRING(&_10, "<link");
2575 ZEPHIR_CALL_SELF(&code, "renderattributes", NULL, 0, &_10, ¶ms);
2576 zephir_check_call_status();
2577 zephir_read_static_property_ce(&_11, phalcon_tag_ce, SL("documentType"), PH_NOISY_CC | PH_READONLY);
2578 if (ZEPHIR_GT_LONG(&_11, 5)) {
2579 ZEPHIR_INIT_VAR(&_12$$14);
2580 ZEPHIR_GET_CONSTANT(&_12$$14, "PHP_EOL");
2581 ZEPHIR_INIT_VAR(&_13$$14);
2582 ZEPHIR_CONCAT_SV(&_13$$14, " />", &_12$$14);
2583 zephir_concat_self(&code, &_13$$14);
2584 } else {
2585 ZEPHIR_INIT_VAR(&_14$$15);
2586 ZEPHIR_GET_CONSTANT(&_14$$15, "PHP_EOL");
2587 ZEPHIR_INIT_VAR(&_15$$15);
2588 ZEPHIR_CONCAT_SV(&_15$$15, ">", &_14$$15);
2589 zephir_concat_self(&code, &_15$$15);
2590 }
2591 RETURN_CCTOR(&code);
2592
2593 }
2594
2595 /**
2596 * Builds a HTML input[type="submit"] tag
2597 */
PHP_METHOD(Phalcon_Tag,submitButton)2598 PHP_METHOD(Phalcon_Tag, submitButton) {
2599
2600 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2601 zend_long ZEPHIR_LAST_CALL_STATUS;
2602 zephir_fcall_cache_entry *_0 = NULL;
2603 zval *parameters, parameters_sub, _1, _2;
2604 zval *this_ptr = getThis();
2605
2606 ZVAL_UNDEF(¶meters_sub);
2607 ZVAL_UNDEF(&_1);
2608 ZVAL_UNDEF(&_2);
2609
2610 ZEPHIR_MM_GROW();
2611 zephir_fetch_params(1, 1, 0, ¶meters);
2612
2613
2614
2615 ZEPHIR_INIT_VAR(&_1);
2616 ZVAL_STRING(&_1, "submit");
2617 ZVAL_BOOL(&_2, 1);
2618 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters, &_2);
2619 zephir_check_call_status();
2620 RETURN_MM();
2621
2622 }
2623
2624 /**
2625 * Builds a HTML tag
2626 */
PHP_METHOD(Phalcon_Tag,tagHtml)2627 PHP_METHOD(Phalcon_Tag, tagHtml) {
2628
2629 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2630 zend_long ZEPHIR_LAST_CALL_STATUS;
2631 zend_bool selfClose, onlyStart, useEol;
2632 zval *tagName_param = NULL, *parameters = NULL, parameters_sub, *selfClose_param = NULL, *onlyStart_param = NULL, *useEol_param = NULL, __$null, params, localCode, _1, _3$$11;
2633 zval tagName, _0, _2$$10;
2634 zval *this_ptr = getThis();
2635
2636 ZVAL_UNDEF(&tagName);
2637 ZVAL_UNDEF(&_0);
2638 ZVAL_UNDEF(&_2$$10);
2639 ZVAL_UNDEF(¶meters_sub);
2640 ZVAL_NULL(&__$null);
2641 ZVAL_UNDEF(¶ms);
2642 ZVAL_UNDEF(&localCode);
2643 ZVAL_UNDEF(&_1);
2644 ZVAL_UNDEF(&_3$$11);
2645
2646 ZEPHIR_MM_GROW();
2647 zephir_fetch_params(1, 1, 4, &tagName_param, ¶meters, &selfClose_param, &onlyStart_param, &useEol_param);
2648
2649 zephir_get_strval(&tagName, tagName_param);
2650 if (!parameters) {
2651 parameters = ¶meters_sub;
2652 parameters = &__$null;
2653 }
2654 if (!selfClose_param) {
2655 selfClose = 0;
2656 } else {
2657 selfClose = zephir_get_boolval(selfClose_param);
2658 }
2659 if (!onlyStart_param) {
2660 onlyStart = 0;
2661 } else {
2662 onlyStart = zephir_get_boolval(onlyStart_param);
2663 }
2664 if (!useEol_param) {
2665 useEol = 0;
2666 } else {
2667 useEol = zephir_get_boolval(useEol_param);
2668 }
2669
2670
2671 if (Z_TYPE_P(parameters) != IS_ARRAY) {
2672 ZEPHIR_INIT_VAR(¶ms);
2673 zephir_create_array(¶ms, 1, 0);
2674 zephir_array_fast_append(¶ms, parameters);
2675 } else {
2676 ZEPHIR_CPY_WRT(¶ms, parameters);
2677 }
2678 ZEPHIR_INIT_VAR(&_0);
2679 ZEPHIR_CONCAT_SV(&_0, "<", &tagName);
2680 ZEPHIR_CALL_SELF(&localCode, "renderattributes", NULL, 0, &_0, ¶ms);
2681 zephir_check_call_status();
2682 zephir_read_static_property_ce(&_1, phalcon_tag_ce, SL("documentType"), PH_NOISY_CC | PH_READONLY);
2683 if (ZEPHIR_GT_LONG(&_1, 5)) {
2684 if (selfClose) {
2685 zephir_concat_self_str(&localCode, SL(" />"));
2686 } else {
2687 zephir_concat_self_str(&localCode, SL(">"));
2688 }
2689 } else {
2690 if (onlyStart) {
2691 zephir_concat_self_str(&localCode, SL(">"));
2692 } else {
2693 ZEPHIR_INIT_VAR(&_2$$10);
2694 ZEPHIR_CONCAT_SVS(&_2$$10, "></", &tagName, ">");
2695 zephir_concat_self(&localCode, &_2$$10);
2696 }
2697 }
2698 if (useEol) {
2699 ZEPHIR_INIT_VAR(&_3$$11);
2700 ZEPHIR_GET_CONSTANT(&_3$$11, "PHP_EOL");
2701 zephir_concat_self(&localCode, &_3$$11);
2702 }
2703 RETURN_CCTOR(&localCode);
2704
2705 }
2706
2707 /**
2708 * Builds a HTML tag closing tag
2709 */
PHP_METHOD(Phalcon_Tag,tagHtmlClose)2710 PHP_METHOD(Phalcon_Tag, tagHtmlClose) {
2711
2712 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2713 zend_bool useEol;
2714 zval *tagName_param = NULL, *useEol_param = NULL, _0$$3;
2715 zval tagName;
2716 zval *this_ptr = getThis();
2717
2718 ZVAL_UNDEF(&tagName);
2719 ZVAL_UNDEF(&_0$$3);
2720
2721 ZEPHIR_MM_GROW();
2722 zephir_fetch_params(1, 1, 1, &tagName_param, &useEol_param);
2723
2724 zephir_get_strval(&tagName, tagName_param);
2725 if (!useEol_param) {
2726 useEol = 0;
2727 } else {
2728 useEol = zephir_get_boolval(useEol_param);
2729 }
2730
2731
2732 if (useEol) {
2733 ZEPHIR_INIT_VAR(&_0$$3);
2734 ZEPHIR_GET_CONSTANT(&_0$$3, "PHP_EOL");
2735 ZEPHIR_CONCAT_SVSV(return_value, "</", &tagName, ">", &_0$$3);
2736 RETURN_MM();
2737 }
2738 ZEPHIR_CONCAT_SVS(return_value, "</", &tagName, ">");
2739 RETURN_MM();
2740
2741 }
2742
2743 /**
2744 * Builds a HTML input[type="tel"] tag
2745 *
2746 * @param array parameters = [
2747 * 'id' => '',
2748 * 'name' => '',
2749 * 'value' => '',
2750 * 'class' => ''
2751 * ]
2752 */
PHP_METHOD(Phalcon_Tag,telField)2753 PHP_METHOD(Phalcon_Tag, telField) {
2754
2755 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2756 zend_long ZEPHIR_LAST_CALL_STATUS;
2757 zephir_fcall_cache_entry *_0 = NULL;
2758 zval *parameters, parameters_sub, _1;
2759 zval *this_ptr = getThis();
2760
2761 ZVAL_UNDEF(¶meters_sub);
2762 ZVAL_UNDEF(&_1);
2763
2764 ZEPHIR_MM_GROW();
2765 zephir_fetch_params(1, 1, 0, ¶meters);
2766
2767
2768
2769 ZEPHIR_INIT_VAR(&_1);
2770 ZVAL_STRING(&_1, "tel");
2771 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters);
2772 zephir_check_call_status();
2773 RETURN_MM();
2774
2775 }
2776
2777 /**
2778 * Builds a HTML TEXTAREA tag
2779 *
2780 * @paraym array parameters = [
2781 * 'id' => '',
2782 * 'name' => '',
2783 * 'value' => '',
2784 * 'class' => ''
2785 * ]
2786 */
PHP_METHOD(Phalcon_Tag,textArea)2787 PHP_METHOD(Phalcon_Tag, textArea) {
2788
2789 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2790 zend_long ZEPHIR_LAST_CALL_STATUS;
2791 zval *parameters, parameters_sub, params, id, name, content, code, _1, _2, _3, _0$$6;
2792 zval *this_ptr = getThis();
2793
2794 ZVAL_UNDEF(¶meters_sub);
2795 ZVAL_UNDEF(¶ms);
2796 ZVAL_UNDEF(&id);
2797 ZVAL_UNDEF(&name);
2798 ZVAL_UNDEF(&content);
2799 ZVAL_UNDEF(&code);
2800 ZVAL_UNDEF(&_1);
2801 ZVAL_UNDEF(&_2);
2802 ZVAL_UNDEF(&_3);
2803 ZVAL_UNDEF(&_0$$6);
2804
2805 ZEPHIR_MM_GROW();
2806 zephir_fetch_params(1, 1, 0, ¶meters);
2807
2808
2809
2810 if (Z_TYPE_P(parameters) != IS_ARRAY) {
2811 ZEPHIR_INIT_VAR(¶ms);
2812 zephir_create_array(¶ms, 1, 0);
2813 zephir_array_fast_append(¶ms, parameters);
2814 } else {
2815 ZEPHIR_CPY_WRT(¶ms, parameters);
2816 }
2817 if (!(zephir_array_isset_long(¶ms, 0))) {
2818 if (zephir_array_isset_string(¶ms, SL("id"))) {
2819 zephir_array_fetch_string(&_0$$6, ¶ms, SL("id"), PH_NOISY | PH_READONLY, "phalcon/Tag.zep", 1246);
2820 zephir_array_update_long(¶ms, 0, &_0$$6, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY);
2821 }
2822 }
2823 ZEPHIR_OBS_VAR(&id);
2824 zephir_array_fetch_long(&id, ¶ms, 0, PH_NOISY, "phalcon/Tag.zep", 1250);
2825 if (!(zephir_array_isset_string(¶ms, SL("name")))) {
2826 zephir_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE);
2827 } else {
2828 ZEPHIR_OBS_VAR(&name);
2829 zephir_array_fetch_string(&name, ¶ms, SL("name"), PH_NOISY, "phalcon/Tag.zep", 1255);
2830 if (ZEPHIR_IS_EMPTY(&name)) {
2831 zephir_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE);
2832 }
2833 }
2834 if (!(zephir_array_isset_string(¶ms, SL("id")))) {
2835 zephir_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE);
2836 }
2837 if (zephir_array_isset_string(¶ms, SL("value"))) {
2838 ZEPHIR_OBS_VAR(&content);
2839 zephir_array_fetch_string(&content, ¶ms, SL("value"), PH_NOISY, "phalcon/Tag.zep", 1267);
2840 zephir_array_unset_string(¶ms, SL("value"), PH_SEPARATE);
2841 } else {
2842 ZEPHIR_CALL_SELF(&content, "getvalue", NULL, 0, &id, ¶ms);
2843 zephir_check_call_status();
2844 }
2845 ZEPHIR_INIT_VAR(&_1);
2846 ZVAL_STRING(&_1, "<textarea");
2847 ZEPHIR_CALL_SELF(&code, "renderattributes", NULL, 0, &_1, ¶ms);
2848 zephir_check_call_status();
2849 ZEPHIR_CALL_FUNCTION(&_2, "htmlspecialchars", NULL, 244, &content);
2850 zephir_check_call_status();
2851 ZEPHIR_INIT_VAR(&_3);
2852 ZEPHIR_CONCAT_SVS(&_3, ">", &_2, "</textarea>");
2853 zephir_concat_self(&code, &_3);
2854 RETURN_CCTOR(&code);
2855
2856 }
2857
2858 /**
2859 * Builds a HTML input[type="text"] tag
2860 *
2861 * @param array parameters = [
2862 * 'id' => '',
2863 * 'name' => '',
2864 * 'value' => '',
2865 * 'class' => ''
2866 * ]
2867 */
PHP_METHOD(Phalcon_Tag,textField)2868 PHP_METHOD(Phalcon_Tag, textField) {
2869
2870 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2871 zend_long ZEPHIR_LAST_CALL_STATUS;
2872 zephir_fcall_cache_entry *_0 = NULL;
2873 zval *parameters, parameters_sub, _1;
2874 zval *this_ptr = getThis();
2875
2876 ZVAL_UNDEF(¶meters_sub);
2877 ZVAL_UNDEF(&_1);
2878
2879 ZEPHIR_MM_GROW();
2880 zephir_fetch_params(1, 1, 0, ¶meters);
2881
2882
2883
2884 ZEPHIR_INIT_VAR(&_1);
2885 ZVAL_STRING(&_1, "text");
2886 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters);
2887 zephir_check_call_status();
2888 RETURN_MM();
2889
2890 }
2891
2892 /**
2893 * Builds a HTML input[type="time"] tag
2894 *
2895 * @param array paramters = [
2896 * 'id' => '',
2897 * 'name' => '',
2898 * 'value' => '',
2899 * 'class' => ''
2900 * ]
2901 */
PHP_METHOD(Phalcon_Tag,timeField)2902 PHP_METHOD(Phalcon_Tag, timeField) {
2903
2904 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2905 zend_long ZEPHIR_LAST_CALL_STATUS;
2906 zephir_fcall_cache_entry *_0 = NULL;
2907 zval *parameters, parameters_sub, _1;
2908 zval *this_ptr = getThis();
2909
2910 ZVAL_UNDEF(¶meters_sub);
2911 ZVAL_UNDEF(&_1);
2912
2913 ZEPHIR_MM_GROW();
2914 zephir_fetch_params(1, 1, 0, ¶meters);
2915
2916
2917
2918 ZEPHIR_INIT_VAR(&_1);
2919 ZVAL_STRING(&_1, "time");
2920 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters);
2921 zephir_check_call_status();
2922 RETURN_MM();
2923
2924 }
2925
2926 /**
2927 * Builds a HTML input[type="url"] tag
2928 *
2929 * @param array paramters = [
2930 * 'id' => '',
2931 * 'name' => '',
2932 * 'value' => '',
2933 * 'class' => ''
2934 * ]
2935 */
PHP_METHOD(Phalcon_Tag,urlField)2936 PHP_METHOD(Phalcon_Tag, urlField) {
2937
2938 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2939 zend_long ZEPHIR_LAST_CALL_STATUS;
2940 zephir_fcall_cache_entry *_0 = NULL;
2941 zval *parameters, parameters_sub, _1;
2942 zval *this_ptr = getThis();
2943
2944 ZVAL_UNDEF(¶meters_sub);
2945 ZVAL_UNDEF(&_1);
2946
2947 ZEPHIR_MM_GROW();
2948 zephir_fetch_params(1, 1, 0, ¶meters);
2949
2950
2951
2952 ZEPHIR_INIT_VAR(&_1);
2953 ZVAL_STRING(&_1, "url");
2954 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters);
2955 zephir_check_call_status();
2956 RETURN_MM();
2957
2958 }
2959
2960 /**
2961 * Builds a HTML input[type="week"] tag
2962 *
2963 * @param array parameters = [
2964 * 'id' => '',
2965 * 'name' => '',
2966 * 'value' => '',
2967 * 'class' => ''
2968 * ]
2969 */
PHP_METHOD(Phalcon_Tag,weekField)2970 PHP_METHOD(Phalcon_Tag, weekField) {
2971
2972 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2973 zend_long ZEPHIR_LAST_CALL_STATUS;
2974 zephir_fcall_cache_entry *_0 = NULL;
2975 zval *parameters, parameters_sub, _1;
2976 zval *this_ptr = getThis();
2977
2978 ZVAL_UNDEF(¶meters_sub);
2979 ZVAL_UNDEF(&_1);
2980
2981 ZEPHIR_MM_GROW();
2982 zephir_fetch_params(1, 1, 0, ¶meters);
2983
2984
2985
2986 ZEPHIR_INIT_VAR(&_1);
2987 ZVAL_STRING(&_1, "week");
2988 ZEPHIR_RETURN_CALL_SELF("inputfield", &_0, 0, &_1, parameters);
2989 zephir_check_call_status();
2990 RETURN_MM();
2991
2992 }
2993
2994 /**
2995 * Builds generic INPUT tags
2996 *
2997 * @param array paramters = [
2998 * 'id' => '',
2999 * 'name' => '',
3000 * 'value' => '',
3001 * 'class' => '',
3002 * 'type' => ''
3003 * ]
3004 */
PHP_METHOD(Phalcon_Tag,inputField)3005 PHP_METHOD(Phalcon_Tag, inputField) {
3006
3007 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
3008 zend_long ZEPHIR_LAST_CALL_STATUS;
3009 zend_bool asValue, _1$$10;
3010 zval *type_param = NULL, *parameters, parameters_sub, *asValue_param = NULL, params, id, value, code, name, _3, _4, _0$$6, _2$$5;
3011 zval type;
3012 zval *this_ptr = getThis();
3013
3014 ZVAL_UNDEF(&type);
3015 ZVAL_UNDEF(¶meters_sub);
3016 ZVAL_UNDEF(¶ms);
3017 ZVAL_UNDEF(&id);
3018 ZVAL_UNDEF(&value);
3019 ZVAL_UNDEF(&code);
3020 ZVAL_UNDEF(&name);
3021 ZVAL_UNDEF(&_3);
3022 ZVAL_UNDEF(&_4);
3023 ZVAL_UNDEF(&_0$$6);
3024 ZVAL_UNDEF(&_2$$5);
3025
3026 ZEPHIR_MM_GROW();
3027 zephir_fetch_params(1, 2, 1, &type_param, ¶meters, &asValue_param);
3028
3029 zephir_get_strval(&type, type_param);
3030 if (!asValue_param) {
3031 asValue = 0;
3032 } else {
3033 asValue = zephir_get_boolval(asValue_param);
3034 }
3035
3036
3037 ZEPHIR_INIT_VAR(¶ms);
3038 array_init(¶ms);
3039 if (Z_TYPE_P(parameters) != IS_ARRAY) {
3040 zephir_array_append(¶ms, parameters, PH_SEPARATE, "phalcon/Tag.zep", 1358);
3041 } else {
3042 ZEPHIR_CPY_WRT(¶ms, parameters);
3043 }
3044 if (asValue == 0) {
3045 ZEPHIR_OBS_VAR(&id);
3046 if (!(zephir_array_isset_long_fetch(&id, ¶ms, 0, 0))) {
3047 zephir_array_fetch_string(&_0$$6, ¶ms, SL("id"), PH_NOISY | PH_READONLY, "phalcon/Tag.zep", 1365);
3048 zephir_array_update_long(¶ms, 0, &_0$$6, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY);
3049 }
3050 ZEPHIR_OBS_VAR(&name);
3051 if (zephir_array_isset_string_fetch(&name, ¶ms, SL("name"), 0)) {
3052 if (ZEPHIR_IS_EMPTY(&name)) {
3053 zephir_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE);
3054 }
3055 } else {
3056 zephir_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE);
3057 }
3058 if (Z_TYPE_P(&id) == IS_STRING) {
3059 _1$$10 = !(zephir_memnstr_str(&id, SL("["), "phalcon/Tag.zep", 1380));
3060 if (_1$$10) {
3061 _1$$10 = !(zephir_array_isset_string(¶ms, SL("id")));
3062 }
3063 if (_1$$10) {
3064 zephir_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE);
3065 }
3066 }
3067 ZEPHIR_CALL_SELF(&_2$$5, "getvalue", NULL, 0, &id, ¶ms);
3068 zephir_check_call_status();
3069 zephir_array_update_string(¶ms, SL("value"), &_2$$5, PH_COPY | PH_SEPARATE);
3070 } else {
3071 if (!(zephir_array_isset_string(¶ms, SL("value")))) {
3072 ZEPHIR_OBS_VAR(&value);
3073 if (zephir_array_isset_long_fetch(&value, ¶ms, 0, 0)) {
3074 zephir_array_update_string(¶ms, SL("value"), &value, PH_COPY | PH_SEPARATE);
3075 }
3076 }
3077 }
3078 zephir_array_update_string(¶ms, SL("type"), &type, PH_COPY | PH_SEPARATE);
3079 ZEPHIR_INIT_VAR(&_3);
3080 ZVAL_STRING(&_3, "<input");
3081 ZEPHIR_CALL_SELF(&code, "renderattributes", NULL, 0, &_3, ¶ms);
3082 zephir_check_call_status();
3083 zephir_read_static_property_ce(&_4, phalcon_tag_ce, SL("documentType"), PH_NOISY_CC | PH_READONLY);
3084 if (ZEPHIR_GT_LONG(&_4, 5)) {
3085 zephir_concat_self_str(&code, SL(" />"));
3086 } else {
3087 zephir_concat_self_str(&code, SL(">"));
3088 }
3089 RETURN_CCTOR(&code);
3090
3091 }
3092
3093 /**
3094 * Builds INPUT tags that implements the checked attribute
3095 */
PHP_METHOD(Phalcon_Tag,inputFieldChecked)3096 PHP_METHOD(Phalcon_Tag, inputFieldChecked) {
3097
3098 zend_bool _3$$11;
3099 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
3100 zend_long ZEPHIR_LAST_CALL_STATUS;
3101 zval *type_param = NULL, *parameters, parameters_sub, params, value, id, code, name, currentValue, _1, _2, _6, _7, _0$$5, _4$$12, _5$$14;
3102 zval type;
3103 zval *this_ptr = getThis();
3104
3105 ZVAL_UNDEF(&type);
3106 ZVAL_UNDEF(¶meters_sub);
3107 ZVAL_UNDEF(¶ms);
3108 ZVAL_UNDEF(&value);
3109 ZVAL_UNDEF(&id);
3110 ZVAL_UNDEF(&code);
3111 ZVAL_UNDEF(&name);
3112 ZVAL_UNDEF(¤tValue);
3113 ZVAL_UNDEF(&_1);
3114 ZVAL_UNDEF(&_2);
3115 ZVAL_UNDEF(&_6);
3116 ZVAL_UNDEF(&_7);
3117 ZVAL_UNDEF(&_0$$5);
3118 ZVAL_UNDEF(&_4$$12);
3119 ZVAL_UNDEF(&_5$$14);
3120
3121 ZEPHIR_MM_GROW();
3122 zephir_fetch_params(1, 2, 0, &type_param, ¶meters);
3123
3124 zephir_get_strval(&type, type_param);
3125
3126
3127 if (Z_TYPE_P(parameters) != IS_ARRAY) {
3128 ZEPHIR_INIT_VAR(¶ms);
3129 zephir_create_array(¶ms, 1, 0);
3130 zephir_array_fast_append(¶ms, parameters);
3131 } else {
3132 ZEPHIR_CPY_WRT(¶ms, parameters);
3133 }
3134 if (!(zephir_array_isset_long(¶ms, 0))) {
3135 zephir_array_fetch_string(&_0$$5, ¶ms, SL("id"), PH_NOISY | PH_READONLY, "phalcon/Tag.zep", 1426);
3136 zephir_array_update_long(¶ms, 0, &_0$$5, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY);
3137 }
3138 ZEPHIR_OBS_VAR(&id);
3139 zephir_array_fetch_long(&id, ¶ms, 0, PH_NOISY, "phalcon/Tag.zep", 1429);
3140 if (!(zephir_array_isset_string(¶ms, SL("name")))) {
3141 zephir_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE);
3142 } else {
3143 ZEPHIR_OBS_VAR(&name);
3144 zephir_array_fetch_string(&name, ¶ms, SL("name"), PH_NOISY, "phalcon/Tag.zep", 1434);
3145 if (ZEPHIR_IS_EMPTY(&name)) {
3146 zephir_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE);
3147 }
3148 }
3149 ZEPHIR_INIT_VAR(&_1);
3150 ZVAL_STRING(&_1, "[");
3151 ZEPHIR_INIT_VAR(&_2);
3152 zephir_fast_strpos(&_2, &id, &_1, 0 );
3153 if (!(zephir_is_true(&_2))) {
3154 if (!(zephir_array_isset_string(¶ms, SL("id")))) {
3155 zephir_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE);
3156 }
3157 }
3158 ZEPHIR_OBS_VAR(¤tValue);
3159 if (zephir_array_isset_string_fetch(¤tValue, ¶ms, SL("value"), 0)) {
3160 zephir_array_unset_string(¶ms, SL("value"), PH_SEPARATE);
3161 ZEPHIR_CALL_SELF(&value, "getvalue", NULL, 0, &id, ¶ms);
3162 zephir_check_call_status();
3163 _3$$11 = Z_TYPE_P(&value) != IS_NULL;
3164 if (_3$$11) {
3165 _3$$11 = ZEPHIR_IS_EQUAL(¤tValue, &value);
3166 }
3167 if (_3$$11) {
3168 ZEPHIR_INIT_VAR(&_4$$12);
3169 ZVAL_STRING(&_4$$12, "checked");
3170 zephir_array_update_string(¶ms, SL("checked"), &_4$$12, PH_COPY | PH_SEPARATE);
3171 }
3172 zephir_array_update_string(¶ms, SL("value"), ¤tValue, PH_COPY | PH_SEPARATE);
3173 } else {
3174 ZEPHIR_CALL_SELF(&value, "getvalue", NULL, 0, &id, ¶ms);
3175 zephir_check_call_status();
3176 if (Z_TYPE_P(&value) != IS_NULL) {
3177 ZEPHIR_INIT_VAR(&_5$$14);
3178 ZVAL_STRING(&_5$$14, "checked");
3179 zephir_array_update_string(¶ms, SL("checked"), &_5$$14, PH_COPY | PH_SEPARATE);
3180 }
3181 zephir_array_update_string(¶ms, SL("value"), &value, PH_COPY | PH_SEPARATE);
3182 }
3183 zephir_array_update_string(¶ms, SL("type"), &type, PH_COPY | PH_SEPARATE);
3184 ZEPHIR_INIT_VAR(&_6);
3185 ZVAL_STRING(&_6, "<input");
3186 ZEPHIR_CALL_SELF(&code, "renderattributes", NULL, 0, &_6, ¶ms);
3187 zephir_check_call_status();
3188 zephir_read_static_property_ce(&_7, phalcon_tag_ce, SL("documentType"), PH_NOISY_CC | PH_READONLY);
3189 if (ZEPHIR_GT_LONG(&_7, 5)) {
3190 zephir_concat_self_str(&code, SL(" />"));
3191 } else {
3192 zephir_concat_self_str(&code, SL(">"));
3193 }
3194 RETURN_CCTOR(&code);
3195
3196 }
3197
3198