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/memory.h"
16 #include "kernel/string.h"
17 #include "ext/spl/spl_exceptions.h"
18 #include "kernel/exception.h"
19 #include "kernel/operators.h"
20 #include "kernel/array.h"
21 #include "kernel/concat.h"
22 #include "kernel/fcall.h"
23 #include "kernel/math.h"
24 #include "kernel/object.h"
25 #include "kernel/main.h"
26
27
28 /**
29 * Phalcon\Text
30 *
31 * Provides utilities to work with texts
32 */
ZEPHIR_INIT_CLASS(Phalcon_Text)33 ZEPHIR_INIT_CLASS(Phalcon_Text) {
34
35 ZEPHIR_REGISTER_CLASS(Phalcon, Text, phalcon, text, phalcon_text_method_entry, ZEND_ACC_EXPLICIT_ABSTRACT_CLASS);
36
37 zend_declare_class_constant_long(phalcon_text_ce, SL("RANDOM_ALNUM"), 0 TSRMLS_CC);
38
39 zend_declare_class_constant_long(phalcon_text_ce, SL("RANDOM_ALPHA"), 1 TSRMLS_CC);
40
41 zend_declare_class_constant_long(phalcon_text_ce, SL("RANDOM_HEXDEC"), 2 TSRMLS_CC);
42
43 zend_declare_class_constant_long(phalcon_text_ce, SL("RANDOM_NUMERIC"), 3 TSRMLS_CC);
44
45 zend_declare_class_constant_long(phalcon_text_ce, SL("RANDOM_NOZERO"), 4 TSRMLS_CC);
46
47 zend_declare_class_constant_long(phalcon_text_ce, SL("RANDOM_DISTINCT"), 5 TSRMLS_CC);
48
49 return SUCCESS;
50
51 }
52
53 /**
54 * Converts strings to camelize style
55 *
56 * <code>
57 * echo Phalcon\Text::camelize("coco_bongo"); // CocoBongo
58 * echo Phalcon\Text::camelize("co_co-bon_go", "-"); // Co_coBon_go
59 * echo Phalcon\Text::camelize("co_co-bon_go", "_-"); // CoCoBonGo
60 * </code>
61 */
PHP_METHOD(Phalcon_Text,camelize)62 PHP_METHOD(Phalcon_Text, camelize) {
63
64 zval *str_param = NULL, *delimiter = NULL, *_0;
65 zval *str = NULL;
66
67 ZEPHIR_MM_GROW();
68 zephir_fetch_params(1, 1, 1, &str_param, &delimiter);
69
70 if (UNEXPECTED(Z_TYPE_P(str_param) != IS_STRING && Z_TYPE_P(str_param) != IS_NULL)) {
71 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'str' must be a string") TSRMLS_CC);
72 RETURN_MM_NULL();
73 }
74 if (EXPECTED(Z_TYPE_P(str_param) == IS_STRING)) {
75 zephir_get_strval(str, str_param);
76 } else {
77 ZEPHIR_INIT_VAR(str);
78 ZVAL_EMPTY_STRING(str);
79 }
80 if (!delimiter) {
81 delimiter = ZEPHIR_GLOBAL(global_null);
82 }
83
84
85 ZEPHIR_INIT_VAR(_0);
86 zephir_camelize(_0, str, delimiter );
87 RETURN_CCTOR(_0);
88
89 }
90
91 /**
92 * Uncamelize strings which are camelized
93 *
94 * <code>
95 * echo Phalcon\Text::uncamelize("CocoBongo"); // coco_bongo
96 * echo Phalcon\Text::uncamelize("CocoBongo", "-"); // coco-bongo
97 * </code>
98 */
PHP_METHOD(Phalcon_Text,uncamelize)99 PHP_METHOD(Phalcon_Text, uncamelize) {
100
101 zval *str_param = NULL, *delimiter = NULL, *_0;
102 zval *str = NULL;
103
104 ZEPHIR_MM_GROW();
105 zephir_fetch_params(1, 1, 1, &str_param, &delimiter);
106
107 if (UNEXPECTED(Z_TYPE_P(str_param) != IS_STRING && Z_TYPE_P(str_param) != IS_NULL)) {
108 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'str' must be a string") TSRMLS_CC);
109 RETURN_MM_NULL();
110 }
111 if (EXPECTED(Z_TYPE_P(str_param) == IS_STRING)) {
112 zephir_get_strval(str, str_param);
113 } else {
114 ZEPHIR_INIT_VAR(str);
115 ZVAL_EMPTY_STRING(str);
116 }
117 if (!delimiter) {
118 delimiter = ZEPHIR_GLOBAL(global_null);
119 }
120
121
122 ZEPHIR_INIT_VAR(_0);
123 zephir_uncamelize(_0, str, delimiter );
124 RETURN_CCTOR(_0);
125
126 }
127
128 /**
129 * Adds a number to a string or increment that number if it already is defined
130 *
131 * <code>
132 * echo Phalcon\Text::increment("a"); // "a_1"
133 * echo Phalcon\Text::increment("a_1"); // "a_2"
134 * </code>
135 */
PHP_METHOD(Phalcon_Text,increment)136 PHP_METHOD(Phalcon_Text, increment) {
137
138 zval *str_param = NULL, *separator_param = NULL, *parts = NULL, *number = NULL, *_0;
139 zval *str = NULL, *separator = NULL;
140
141 ZEPHIR_MM_GROW();
142 zephir_fetch_params(1, 1, 1, &str_param, &separator_param);
143
144 zephir_get_strval(str, str_param);
145 if (!separator_param) {
146 ZEPHIR_INIT_VAR(separator);
147 ZVAL_STRING(separator, "_", 1);
148 } else {
149 zephir_get_strval(separator, separator_param);
150 }
151
152
153 ZEPHIR_INIT_VAR(parts);
154 zephir_fast_explode(parts, separator, str, LONG_MAX TSRMLS_CC);
155 ZEPHIR_OBS_VAR(number);
156 if (zephir_array_isset_long_fetch(&number, parts, 1, 0 TSRMLS_CC)) {
157 ZEPHIR_SEPARATE(number);
158 zephir_increment(number);
159 } else {
160 ZEPHIR_INIT_NVAR(number);
161 ZVAL_LONG(number, 1);
162 }
163 zephir_array_fetch_long(&_0, parts, 0, PH_NOISY | PH_READONLY, "phalcon/text.zep", 89 TSRMLS_CC);
164 ZEPHIR_CONCAT_VVV(return_value, _0, separator, number);
165 RETURN_MM();
166
167 }
168
169 /**
170 * Generates a random string based on the given type. Type is one of the RANDOM_* constants
171 *
172 * <code>
173 * use Phalcon\Text;
174 *
175 * // "aloiwkqz"
176 * echo Text::random(Text::RANDOM_ALNUM);
177 * </code>
178 */
PHP_METHOD(Phalcon_Text,random)179 PHP_METHOD(Phalcon_Text, random) {
180
181 long length;
182 zval *type_param = NULL, *length_param = NULL, *pool = NULL, *str = NULL, _0$$3 = zval_used_for_init, _1$$3 = zval_used_for_init, *_2$$3 = NULL, *_3$$3 = NULL, _4$$4 = zval_used_for_init, _5$$4 = zval_used_for_init, *_6$$4 = NULL, *_7$$4 = NULL, _8$$5, _9$$5, _10$$6, _11$$6, _12$$7, _13$$8 = zval_used_for_init, _14$$8 = zval_used_for_init, *_15$$8 = NULL, *_16$$8 = NULL, *_17$$8 = NULL, *_18$$9, _19$$9 = zval_used_for_init, _20$$9 = zval_used_for_init;
183 zend_long type, ZEPHIR_LAST_CALL_STATUS, end = 0;
184
185 ZEPHIR_MM_GROW();
186 zephir_fetch_params(1, 0, 2, &type_param, &length_param);
187
188 if (!type_param) {
189 type = 0;
190 } else {
191 type = zephir_get_intval(type_param);
192 }
193 if (!length_param) {
194 length = 8;
195 } else {
196 length = zephir_get_intval(length_param);
197 }
198
199
200 ZEPHIR_INIT_VAR(str);
201 ZVAL_STRING(str, "", 1);
202 do {
203 if (type == 1) {
204 ZEPHIR_SINIT_VAR(_0$$3);
205 ZVAL_STRING(&_0$$3, "a", 0);
206 ZEPHIR_SINIT_VAR(_1$$3);
207 ZVAL_STRING(&_1$$3, "z", 0);
208 ZEPHIR_CALL_FUNCTION(&_2$$3, "range", NULL, 460, &_0$$3, &_1$$3);
209 zephir_check_call_status();
210 ZEPHIR_SINIT_NVAR(_0$$3);
211 ZVAL_STRING(&_0$$3, "A", 0);
212 ZEPHIR_SINIT_NVAR(_1$$3);
213 ZVAL_STRING(&_1$$3, "Z", 0);
214 ZEPHIR_CALL_FUNCTION(&_3$$3, "range", NULL, 460, &_0$$3, &_1$$3);
215 zephir_check_call_status();
216 ZEPHIR_INIT_VAR(pool);
217 zephir_fast_array_merge(pool, &(_2$$3), &(_3$$3) TSRMLS_CC);
218 break;
219 }
220 if (type == 2) {
221 ZEPHIR_SINIT_VAR(_4$$4);
222 ZVAL_LONG(&_4$$4, 0);
223 ZEPHIR_SINIT_VAR(_5$$4);
224 ZVAL_LONG(&_5$$4, 9);
225 ZEPHIR_CALL_FUNCTION(&_6$$4, "range", NULL, 460, &_4$$4, &_5$$4);
226 zephir_check_call_status();
227 ZEPHIR_SINIT_NVAR(_4$$4);
228 ZVAL_STRING(&_4$$4, "a", 0);
229 ZEPHIR_SINIT_NVAR(_5$$4);
230 ZVAL_STRING(&_5$$4, "f", 0);
231 ZEPHIR_CALL_FUNCTION(&_7$$4, "range", NULL, 460, &_4$$4, &_5$$4);
232 zephir_check_call_status();
233 ZEPHIR_INIT_NVAR(pool);
234 zephir_fast_array_merge(pool, &(_6$$4), &(_7$$4) TSRMLS_CC);
235 break;
236 }
237 if (type == 3) {
238 ZEPHIR_SINIT_VAR(_8$$5);
239 ZVAL_LONG(&_8$$5, 0);
240 ZEPHIR_SINIT_VAR(_9$$5);
241 ZVAL_LONG(&_9$$5, 9);
242 ZEPHIR_CALL_FUNCTION(&pool, "range", NULL, 460, &_8$$5, &_9$$5);
243 zephir_check_call_status();
244 break;
245 }
246 if (type == 4) {
247 ZEPHIR_SINIT_VAR(_10$$6);
248 ZVAL_LONG(&_10$$6, 1);
249 ZEPHIR_SINIT_VAR(_11$$6);
250 ZVAL_LONG(&_11$$6, 9);
251 ZEPHIR_CALL_FUNCTION(&pool, "range", NULL, 460, &_10$$6, &_11$$6);
252 zephir_check_call_status();
253 break;
254 }
255 if (type == 5) {
256 ZEPHIR_SINIT_VAR(_12$$7);
257 ZVAL_STRING(&_12$$7, "2345679ACDEFHJKLMNPRSTUVWXYZ", 0);
258 ZEPHIR_CALL_FUNCTION(&pool, "str_split", NULL, 76, &_12$$7);
259 zephir_check_call_status();
260 break;
261 }
262 ZEPHIR_SINIT_VAR(_13$$8);
263 ZVAL_LONG(&_13$$8, 0);
264 ZEPHIR_SINIT_VAR(_14$$8);
265 ZVAL_LONG(&_14$$8, 9);
266 ZEPHIR_CALL_FUNCTION(&_15$$8, "range", NULL, 460, &_13$$8, &_14$$8);
267 zephir_check_call_status();
268 ZEPHIR_SINIT_NVAR(_13$$8);
269 ZVAL_STRING(&_13$$8, "a", 0);
270 ZEPHIR_SINIT_NVAR(_14$$8);
271 ZVAL_STRING(&_14$$8, "z", 0);
272 ZEPHIR_CALL_FUNCTION(&_16$$8, "range", NULL, 460, &_13$$8, &_14$$8);
273 zephir_check_call_status();
274 ZEPHIR_SINIT_NVAR(_13$$8);
275 ZVAL_STRING(&_13$$8, "A", 0);
276 ZEPHIR_SINIT_NVAR(_14$$8);
277 ZVAL_STRING(&_14$$8, "Z", 0);
278 ZEPHIR_CALL_FUNCTION(&_17$$8, "range", NULL, 460, &_13$$8, &_14$$8);
279 zephir_check_call_status();
280 ZEPHIR_CALL_FUNCTION(&pool, "array_merge", NULL, 461, _15$$8, _16$$8, _17$$8);
281 zephir_check_call_status();
282 break;
283 } while(0);
284
285 end = (zephir_fast_count_int(pool TSRMLS_CC) - 1);
286 while (1) {
287 if (!(zephir_fast_strlen_ev(str) < length)) {
288 break;
289 }
290 ZEPHIR_SINIT_NVAR(_19$$9);
291 ZVAL_LONG(&_19$$9, 0);
292 ZEPHIR_SINIT_NVAR(_20$$9);
293 ZVAL_LONG(&_20$$9, end);
294 zephir_array_fetch_long(&_18$$9, pool, zephir_mt_rand(zephir_get_intval(&_19$$9), zephir_get_intval(&_20$$9) TSRMLS_CC), PH_NOISY | PH_READONLY, "phalcon/text.zep", 138 TSRMLS_CC);
295 zephir_concat_self(&str, _18$$9 TSRMLS_CC);
296 }
297 RETURN_CCTOR(str);
298
299 }
300
301 /**
302 * Check if a string starts with a given string
303 *
304 * <code>
305 * echo Phalcon\Text::startsWith("Hello", "He"); // true
306 * echo Phalcon\Text::startsWith("Hello", "he", false); // false
307 * echo Phalcon\Text::startsWith("Hello", "he"); // true
308 * </code>
309 */
PHP_METHOD(Phalcon_Text,startsWith)310 PHP_METHOD(Phalcon_Text, startsWith) {
311
312 zend_bool ignoreCase;
313 zval *str_param = NULL, *start_param = NULL, *ignoreCase_param = NULL, _0;
314 zval *str = NULL, *start = NULL;
315
316 ZEPHIR_MM_GROW();
317 zephir_fetch_params(1, 2, 1, &str_param, &start_param, &ignoreCase_param);
318
319 zephir_get_strval(str, str_param);
320 zephir_get_strval(start, start_param);
321 if (!ignoreCase_param) {
322 ignoreCase = 1;
323 } else {
324 ignoreCase = zephir_get_boolval(ignoreCase_param);
325 }
326
327
328 ZEPHIR_SINIT_VAR(_0);
329 ZVAL_BOOL(&_0, (ignoreCase ? 1 : 0));
330 RETURN_MM_BOOL(zephir_start_with(str, start, &_0));
331
332 }
333
334 /**
335 * Check if a string ends with a given string
336 *
337 * <code>
338 * echo Phalcon\Text::endsWith("Hello", "llo"); // true
339 * echo Phalcon\Text::endsWith("Hello", "LLO", false); // false
340 * echo Phalcon\Text::endsWith("Hello", "LLO"); // true
341 * </code>
342 */
PHP_METHOD(Phalcon_Text,endsWith)343 PHP_METHOD(Phalcon_Text, endsWith) {
344
345 zend_bool ignoreCase;
346 zval *str_param = NULL, *end_param = NULL, *ignoreCase_param = NULL, _0;
347 zval *str = NULL, *end = NULL;
348
349 ZEPHIR_MM_GROW();
350 zephir_fetch_params(1, 2, 1, &str_param, &end_param, &ignoreCase_param);
351
352 zephir_get_strval(str, str_param);
353 zephir_get_strval(end, end_param);
354 if (!ignoreCase_param) {
355 ignoreCase = 1;
356 } else {
357 ignoreCase = zephir_get_boolval(ignoreCase_param);
358 }
359
360
361 ZEPHIR_SINIT_VAR(_0);
362 ZVAL_BOOL(&_0, (ignoreCase ? 1 : 0));
363 RETURN_MM_BOOL(zephir_end_with(str, end, &_0));
364
365 }
366
367 /**
368 * Lowercases a string, this function makes use of the mbstring extension if available
369 *
370 * <code>
371 * echo Phalcon\Text::lower("HELLO"); // hello
372 * </code>
373 */
PHP_METHOD(Phalcon_Text,lower)374 PHP_METHOD(Phalcon_Text, lower) {
375
376 zend_long ZEPHIR_LAST_CALL_STATUS;
377 zval *str_param = NULL, *encoding_param = NULL;
378 zval *str = NULL, *encoding = NULL;
379
380 ZEPHIR_MM_GROW();
381 zephir_fetch_params(1, 1, 1, &str_param, &encoding_param);
382
383 if (UNEXPECTED(Z_TYPE_P(str_param) != IS_STRING && Z_TYPE_P(str_param) != IS_NULL)) {
384 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'str' must be a string") TSRMLS_CC);
385 RETURN_MM_NULL();
386 }
387 if (EXPECTED(Z_TYPE_P(str_param) == IS_STRING)) {
388 zephir_get_strval(str, str_param);
389 } else {
390 ZEPHIR_INIT_VAR(str);
391 ZVAL_EMPTY_STRING(str);
392 }
393 if (!encoding_param) {
394 ZEPHIR_INIT_VAR(encoding);
395 ZVAL_STRING(encoding, "UTF-8", 1);
396 } else {
397 if (UNEXPECTED(Z_TYPE_P(encoding_param) != IS_STRING && Z_TYPE_P(encoding_param) != IS_NULL)) {
398 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'encoding' must be a string") TSRMLS_CC);
399 RETURN_MM_NULL();
400 }
401 if (EXPECTED(Z_TYPE_P(encoding_param) == IS_STRING)) {
402 zephir_get_strval(encoding, encoding_param);
403 } else {
404 ZEPHIR_INIT_VAR(encoding);
405 ZVAL_EMPTY_STRING(encoding);
406 }
407 }
408
409
410 if ((zephir_function_exists_ex(SS("mb_strtolower") TSRMLS_CC) == SUCCESS)) {
411 ZEPHIR_RETURN_CALL_FUNCTION("mb_strtolower", NULL, 215, str, encoding);
412 zephir_check_call_status();
413 RETURN_MM();
414 }
415 zephir_fast_strtolower(return_value, str);
416 RETURN_MM();
417
418 }
419
420 /**
421 * Uppercases a string, this function makes use of the mbstring extension if available
422 *
423 * <code>
424 * echo Phalcon\Text::upper("hello"); // HELLO
425 * </code>
426 */
PHP_METHOD(Phalcon_Text,upper)427 PHP_METHOD(Phalcon_Text, upper) {
428
429 zend_long ZEPHIR_LAST_CALL_STATUS;
430 zval *str_param = NULL, *encoding_param = NULL;
431 zval *str = NULL, *encoding = NULL;
432
433 ZEPHIR_MM_GROW();
434 zephir_fetch_params(1, 1, 1, &str_param, &encoding_param);
435
436 if (UNEXPECTED(Z_TYPE_P(str_param) != IS_STRING && Z_TYPE_P(str_param) != IS_NULL)) {
437 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'str' must be a string") TSRMLS_CC);
438 RETURN_MM_NULL();
439 }
440 if (EXPECTED(Z_TYPE_P(str_param) == IS_STRING)) {
441 zephir_get_strval(str, str_param);
442 } else {
443 ZEPHIR_INIT_VAR(str);
444 ZVAL_EMPTY_STRING(str);
445 }
446 if (!encoding_param) {
447 ZEPHIR_INIT_VAR(encoding);
448 ZVAL_STRING(encoding, "UTF-8", 1);
449 } else {
450 if (UNEXPECTED(Z_TYPE_P(encoding_param) != IS_STRING && Z_TYPE_P(encoding_param) != IS_NULL)) {
451 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'encoding' must be a string") TSRMLS_CC);
452 RETURN_MM_NULL();
453 }
454 if (EXPECTED(Z_TYPE_P(encoding_param) == IS_STRING)) {
455 zephir_get_strval(encoding, encoding_param);
456 } else {
457 ZEPHIR_INIT_VAR(encoding);
458 ZVAL_EMPTY_STRING(encoding);
459 }
460 }
461
462
463 if ((zephir_function_exists_ex(SS("mb_strtoupper") TSRMLS_CC) == SUCCESS)) {
464 ZEPHIR_RETURN_CALL_FUNCTION("mb_strtoupper", NULL, 216, str, encoding);
465 zephir_check_call_status();
466 RETURN_MM();
467 }
468 zephir_fast_strtoupper(return_value, str);
469 RETURN_MM();
470
471 }
472
473 /**
474 * Reduces multiple slashes in a string to single slashes
475 *
476 * <code>
477 * echo Phalcon\Text::reduceSlashes("foo//bar/baz"); // foo/bar/baz
478 * echo Phalcon\Text::reduceSlashes("http://foo.bar///baz/buz"); // http://foo.bar/baz/buz
479 * </code>
480 */
PHP_METHOD(Phalcon_Text,reduceSlashes)481 PHP_METHOD(Phalcon_Text, reduceSlashes) {
482
483 zend_long ZEPHIR_LAST_CALL_STATUS;
484 zval *str_param = NULL, *_0, *_1;
485 zval *str = NULL;
486
487 ZEPHIR_MM_GROW();
488 zephir_fetch_params(1, 1, 0, &str_param);
489
490 zephir_get_strval(str, str_param);
491
492
493 ZEPHIR_INIT_VAR(_0);
494 ZVAL_STRING(_0, "#(?<!:)//+#", ZEPHIR_TEMP_PARAM_COPY);
495 ZEPHIR_INIT_VAR(_1);
496 ZVAL_STRING(_1, "/", ZEPHIR_TEMP_PARAM_COPY);
497 ZEPHIR_RETURN_CALL_FUNCTION("preg_replace", NULL, 42, _0, _1, str);
498 zephir_check_temp_parameter(_0);
499 zephir_check_temp_parameter(_1);
500 zephir_check_call_status();
501 RETURN_MM();
502
503 }
504
505 /**
506 * Concatenates strings using the separator only once without duplication in places concatenation
507 *
508 * <code>
509 * $str = Phalcon\Text::concat(
510 * "/",
511 * "/tmp/",
512 * "/folder_1/",
513 * "/folder_2",
514 * "folder_3/"
515 * );
516 *
517 * // /tmp/folder_1/folder_2/folder_3/
518 * echo $str;
519 * </code>
520 *
521 * @param string separator
522 * @param string a
523 * @param string b
524 * @param string ...N
525 */
PHP_METHOD(Phalcon_Text,concat)526 PHP_METHOD(Phalcon_Text, concat) {
527
528 HashTable *_7$$3;
529 HashPosition _6$$3;
530 zval *separator = NULL, *a = NULL, *b = NULL, _0, _1, _2, *c = NULL, *_12, *_13, *_3$$3, _4$$3, *_5$$3 = NULL, **_8$$3, *_9$$4 = NULL, *_10$$4 = NULL, *_11$$4 = NULL;
531 zend_long ZEPHIR_LAST_CALL_STATUS;
532
533 ZEPHIR_MM_GROW();
534
535 ZEPHIR_INIT_VAR(separator);
536 ZEPHIR_SINIT_VAR(_0);
537 ZVAL_LONG(&_0, 0);
538 zephir_get_arg(separator, zephir_get_intval(&_0) TSRMLS_CC);
539 ZEPHIR_INIT_VAR(a);
540 ZEPHIR_SINIT_VAR(_1);
541 ZVAL_LONG(&_1, 1);
542 zephir_get_arg(a, zephir_get_intval(&_1) TSRMLS_CC);
543 ZEPHIR_INIT_VAR(b);
544 ZEPHIR_SINIT_VAR(_2);
545 ZVAL_LONG(&_2, 2);
546 zephir_get_arg(b, zephir_get_intval(&_2) TSRMLS_CC);
547 if (ZEND_NUM_ARGS() > 3) {
548 ZEPHIR_INIT_VAR(_3$$3);
549 zephir_get_args(_3$$3 TSRMLS_CC);
550 ZEPHIR_SINIT_VAR(_4$$3);
551 ZVAL_LONG(&_4$$3, 3);
552 ZEPHIR_CALL_FUNCTION(&_5$$3, "array_slice", NULL, 411, _3$$3, &_4$$3);
553 zephir_check_call_status();
554 zephir_is_iterable(_5$$3, &_7$$3, &_6$$3, 0, 0, "phalcon/text.zep", 262);
555 for (
556 ; zend_hash_get_current_data_ex(_7$$3, (void**) &_8$$3, &_6$$3) == SUCCESS
557 ; zend_hash_move_forward_ex(_7$$3, &_6$$3)
558 ) {
559 ZEPHIR_GET_HVALUE(c, _8$$3);
560 ZEPHIR_INIT_NVAR(_9$$4);
561 zephir_fast_trim(_9$$4, b, separator, ZEPHIR_TRIM_RIGHT TSRMLS_CC);
562 ZEPHIR_INIT_NVAR(_10$$4);
563 zephir_fast_trim(_10$$4, c, separator, ZEPHIR_TRIM_LEFT TSRMLS_CC);
564 ZEPHIR_INIT_LNVAR(_11$$4);
565 ZEPHIR_CONCAT_VVV(_11$$4, _9$$4, separator, _10$$4);
566 ZEPHIR_CPY_WRT(b, _11$$4);
567 }
568 }
569 ZEPHIR_INIT_VAR(_12);
570 zephir_fast_trim(_12, a, separator, ZEPHIR_TRIM_RIGHT TSRMLS_CC);
571 ZEPHIR_INIT_VAR(_13);
572 zephir_fast_trim(_13, b, separator, ZEPHIR_TRIM_LEFT TSRMLS_CC);
573 ZEPHIR_CONCAT_VVV(return_value, _12, separator, _13);
574 RETURN_MM();
575
576 }
577
578 /**
579 * Generates random text in accordance with the template
580 *
581 * <code>
582 * // Hi my name is a Bob
583 * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!");
584 *
585 * // Hi my name is a Jon
586 * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!");
587 *
588 * // Hello my name is a Bob
589 * echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!");
590 *
591 * // Hello my name is a Zyxep
592 * echo Phalcon\Text::dynamic("[Hi/Hello], my name is a [Zyxep/Mark]!", "[", "]", "/");
593 * </code>
594 */
PHP_METHOD(Phalcon_Text,dynamic)595 PHP_METHOD(Phalcon_Text, dynamic) {
596
597 zend_bool _9$$6;
598 HashTable *_7$$5;
599 HashPosition _6$$5;
600 zephir_fcall_cache_entry *_12 = NULL, *_17 = NULL;
601 zend_long ZEPHIR_LAST_CALL_STATUS;
602 zval *text_param = NULL, *leftDelimiter_param = NULL, *rightDelimiter_param = NULL, *separator_param = NULL, *ldS = NULL, *rdS = NULL, *pattern = NULL, *matches = NULL, *match = NULL, *words = NULL, *word = NULL, *sub = NULL, *_0 = NULL, *_1 = NULL, *_4, *_5 = NULL, *_2$$3, **_8$$5, *_10$$6, *_11$$6 = NULL, *_13$$6, *_14$$6 = NULL, *_15$$6 = NULL, *_16$$6 = NULL;
603 zval *text = NULL, *leftDelimiter = NULL, *rightDelimiter = NULL, *separator = NULL, *_3$$3;
604
605 ZEPHIR_MM_GROW();
606 zephir_fetch_params(1, 1, 3, &text_param, &leftDelimiter_param, &rightDelimiter_param, &separator_param);
607
608 if (UNEXPECTED(Z_TYPE_P(text_param) != IS_STRING && Z_TYPE_P(text_param) != IS_NULL)) {
609 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'text' must be a string") TSRMLS_CC);
610 RETURN_MM_NULL();
611 }
612 if (EXPECTED(Z_TYPE_P(text_param) == IS_STRING)) {
613 zephir_get_strval(text, text_param);
614 } else {
615 ZEPHIR_INIT_VAR(text);
616 ZVAL_EMPTY_STRING(text);
617 }
618 if (!leftDelimiter_param) {
619 ZEPHIR_INIT_VAR(leftDelimiter);
620 ZVAL_STRING(leftDelimiter, "{", 1);
621 } else {
622 if (UNEXPECTED(Z_TYPE_P(leftDelimiter_param) != IS_STRING && Z_TYPE_P(leftDelimiter_param) != IS_NULL)) {
623 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'leftDelimiter' must be a string") TSRMLS_CC);
624 RETURN_MM_NULL();
625 }
626 if (EXPECTED(Z_TYPE_P(leftDelimiter_param) == IS_STRING)) {
627 zephir_get_strval(leftDelimiter, leftDelimiter_param);
628 } else {
629 ZEPHIR_INIT_VAR(leftDelimiter);
630 ZVAL_EMPTY_STRING(leftDelimiter);
631 }
632 }
633 if (!rightDelimiter_param) {
634 ZEPHIR_INIT_VAR(rightDelimiter);
635 ZVAL_STRING(rightDelimiter, "}", 1);
636 } else {
637 if (UNEXPECTED(Z_TYPE_P(rightDelimiter_param) != IS_STRING && Z_TYPE_P(rightDelimiter_param) != IS_NULL)) {
638 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'rightDelimiter' must be a string") TSRMLS_CC);
639 RETURN_MM_NULL();
640 }
641 if (EXPECTED(Z_TYPE_P(rightDelimiter_param) == IS_STRING)) {
642 zephir_get_strval(rightDelimiter, rightDelimiter_param);
643 } else {
644 ZEPHIR_INIT_VAR(rightDelimiter);
645 ZVAL_EMPTY_STRING(rightDelimiter);
646 }
647 }
648 if (!separator_param) {
649 ZEPHIR_INIT_VAR(separator);
650 ZVAL_STRING(separator, "|", 1);
651 } else {
652 if (UNEXPECTED(Z_TYPE_P(separator_param) != IS_STRING && Z_TYPE_P(separator_param) != IS_NULL)) {
653 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'separator' must be a string") TSRMLS_CC);
654 RETURN_MM_NULL();
655 }
656 if (EXPECTED(Z_TYPE_P(separator_param) == IS_STRING)) {
657 zephir_get_strval(separator, separator_param);
658 } else {
659 ZEPHIR_INIT_VAR(separator);
660 ZVAL_EMPTY_STRING(separator);
661 }
662 }
663
664
665 ZEPHIR_CALL_FUNCTION(&_0, "substr_count", NULL, 462, text, leftDelimiter);
666 zephir_check_call_status();
667 ZEPHIR_CALL_FUNCTION(&_1, "substr_count", NULL, 462, text, rightDelimiter);
668 zephir_check_call_status();
669 if (!ZEPHIR_IS_IDENTICAL(_0, _1)) {
670 ZEPHIR_INIT_VAR(_2$$3);
671 object_init_ex(_2$$3, spl_ce_RuntimeException);
672 ZEPHIR_INIT_VAR(_3$$3);
673 ZEPHIR_CONCAT_SVS(_3$$3, "Syntax error in string \"", text, "\"");
674 ZEPHIR_CALL_METHOD(NULL, _2$$3, "__construct", NULL, 463, _3$$3);
675 zephir_check_call_status();
676 zephir_throw_exception_debug(_2$$3, "phalcon/text.zep", 289 TSRMLS_CC);
677 ZEPHIR_MM_RESTORE();
678 return;
679 }
680 ZEPHIR_CALL_FUNCTION(&ldS, "preg_quote", NULL, 464, leftDelimiter);
681 zephir_check_call_status();
682 ZEPHIR_CALL_FUNCTION(&rdS, "preg_quote", NULL, 464, rightDelimiter);
683 zephir_check_call_status();
684 ZEPHIR_INIT_VAR(pattern);
685 ZEPHIR_CONCAT_SVSVVSVS(pattern, "/", ldS, "([^", ldS, rdS, "]+)", rdS, "/");
686 ZEPHIR_INIT_VAR(matches);
687 array_init(matches);
688 ZEPHIR_INIT_VAR(_4);
689 ZVAL_LONG(_4, 2);
690 ZEPHIR_MAKE_REF(matches);
691 ZEPHIR_CALL_FUNCTION(&_5, "preg_match_all", NULL, 41, pattern, text, matches, _4);
692 ZEPHIR_UNREF(matches);
693 zephir_check_call_status();
694 if (!(zephir_is_true(_5))) {
695 RETURN_CTOR(text);
696 }
697 if (Z_TYPE_P(matches) == IS_ARRAY) {
698 zephir_is_iterable(matches, &_7$$5, &_6$$5, 0, 0, "phalcon/text.zep", 312);
699 for (
700 ; zend_hash_get_current_data_ex(_7$$5, (void**) &_8$$5, &_6$$5) == SUCCESS
701 ; zend_hash_move_forward_ex(_7$$5, &_6$$5)
702 ) {
703 ZEPHIR_GET_HVALUE(match, _8$$5);
704 _9$$6 = !(zephir_array_isset_long(match, 0));
705 if (!(_9$$6)) {
706 _9$$6 = !(zephir_array_isset_long(match, 1));
707 }
708 if (_9$$6) {
709 continue;
710 }
711 zephir_array_fetch_long(&_10$$6, match, 1, PH_NOISY | PH_READONLY, "phalcon/text.zep", 307 TSRMLS_CC);
712 ZEPHIR_INIT_NVAR(words);
713 zephir_fast_explode(words, separator, _10$$6, LONG_MAX TSRMLS_CC);
714 ZEPHIR_OBS_NVAR(word);
715 ZEPHIR_CALL_FUNCTION(&_11$$6, "array_rand", &_12, 465, words);
716 zephir_check_call_status();
717 zephir_array_fetch(&word, words, _11$$6, PH_NOISY, "phalcon/text.zep", 308 TSRMLS_CC);
718 zephir_array_fetch_long(&_13$$6, match, 0, PH_NOISY | PH_READONLY, "phalcon/text.zep", 309 TSRMLS_CC);
719 ZEPHIR_CALL_FUNCTION(&sub, "preg_quote", NULL, 464, _13$$6, separator);
720 zephir_check_call_status();
721 ZEPHIR_INIT_LNVAR(_14$$6);
722 ZEPHIR_CONCAT_SVS(_14$$6, "/", sub, "/");
723 ZEPHIR_INIT_NVAR(_15$$6);
724 ZVAL_LONG(_15$$6, 1);
725 ZEPHIR_CALL_FUNCTION(&_16$$6, "preg_replace", &_17, 42, _14$$6, word, text, _15$$6);
726 zephir_check_call_status();
727 zephir_get_strval(text, _16$$6);
728 }
729 }
730 RETURN_CTOR(text);
731
732 }
733
734 /**
735 * Makes a phrase underscored instead of spaced
736 *
737 * <code>
738 * echo Phalcon\Text::underscore("look behind"); // "look_behind"
739 * echo Phalcon\Text::underscore("Awesome Phalcon"); // "Awesome_Phalcon"
740 * </code>
741 */
PHP_METHOD(Phalcon_Text,underscore)742 PHP_METHOD(Phalcon_Text, underscore) {
743
744 zend_long ZEPHIR_LAST_CALL_STATUS;
745 zval *text_param = NULL, *_0, *_1, *_2;
746 zval *text = NULL;
747
748 ZEPHIR_MM_GROW();
749 zephir_fetch_params(1, 1, 0, &text_param);
750
751 if (UNEXPECTED(Z_TYPE_P(text_param) != IS_STRING && Z_TYPE_P(text_param) != IS_NULL)) {
752 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'text' must be a string") TSRMLS_CC);
753 RETURN_MM_NULL();
754 }
755 if (EXPECTED(Z_TYPE_P(text_param) == IS_STRING)) {
756 zephir_get_strval(text, text_param);
757 } else {
758 ZEPHIR_INIT_VAR(text);
759 ZVAL_EMPTY_STRING(text);
760 }
761
762
763 ZEPHIR_INIT_VAR(_0);
764 zephir_fast_trim(_0, text, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC);
765 ZEPHIR_INIT_VAR(_1);
766 ZVAL_STRING(_1, "#\\s+#", ZEPHIR_TEMP_PARAM_COPY);
767 ZEPHIR_INIT_VAR(_2);
768 ZVAL_STRING(_2, "_", ZEPHIR_TEMP_PARAM_COPY);
769 ZEPHIR_RETURN_CALL_FUNCTION("preg_replace", NULL, 42, _1, _2, _0);
770 zephir_check_temp_parameter(_1);
771 zephir_check_temp_parameter(_2);
772 zephir_check_call_status();
773 RETURN_MM();
774
775 }
776
777 /**
778 * Makes an underscored or dashed phrase human-readable
779 *
780 * <code>
781 * echo Phalcon\Text::humanize("start-a-horse"); // "start a horse"
782 * echo Phalcon\Text::humanize("five_cats"); // "five cats"
783 * </code>
784 */
PHP_METHOD(Phalcon_Text,humanize)785 PHP_METHOD(Phalcon_Text, humanize) {
786
787 zend_long ZEPHIR_LAST_CALL_STATUS;
788 zval *text_param = NULL, *_0, *_1, *_2;
789 zval *text = NULL;
790
791 ZEPHIR_MM_GROW();
792 zephir_fetch_params(1, 1, 0, &text_param);
793
794 if (UNEXPECTED(Z_TYPE_P(text_param) != IS_STRING && Z_TYPE_P(text_param) != IS_NULL)) {
795 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'text' must be a string") TSRMLS_CC);
796 RETURN_MM_NULL();
797 }
798 if (EXPECTED(Z_TYPE_P(text_param) == IS_STRING)) {
799 zephir_get_strval(text, text_param);
800 } else {
801 ZEPHIR_INIT_VAR(text);
802 ZVAL_EMPTY_STRING(text);
803 }
804
805
806 ZEPHIR_INIT_VAR(_0);
807 zephir_fast_trim(_0, text, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC);
808 ZEPHIR_INIT_VAR(_1);
809 ZVAL_STRING(_1, "#[_-]+#", ZEPHIR_TEMP_PARAM_COPY);
810 ZEPHIR_INIT_VAR(_2);
811 ZVAL_STRING(_2, " ", ZEPHIR_TEMP_PARAM_COPY);
812 ZEPHIR_RETURN_CALL_FUNCTION("preg_replace", NULL, 42, _1, _2, _0);
813 zephir_check_temp_parameter(_1);
814 zephir_check_temp_parameter(_2);
815 zephir_check_call_status();
816 RETURN_MM();
817
818 }
819
820