16 | * @link http://www.smarty.net/manual/en/language.function.counter.php {counter}
17 | * (Smarty online manual)
18 | *
19 | * @param array $params parameters
20 | * @param Smarty_Internal_Template $template template object
21 | *
22 | * @return string|null
23 | */
24 | function smarty_function_counter($params, $template)
25 | {
26 | static $counters = array();
27 |
28 | $name = (isset($params['name'])) ? $params['name'] : 'default';
29 | if (!isset($counters[$name])) {
30 | $counters[$name] = array(
31 | 'start' => 1,
32 | 'skip' => 1,
33 | 'direction' => 'up',
34 | 'count' => 1
35 | );
36 | }
37 | $counter =& $counters[$name];
38 |
39 | if (isset($params['start'])) {
40 | $counter['start'] = $counter['count'] = (int) $params['start'];
41 | }
42 |
43 | if (!empty($params['assign'])) {
44 | $counter['assign'] = $params['assign'];
45 | }
46 |
47 | if (isset($counter['assign'])) {
48 | $template->assign($counter['assign'], $counter['count']);
49 | }
50 |
51 | if (isset($params['print'])) {
52 | $print = (bool) $params['print'];
53 | } else {
54 | $print = empty($counter['assign']);
55 | }
56 |
57 | if ($print) {
58 | $retval = $counter['count'];
59 | } else {
60 | $retval = null;
61 | }
62 |
63 | if (isset($params['skip'])) {
64 | $counter['skip'] = $params['skip'];
65 | }
66 |
67 | if (isset($params['direction'])) {
68 | $counter['direction'] = $params['direction'];
69 | }
70 |
71 | if ($counter['direction'] == "down") {
72 | $counter['count'] -= $counter['skip'];
73 | } else {
74 | $counter['count'] += $counter['skip'];
75 | }
76 |
77 | return $retval;
78 | }
79 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/function.cycle.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: cycle
13 | * Date: May 3, 2002
14 | * Purpose: cycle through given values
15 | * Params:
16 | *
17 | * - name - name of cycle (optional)
18 | * - values - comma separated list of values to cycle, or an array of values to cycle
19 | * (this can be left out for subsequent calls)
20 | * - reset - boolean - resets given var to true
21 | * - print - boolean - print var or not. default is true
22 | * - advance - boolean - whether or not to advance the cycle
23 | * - delimiter - the value delimiter, default is ","
24 | * - assign - boolean, assigns to template var instead of printed.
25 | *
26 | * Examples:
27 | *
28 | * {cycle values="#eeeeee,#d0d0d0d"}
29 | * {cycle name=row values="one,two,three" reset=true}
30 | * {cycle name=row}
31 | *
32 | *
33 | * @link http://www.smarty.net/manual/en/language.function.cycle.php {cycle}
34 | * (Smarty online manual)
35 | * @author Monte Ohrt
36 | * @author credit to Mark Priatel
37 | * @author credit to Gerard
38 | * @author credit to Jason Sweat
39 | * @version 1.3
40 | *
41 | * @param array $params parameters
42 | * @param Smarty_Internal_Template $template template object
43 | *
44 | * @return string|null
45 | */
46 |
47 | function smarty_function_cycle($params, $template)
48 | {
49 | static $cycle_vars;
50 |
51 | $name = (empty($params['name'])) ? 'default' : $params['name'];
52 | $print = (isset($params['print'])) ? (bool) $params['print'] : true;
53 | $advance = (isset($params['advance'])) ? (bool) $params['advance'] : true;
54 | $reset = (isset($params['reset'])) ? (bool) $params['reset'] : false;
55 |
56 | if (!isset($params['values'])) {
57 | if (!isset($cycle_vars[$name]['values'])) {
58 | trigger_error("cycle: missing 'values' parameter");
59 |
60 | return;
61 | }
62 | } else {
63 | if (isset($cycle_vars[$name]['values'])
64 | && $cycle_vars[$name]['values'] != $params['values']
65 | ) {
66 | $cycle_vars[$name]['index'] = 0;
67 | }
68 | $cycle_vars[$name]['values'] = $params['values'];
69 | }
70 |
71 | if (isset($params['delimiter'])) {
72 | $cycle_vars[$name]['delimiter'] = $params['delimiter'];
73 | } elseif (!isset($cycle_vars[$name]['delimiter'])) {
74 | $cycle_vars[$name]['delimiter'] = ',';
75 | }
76 |
77 | if (is_array($cycle_vars[$name]['values'])) {
78 | $cycle_array = $cycle_vars[$name]['values'];
79 | } else {
80 | $cycle_array = explode($cycle_vars[$name]['delimiter'], $cycle_vars[$name]['values']);
81 | }
82 |
83 | if (!isset($cycle_vars[$name]['index']) || $reset) {
84 | $cycle_vars[$name]['index'] = 0;
85 | }
86 |
87 | if (isset($params['assign'])) {
88 | $print = false;
89 | $template->assign($params['assign'], $cycle_array[$cycle_vars[$name]['index']]);
90 | }
91 |
92 | if ($print) {
93 | $retval = $cycle_array[$cycle_vars[$name]['index']];
94 | } else {
95 | $retval = null;
96 | }
97 |
98 | if ($advance) {
99 | if ($cycle_vars[$name]['index'] >= count($cycle_array) - 1) {
100 | $cycle_vars[$name]['index'] = 0;
101 | } else {
102 | $cycle_vars[$name]['index'] ++;
103 | }
104 | }
105 |
106 | return $retval;
107 | }
108 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/function.math.php:
--------------------------------------------------------------------------------
1 |
13 | * Name: math
14 | * Purpose: handle math computations in template
15 | *
16 | * @link http://www.smarty.net/manual/en/language.function.math.php {math}
17 | * (Smarty online manual)
18 | * @author Monte Ohrt
19 | *
20 | * @param array $params parameters
21 | * @param Smarty_Internal_Template $template template object
22 | *
23 | * @return string|null
24 | */
25 | function smarty_function_math($params, $template)
26 | {
27 | static $_allowed_funcs = array(
28 | 'int' => true, 'abs' => true, 'ceil' => true, 'cos' => true, 'exp' => true, 'floor' => true,
29 | 'log' => true, 'log10' => true, 'max' => true, 'min' => true, 'pi' => true, 'pow' => true,
30 | 'rand' => true, 'round' => true, 'sin' => true, 'sqrt' => true, 'srand' => true, 'tan' => true
31 | );
32 | // be sure equation parameter is present
33 | if (empty($params['equation'])) {
34 | trigger_error("math: missing equation parameter", E_USER_WARNING);
35 |
36 | return;
37 | }
38 |
39 | $equation = $params['equation'];
40 |
41 | // make sure parenthesis are balanced
42 | if (substr_count($equation, "(") != substr_count($equation, ")")) {
43 | trigger_error("math: unbalanced parenthesis", E_USER_WARNING);
44 |
45 | return;
46 | }
47 |
48 | // match all vars in equation, make sure all are passed
49 | preg_match_all("!(?:0x[a-fA-F0-9]+)|([a-zA-Z][a-zA-Z0-9_]*)!", $equation, $match);
50 |
51 | foreach ($match[1] as $curr_var) {
52 | if ($curr_var && !isset($params[$curr_var]) && !isset($_allowed_funcs[$curr_var])) {
53 | trigger_error("math: function call $curr_var not allowed", E_USER_WARNING);
54 |
55 | return;
56 | }
57 | }
58 |
59 | foreach ($params as $key => $val) {
60 | if ($key != "equation" && $key != "format" && $key != "assign") {
61 | // make sure value is not empty
62 | if (strlen($val) == 0) {
63 | trigger_error("math: parameter $key is empty", E_USER_WARNING);
64 |
65 | return;
66 | }
67 | if (!is_numeric($val)) {
68 | trigger_error("math: parameter $key: is not numeric", E_USER_WARNING);
69 |
70 | return;
71 | }
72 | $equation = preg_replace("/\b$key\b/", " \$params['$key'] ", $equation);
73 | }
74 | }
75 | $smarty_math_result = null;
76 | eval("\$smarty_math_result = " . $equation . ";");
77 |
78 | if (empty($params['format'])) {
79 | if (empty($params['assign'])) {
80 | return $smarty_math_result;
81 | } else {
82 | $template->assign($params['assign'], $smarty_math_result);
83 | }
84 | } else {
85 | if (empty($params['assign'])) {
86 | printf($params['format'], $smarty_math_result);
87 | } else {
88 | $template->assign($params['assign'], sprintf($params['format'], $smarty_math_result));
89 | }
90 | }
91 | }
92 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifier.capitalize.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: capitalize
13 | * Purpose: capitalize words in the string
14 | * {@internal {$string|capitalize:true:true} is the fastest option for MBString enabled systems }}
15 | *
16 | * @param string $string string to capitalize
17 | * @param boolean $uc_digits also capitalize "x123" to "X123"
18 | * @param boolean $lc_rest capitalize first letters, lowercase all following letters "aAa" to "Aaa"
19 | *
20 | * @return string capitalized string
21 | * @author Monte Ohrt
22 | * @author Rodney Rehm
23 | */
24 | function smarty_modifier_capitalize($string, $uc_digits = false, $lc_rest = false)
25 | {
26 | if (Smarty::$_MBSTRING) {
27 | if ($lc_rest) {
28 | // uppercase (including hyphenated words)
29 | $upper_string = mb_convert_case($string, MB_CASE_TITLE, Smarty::$_CHARSET);
30 | } else {
31 | // uppercase word breaks
32 | $upper_string = preg_replace_callback("!(^|[^\p{L}'])([\p{Ll}])!S" . Smarty::$_UTF8_MODIFIER, 'smarty_mod_cap_mbconvert_cb', $string);
33 | }
34 | // check uc_digits case
35 | if (!$uc_digits) {
36 | if (preg_match_all("!\b([\p{L}]*[\p{N}]+[\p{L}]*)\b!" . Smarty::$_UTF8_MODIFIER, $string, $matches, PREG_OFFSET_CAPTURE)) {
37 | foreach ($matches[1] as $match) {
38 | $upper_string = substr_replace($upper_string, mb_strtolower($match[0], Smarty::$_CHARSET), $match[1], strlen($match[0]));
39 | }
40 | }
41 | }
42 | $upper_string = preg_replace_callback("!((^|\s)['\"])(\w)!" . Smarty::$_UTF8_MODIFIER, 'smarty_mod_cap_mbconvert2_cb', $upper_string);
43 | return $upper_string;
44 | }
45 |
46 | // lowercase first
47 | if ($lc_rest) {
48 | $string = strtolower($string);
49 | }
50 | // uppercase (including hyphenated words)
51 | $upper_string = preg_replace_callback("!(^|[^\p{L}'])([\p{Ll}])!S" . Smarty::$_UTF8_MODIFIER, 'smarty_mod_cap_ucfirst_cb', $string);
52 | // check uc_digits case
53 | if (!$uc_digits) {
54 | if (preg_match_all("!\b([\p{L}]*[\p{N}]+[\p{L}]*)\b!" . Smarty::$_UTF8_MODIFIER, $string, $matches, PREG_OFFSET_CAPTURE)) {
55 | foreach ($matches[1] as $match) {
56 | $upper_string = substr_replace($upper_string, strtolower($match[0]), $match[1], strlen($match[0]));
57 | }
58 | }
59 | }
60 | $upper_string = preg_replace_callback("!((^|\s)['\"])(\w)!" . Smarty::$_UTF8_MODIFIER, 'smarty_mod_cap_ucfirst2_cb', $upper_string);
61 | return $upper_string;
62 | }
63 |
64 | /*
65 | *
66 | * Bug: create_function() use exhausts memory when used in long loops
67 | * Fix: use declared functions for callbacks instead of using create_function()
68 | * Note: This can be fixed using anonymous functions instead, but that requires PHP >= 5.3
69 | *
70 | * @author Kyle Renfrow
71 | */
72 | function smarty_mod_cap_mbconvert_cb($matches)
73 | {
74 | return stripslashes($matches[1]) . mb_convert_case(stripslashes($matches[2]), MB_CASE_UPPER, Smarty::$_CHARSET);
75 | }
76 |
77 | function smarty_mod_cap_mbconvert2_cb($matches)
78 | {
79 | return stripslashes($matches[1]) . mb_convert_case(stripslashes($matches[3]), MB_CASE_UPPER, Smarty::$_CHARSET);
80 | }
81 |
82 | function smarty_mod_cap_ucfirst_cb($matches)
83 | {
84 | return stripslashes($matches[1]) . ucfirst(stripslashes($matches[2]));
85 | }
86 |
87 | function smarty_mod_cap_ucfirst2_cb($matches)
88 | {
89 | return stripslashes($matches[1]) . ucfirst(stripslashes($matches[3]));
90 | }
91 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifier.date_format.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: date_format
13 | * Purpose: format datestamps via strftime
14 | * Input:
15 | * - string: input date string
16 | * - format: strftime format for output
17 | * - default_date: default date if $string is empty
18 | *
19 | * @link http://www.smarty.net/manual/en/language.modifier.date.format.php date_format (Smarty online manual)
20 | * @author Monte Ohrt
21 | *
22 | * @param string $string input date string
23 | * @param string $format strftime format for output
24 | * @param string $default_date default date if $string is empty
25 | * @param string $formatter either 'strftime' or 'auto'
26 | *
27 | * @return string |void
28 | * @uses smarty_make_timestamp()
29 | */
30 | function smarty_modifier_date_format($string, $format = null, $default_date = '', $formatter = 'auto')
31 | {
32 | if ($format === null) {
33 | $format = Smarty::$_DATE_FORMAT;
34 | }
35 | /**
36 | * Include the {@link shared.make_timestamp.php} plugin
37 | */
38 | require_once(SMARTY_PLUGINS_DIR . 'shared.make_timestamp.php');
39 | if ($string != '' && $string != '0000-00-00' && $string != '0000-00-00 00:00:00') {
40 | $timestamp = smarty_make_timestamp($string);
41 | } elseif ($default_date != '') {
42 | $timestamp = smarty_make_timestamp($default_date);
43 | } else {
44 | return;
45 | }
46 | if ($formatter == 'strftime' || ($formatter == 'auto' && strpos($format, '%') !== false)) {
47 | if (DS == '\\') {
48 | $_win_from = array('%D', '%h', '%n', '%r', '%R', '%t', '%T');
49 | $_win_to = array('%m/%d/%y', '%b', "\n", '%I:%M:%S %p', '%H:%M', "\t", '%H:%M:%S');
50 | if (strpos($format, '%e') !== false) {
51 | $_win_from[] = '%e';
52 | $_win_to[] = sprintf('%\' 2d', date('j', $timestamp));
53 | }
54 | if (strpos($format, '%l') !== false) {
55 | $_win_from[] = '%l';
56 | $_win_to[] = sprintf('%\' 2d', date('h', $timestamp));
57 | }
58 | $format = str_replace($_win_from, $_win_to, $format);
59 | }
60 |
61 | return strftime($format, $timestamp);
62 | } else {
63 | return date($format, $timestamp);
64 | }
65 | }
66 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifier.debug_print_var.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: debug_print_var
13 | * Purpose: formats variable contents for display in the console
14 | *
15 | * @author Monte Ohrt
16 | *
17 | * @param array|object $var variable to be formatted
18 | * @param integer $depth maximum recursion depth if $var is an array
19 | * @param integer $length maximum string length if $var is a string
20 | *
21 | * @return string
22 | */
23 | function smarty_modifier_debug_print_var($var, $depth = 0, $length = 40)
24 | {
25 | $_replace = array("\n" => '\n',
26 | "\r" => '\r',
27 | "\t" => '\t'
28 | );
29 |
30 | switch (gettype($var)) {
31 | case 'array' :
32 | $results = 'Array (' . count($var) . ')';
33 | foreach ($var as $curr_key => $curr_val) {
34 | $results .= '
' . str_repeat(' ', $depth * 2)
35 | . '' . strtr($curr_key, $_replace) . ' => '
36 | . smarty_modifier_debug_print_var($curr_val, ++$depth, $length);
37 | $depth --;
38 | }
39 | break;
40 |
41 | case 'object' :
42 | $object_vars = get_object_vars($var);
43 | $results = '' . get_class($var) . ' Object (' . count($object_vars) . ')';
44 | foreach ($object_vars as $curr_key => $curr_val) {
45 | $results .= '
' . str_repeat(' ', $depth * 2)
46 | . ' ->' . strtr($curr_key, $_replace) . ' = '
47 | . smarty_modifier_debug_print_var($curr_val, ++$depth, $length);
48 | $depth --;
49 | }
50 | break;
51 |
52 | case 'boolean' :
53 | case 'NULL' :
54 | case 'resource' :
55 | if (true === $var) {
56 | $results = 'true';
57 | } elseif (false === $var) {
58 | $results = 'false';
59 | } elseif (null === $var) {
60 | $results = 'null';
61 | } else {
62 | $results = htmlspecialchars((string) $var);
63 | }
64 | $results = '' . $results . '';
65 | break;
66 |
67 | case 'integer' :
68 | case 'float' :
69 | $results = htmlspecialchars((string) $var);
70 | break;
71 |
72 | case 'string' :
73 | $results = strtr($var, $_replace);
74 | if (Smarty::$_MBSTRING) {
75 | if (mb_strlen($var, Smarty::$_CHARSET) > $length) {
76 | $results = mb_substr($var, 0, $length - 3, Smarty::$_CHARSET) . '...';
77 | }
78 | } else {
79 | if (isset($var[$length])) {
80 | $results = substr($var, 0, $length - 3) . '...';
81 | }
82 | }
83 |
84 | $results = htmlspecialchars('"' . $results . '"');
85 | break;
86 |
87 | case 'unknown type' :
88 | default :
89 | $results = strtr((string) $var, $_replace);
90 | if (Smarty::$_MBSTRING) {
91 | if (mb_strlen($results, Smarty::$_CHARSET) > $length) {
92 | $results = mb_substr($results, 0, $length - 3, Smarty::$_CHARSET) . '...';
93 | }
94 | } else {
95 | if (strlen($results) > $length) {
96 | $results = substr($results, 0, $length - 3) . '...';
97 | }
98 | }
99 |
100 | $results = htmlspecialchars($results);
101 | }
102 |
103 | return $results;
104 | }
105 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifier.regex_replace.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: regex_replace
13 | * Purpose: regular expression search/replace
14 | *
15 | * @link http://smarty.php.net/manual/en/language.modifier.regex.replace.php
16 | * regex_replace (Smarty online manual)
17 | * @author Monte Ohrt
18 | *
19 | * @param string $string input string
20 | * @param string|array $search regular expression(s) to search for
21 | * @param string|array $replace string(s) that should be replaced
22 | *
23 | * @return string
24 | */
25 | function smarty_modifier_regex_replace($string, $search, $replace)
26 | {
27 | if (is_array($search)) {
28 | foreach ($search as $idx => $s) {
29 | $search[$idx] = _smarty_regex_replace_check($s);
30 | }
31 | } else {
32 | $search = _smarty_regex_replace_check($search);
33 | }
34 |
35 | return preg_replace($search, $replace, $string);
36 | }
37 |
38 | /**
39 | * @param string $search string(s) that should be replaced
40 | *
41 | * @return string
42 | * @ignore
43 | */
44 | function _smarty_regex_replace_check($search)
45 | {
46 | // null-byte injection detection
47 | // anything behind the first null-byte is ignored
48 | if (($pos = strpos($search, "\0")) !== false) {
49 | $search = substr($search, 0, $pos);
50 | }
51 | // remove eval-modifier from $search
52 | if (preg_match('!([a-zA-Z\s]+)$!s', $search, $match) && (strpos($match[1], 'e') !== false)) {
53 | $search = substr($search, 0, - strlen($match[1])) . preg_replace('![e\s]+!', '', $match[1]);
54 | }
55 |
56 | return $search;
57 | }
58 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifier.replace.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: replace
13 | * Purpose: simple search/replace
14 | *
15 | * @link http://smarty.php.net/manual/en/language.modifier.replace.php replace (Smarty online manual)
16 | * @author Monte Ohrt
17 | * @author Uwe Tews
18 | *
19 | * @param string $string input string
20 | * @param string $search text to search for
21 | * @param string $replace replacement text
22 | *
23 | * @return string
24 | */
25 | function smarty_modifier_replace($string, $search, $replace)
26 | {
27 | if (Smarty::$_MBSTRING) {
28 | require_once(SMARTY_PLUGINS_DIR . 'shared.mb_str_replace.php');
29 |
30 | return smarty_mb_str_replace($search, $replace, $string);
31 | }
32 |
33 | return str_replace($search, $replace, $string);
34 | }
35 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifier.spacify.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: spacify
13 | * Purpose: add spaces between characters in a string
14 | *
15 | * @link http://smarty.php.net/manual/en/language.modifier.spacify.php spacify (Smarty online manual)
16 | * @author Monte Ohrt
17 | *
18 | * @param string $string input string
19 | * @param string $spacify_char string to insert between characters.
20 | *
21 | * @return string
22 | */
23 | function smarty_modifier_spacify($string, $spacify_char = ' ')
24 | {
25 | // well… what about charsets besides latin and UTF-8?
26 | return implode($spacify_char, preg_split('//' . Smarty::$_UTF8_MODIFIER, $string, - 1, PREG_SPLIT_NO_EMPTY));
27 | }
28 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifier.truncate.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: truncate
13 | * Purpose: Truncate a string to a certain length if necessary,
14 | * optionally splitting in the middle of a word, and
15 | * appending the $etc string or inserting $etc into the middle.
16 | *
17 | * @link http://smarty.php.net/manual/en/language.modifier.truncate.php truncate (Smarty online manual)
18 | * @author Monte Ohrt
19 | *
20 | * @param string $string input string
21 | * @param integer $length length of truncated text
22 | * @param string $etc end string
23 | * @param boolean $break_words truncate at word boundary
24 | * @param boolean $middle truncate in the middle of text
25 | *
26 | * @return string truncated string
27 | */
28 | function smarty_modifier_truncate($string, $length = 80, $etc = '...', $break_words = false, $middle = false)
29 | {
30 | if ($length == 0) {
31 | return '';
32 | }
33 |
34 | if (Smarty::$_MBSTRING) {
35 | if (mb_strlen($string, Smarty::$_CHARSET) > $length) {
36 | $length -= min($length, mb_strlen($etc, Smarty::$_CHARSET));
37 | if (!$break_words && !$middle) {
38 | $string = preg_replace('/\s+?(\S+)?$/' . Smarty::$_UTF8_MODIFIER, '', mb_substr($string, 0, $length + 1, Smarty::$_CHARSET));
39 | }
40 | if (!$middle) {
41 | return mb_substr($string, 0, $length, Smarty::$_CHARSET) . $etc;
42 | }
43 |
44 | return mb_substr($string, 0, $length / 2, Smarty::$_CHARSET) . $etc . mb_substr($string, - $length / 2, $length, Smarty::$_CHARSET);
45 | }
46 |
47 | return $string;
48 | }
49 |
50 | // no MBString fallback
51 | if (isset($string[$length])) {
52 | $length -= min($length, strlen($etc));
53 | if (!$break_words && !$middle) {
54 | $string = preg_replace('/\s+?(\S+)?$/', '', substr($string, 0, $length + 1));
55 | }
56 | if (!$middle) {
57 | return substr($string, 0, $length) . $etc;
58 | }
59 |
60 | return substr($string, 0, $length / 2) . $etc . substr($string, - $length / 2);
61 | }
62 |
63 | return $string;
64 | }
65 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifiercompiler.cat.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: cat
13 | * Date: Feb 24, 2003
14 | * Purpose: catenate a value to a variable
15 | * Input: string to catenate
16 | * Example: {$var|cat:"foo"}
17 | *
18 | * @link http://smarty.php.net/manual/en/language.modifier.cat.php cat
19 | * (Smarty online manual)
20 | * @author Uwe Tews
21 | *
22 | * @param array $params parameters
23 | *
24 | * @return string with compiled code
25 | */
26 | function smarty_modifiercompiler_cat($params)
27 | {
28 | return '(' . implode(').(', $params) . ')';
29 | }
30 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifiercompiler.count_characters.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: count_characteres
13 | * Purpose: count the number of characters in a text
14 | *
15 | * @link http://www.smarty.net/manual/en/language.modifier.count.characters.php count_characters (Smarty online manual)
16 | * @author Uwe Tews
17 | *
18 | * @param array $params parameters
19 | *
20 | * @return string with compiled code
21 | */
22 | function smarty_modifiercompiler_count_characters($params)
23 | {
24 | if (!isset($params[1]) || $params[1] != 'true') {
25 | return 'preg_match_all(\'/[^\s]/' . Smarty::$_UTF8_MODIFIER . '\',' . $params[0] . ', $tmp)';
26 | }
27 | if (Smarty::$_MBSTRING) {
28 | return 'mb_strlen(' . $params[0] . ', \'' . addslashes(Smarty::$_CHARSET) . '\')';
29 | }
30 | // no MBString fallback
31 | return 'strlen(' . $params[0] . ')';
32 | }
33 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifiercompiler.count_paragraphs.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: count_paragraphs
13 | * Purpose: count the number of paragraphs in a text
14 | *
15 | * @link http://www.smarty.net/manual/en/language.modifier.count.paragraphs.php
16 | * count_paragraphs (Smarty online manual)
17 | * @author Uwe Tews
18 | *
19 | * @param array $params parameters
20 | *
21 | * @return string with compiled code
22 | */
23 | function smarty_modifiercompiler_count_paragraphs($params)
24 | {
25 | // count \r or \n characters
26 | return '(preg_match_all(\'#[\r\n]+#\', ' . $params[0] . ', $tmp)+1)';
27 | }
28 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifiercompiler.count_sentences.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: count_sentences
13 | * Purpose: count the number of sentences in a text
14 | *
15 | * @link http://www.smarty.net/manual/en/language.modifier.count.paragraphs.php
16 | * count_sentences (Smarty online manual)
17 | * @author Uwe Tews
18 | *
19 | * @param array $params parameters
20 | *
21 | * @return string with compiled code
22 | */
23 | function smarty_modifiercompiler_count_sentences($params)
24 | {
25 | // find periods, question marks, exclamation marks with a word before but not after.
26 | return 'preg_match_all("#\w[\.\?\!](\W|$)#S' . Smarty::$_UTF8_MODIFIER . '", ' . $params[0] . ', $tmp)';
27 | }
28 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifiercompiler.count_words.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: count_words
13 | * Purpose: count the number of words in a text
14 | *
15 | * @link http://www.smarty.net/manual/en/language.modifier.count.words.php count_words (Smarty online manual)
16 | * @author Uwe Tews
17 | *
18 | * @param array $params parameters
19 | *
20 | * @return string with compiled code
21 | */
22 | function smarty_modifiercompiler_count_words($params)
23 | {
24 | if (Smarty::$_MBSTRING) {
25 | // return 'preg_match_all(\'#[\w\pL]+#' . Smarty::$_UTF8_MODIFIER . '\', ' . $params[0] . ', $tmp)';
26 | // expression taken from http://de.php.net/manual/en/function.str-word-count.php#85592
27 | return 'preg_match_all(\'/\p{L}[\p{L}\p{Mn}\p{Pd}\\\'\x{2019}]*/' . Smarty::$_UTF8_MODIFIER . '\', ' . $params[0] . ', $tmp)';
28 | }
29 | // no MBString fallback
30 | return 'str_word_count(' . $params[0] . ')';
31 | }
32 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifiercompiler.default.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: default
13 | * Purpose: designate default value for empty variables
14 | *
15 | * @link http://www.smarty.net/manual/en/language.modifier.default.php default (Smarty online manual)
16 | * @author Uwe Tews
17 | *
18 | * @param array $params parameters
19 | *
20 | * @return string with compiled code
21 | */
22 | function smarty_modifiercompiler_default($params)
23 | {
24 | $output = $params[0];
25 | if (!isset($params[1])) {
26 | $params[1] = "''";
27 | }
28 |
29 | array_shift($params);
30 | foreach ($params as $param) {
31 | $output = '(($tmp = @' . $output . ')===null||$tmp===\'\' ? ' . $param . ' : $tmp)';
32 | }
33 |
34 | return $output;
35 | }
36 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifiercompiler.from_charset.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: from_charset
13 | * Purpose: convert character encoding from $charset to internal encoding
14 | *
15 | * @author Rodney Rehm
16 | *
17 | * @param array $params parameters
18 | *
19 | * @return string with compiled code
20 | */
21 | function smarty_modifiercompiler_from_charset($params)
22 | {
23 | if (!Smarty::$_MBSTRING) {
24 | // FIXME: (rodneyrehm) shouldn't this throw an error?
25 | return $params[0];
26 | }
27 |
28 | if (!isset($params[1])) {
29 | $params[1] = '"ISO-8859-1"';
30 | }
31 |
32 | return 'mb_convert_encoding(' . $params[0] . ', "' . addslashes(Smarty::$_CHARSET) . '", ' . $params[1] . ')';
33 | }
34 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifiercompiler.indent.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: indent
13 | * Purpose: indent lines of text
14 | *
15 | * @link http://www.smarty.net/manual/en/language.modifier.indent.php indent (Smarty online manual)
16 | * @author Uwe Tews
17 | *
18 | * @param array $params parameters
19 | *
20 | * @return string with compiled code
21 | */
22 |
23 | function smarty_modifiercompiler_indent($params)
24 | {
25 | if (!isset($params[1])) {
26 | $params[1] = 4;
27 | }
28 | if (!isset($params[2])) {
29 | $params[2] = "' '";
30 | }
31 |
32 | return 'preg_replace(\'!^!m\',str_repeat(' . $params[2] . ',' . $params[1] . '),' . $params[0] . ')';
33 | }
34 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifiercompiler.lower.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: lower
13 | * Purpose: convert string to lowercase
14 | *
15 | * @link http://www.smarty.net/manual/en/language.modifier.lower.php lower (Smarty online manual)
16 | * @author Monte Ohrt
17 | * @author Uwe Tews
18 | *
19 | * @param array $params parameters
20 | *
21 | * @return string with compiled code
22 | */
23 |
24 | function smarty_modifiercompiler_lower($params)
25 | {
26 | if (Smarty::$_MBSTRING) {
27 | return 'mb_strtolower(' . $params[0] . ', \'' . addslashes(Smarty::$_CHARSET) . '\')';
28 | }
29 | // no MBString fallback
30 | return 'strtolower(' . $params[0] . ')';
31 | }
32 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifiercompiler.noprint.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: noprint
13 | * Purpose: return an empty string
14 | *
15 | * @author Uwe Tews
16 | * @return string with compiled code
17 | */
18 | function smarty_modifiercompiler_noprint()
19 | {
20 | return "''";
21 | }
22 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifiercompiler.string_format.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: string_format
13 | * Purpose: format strings via sprintf
14 | *
15 | * @link http://www.smarty.net/manual/en/language.modifier.string.format.php string_format (Smarty online manual)
16 | * @author Uwe Tews
17 | *
18 | * @param array $params parameters
19 | *
20 | * @return string with compiled code
21 | */
22 | function smarty_modifiercompiler_string_format($params)
23 | {
24 | return 'sprintf(' . $params[1] . ',' . $params[0] . ')';
25 | }
26 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifiercompiler.strip.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: strip
13 | * Purpose: Replace all repeated spaces, newlines, tabs
14 | * with a single space or supplied replacement string.
15 | * Example: {$var|strip} {$var|strip:" "}
16 | * Date: September 25th, 2002
17 | *
18 | * @link http://www.smarty.net/manual/en/language.modifier.strip.php strip (Smarty online manual)
19 | * @author Uwe Tews
20 | *
21 | * @param array $params parameters
22 | *
23 | * @return string with compiled code
24 | */
25 |
26 | function smarty_modifiercompiler_strip($params)
27 | {
28 | if (!isset($params[1])) {
29 | $params[1] = "' '";
30 | }
31 |
32 | return "preg_replace('!\s+!" . Smarty::$_UTF8_MODIFIER . "', {$params[1]},{$params[0]})";
33 | }
34 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifiercompiler.strip_tags.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: strip_tags
13 | * Purpose: strip html tags from text
14 | *
15 | * @link http://www.smarty.net/manual/en/language.modifier.strip.tags.php strip_tags (Smarty online manual)
16 | * @author Uwe Tews
17 | *
18 | * @param array $params parameters
19 | *
20 | * @return string with compiled code
21 | */
22 | function smarty_modifiercompiler_strip_tags($params)
23 | {
24 | if (!isset($params[1]) || $params[1] === true || trim($params[1], '"') == 'true') {
25 | return "preg_replace('!<[^>]*?>!', ' ', {$params[0]})";
26 | } else {
27 | return 'strip_tags(' . $params[0] . ')';
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifiercompiler.to_charset.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: to_charset
13 | * Purpose: convert character encoding from internal encoding to $charset
14 | *
15 | * @author Rodney Rehm
16 | *
17 | * @param array $params parameters
18 | *
19 | * @return string with compiled code
20 | */
21 | function smarty_modifiercompiler_to_charset($params)
22 | {
23 | if (!Smarty::$_MBSTRING) {
24 | // FIXME: (rodneyrehm) shouldn't this throw an error?
25 | return $params[0];
26 | }
27 |
28 | if (!isset($params[1])) {
29 | $params[1] = '"ISO-8859-1"';
30 | }
31 |
32 | return 'mb_convert_encoding(' . $params[0] . ', ' . $params[1] . ', "' . addslashes(Smarty::$_CHARSET) . '")';
33 | }
34 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifiercompiler.unescape.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: unescape
13 | * Purpose: unescape html entities
14 | *
15 | * @author Rodney Rehm
16 | *
17 | * @param array $params parameters
18 | *
19 | * @return string with compiled code
20 | */
21 | function smarty_modifiercompiler_unescape($params)
22 | {
23 | if (!isset($params[1])) {
24 | $params[1] = 'html';
25 | }
26 | if (!isset($params[2])) {
27 | $params[2] = '\'' . addslashes(Smarty::$_CHARSET) . '\'';
28 | } else {
29 | $params[2] = "'" . $params[2] . "'";
30 | }
31 |
32 | switch (trim($params[1], '"\'')) {
33 | case 'entity':
34 | case 'htmlall':
35 | if (Smarty::$_MBSTRING) {
36 | return 'mb_convert_encoding(' . $params[0] . ', ' . $params[2] . ', \'HTML-ENTITIES\')';
37 | }
38 |
39 | return 'html_entity_decode(' . $params[0] . ', ENT_NOQUOTES, ' . $params[2] . ')';
40 |
41 | case 'html':
42 | return 'htmlspecialchars_decode(' . $params[0] . ', ENT_QUOTES)';
43 |
44 | case 'url':
45 | return 'rawurldecode(' . $params[0] . ')';
46 |
47 | default:
48 | return $params[0];
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifiercompiler.upper.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: lower
13 | * Purpose: convert string to uppercase
14 | *
15 | * @link http://smarty.php.net/manual/en/language.modifier.upper.php lower (Smarty online manual)
16 | * @author Uwe Tews
17 | *
18 | * @param array $params parameters
19 | *
20 | * @return string with compiled code
21 | */
22 | function smarty_modifiercompiler_upper($params)
23 | {
24 | if (Smarty::$_MBSTRING) {
25 | return 'mb_strtoupper(' . $params[0] . ', \'' . addslashes(Smarty::$_CHARSET) . '\')';
26 | }
27 | // no MBString fallback
28 | return 'strtoupper(' . $params[0] . ')';
29 | }
30 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/modifiercompiler.wordwrap.php:
--------------------------------------------------------------------------------
1 |
12 | * Name: wordwrap
13 | * Purpose: wrap a string of text at a given length
14 | *
15 | * @link http://smarty.php.net/manual/en/language.modifier.wordwrap.php wordwrap (Smarty online manual)
16 | * @author Uwe Tews
17 | *
18 | * @param array $params parameters
19 | * @param $compiler
20 | *
21 | * @return string with compiled code
22 | */
23 | function smarty_modifiercompiler_wordwrap($params, $compiler)
24 | {
25 | if (!isset($params[1])) {
26 | $params[1] = 80;
27 | }
28 | if (!isset($params[2])) {
29 | $params[2] = '"\n"';
30 | }
31 | if (!isset($params[3])) {
32 | $params[3] = 'false';
33 | }
34 | $function = 'wordwrap';
35 | if (Smarty::$_MBSTRING) {
36 | if ($compiler->template->caching && ($compiler->tag_nocache | $compiler->nocache)) {
37 | $compiler->template->required_plugins['nocache']['wordwrap']['modifier']['file'] = SMARTY_PLUGINS_DIR . 'shared.mb_wordwrap.php';
38 | $compiler->template->required_plugins['nocache']['wordwrap']['modifier']['function'] = 'smarty_mb_wordwrap';
39 | } else {
40 | $compiler->template->required_plugins['compiled']['wordwrap']['modifier']['file'] = SMARTY_PLUGINS_DIR . 'shared.mb_wordwrap.php';
41 | $compiler->template->required_plugins['compiled']['wordwrap']['modifier']['function'] = 'smarty_mb_wordwrap';
42 | }
43 | $function = 'smarty_mb_wordwrap';
44 | }
45 |
46 | return $function . '(' . $params[0] . ',' . $params[1] . ',' . $params[2] . ',' . $params[3] . ')';
47 | }
48 |
--------------------------------------------------------------------------------
/libs/smarty/plugins/outputfilter.trimwhitespace.php:
--------------------------------------------------------------------------------
1 | .*?#is', $source, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER)) {
31 | foreach ($matches as $match) {
32 | $store[] = $match[0][0];
33 | $_length = strlen($match[0][0]);
34 | $replace = '@!@SMARTY:' . $_store . ':SMARTY@!@';
35 | $source = substr_replace($source, $replace, $match[0][1] - $_offset, $_length);
36 |
37 | $_offset += $_length - strlen($replace);
38 | $_store ++;
39 | }
40 | }
41 |
42 | // Strip all HTML-Comments
43 | // yes, even the ones in
50 | {/literal}
51 | {/if}
52 |
--------------------------------------------------------------------------------
/templates/footer.tpl:
--------------------------------------------------------------------------------
1 |
2 |