~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to www/php/phpBB3/includes/functions_template.php

Merge from no-phpbb-for-you. phpBB is no longer available by default.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
<?php
2
 
/**
3
 
*
4
 
* @package phpBB3
5
 
* @version $Id: functions_template.php,v 1.47 2007/10/05 14:30:10 acydburn Exp $
6
 
* @copyright (c) 2005 phpBB Group, sections (c) 2001 ispi of Lincoln Inc
7
 
* @license http://opensource.org/licenses/gpl-license.php GNU Public License
8
 
*
9
 
*/
10
 
 
11
 
/**
12
 
* @ignore
13
 
*/
14
 
if (!defined('IN_PHPBB'))
15
 
{
16
 
        exit;
17
 
}
18
 
 
19
 
/**
20
 
* Extension of template class - Functions needed for compiling templates only.
21
 
*
22
 
* psoTFX, phpBB Development Team - Completion of file caching, decompilation
23
 
* routines and implementation of conditionals/keywords and associated changes
24
 
*
25
 
* The interface was inspired by PHPLib templates,  and the template file (formats are
26
 
* quite similar)
27
 
*
28
 
* The keyword/conditional implementation is currently based on sections of code from
29
 
* the Smarty templating engine (c) 2001 ispi of Lincoln, Inc. which is released
30
 
* (on its own and in whole) under the LGPL. Section 3 of the LGPL states that any code
31
 
* derived from an LGPL application may be relicenced under the GPL, this applies
32
 
* to this source
33
 
*
34
 
* DEFINE directive inspired by a request by Cyberalien
35
 
*
36
 
* @package phpBB3
37
 
*/
38
 
class template_compile
39
 
{
40
 
        var $template;
41
 
 
42
 
        // Various storage arrays
43
 
        var $block_names = array();
44
 
        var $block_else_level = array();
45
 
 
46
 
        /**
47
 
        * constuctor
48
 
        */
49
 
        function template_compile(&$template)
50
 
        {
51
 
                $this->template = &$template;
52
 
        }
53
 
        
54
 
        /**
55
 
        * Load template source from file
56
 
        * @access private
57
 
        */
58
 
        function _tpl_load_file($handle, $store_in_db = false)
59
 
        {
60
 
                // Try and open template for read
61
 
                if (!file_exists($this->template->files[$handle]))
62
 
                {
63
 
                        trigger_error("template->_tpl_load_file(): File {$this->template->files[$handle]} does not exist or is empty", E_USER_ERROR);
64
 
                }
65
 
 
66
 
                $this->template->compiled_code[$handle] = $this->compile(trim(@file_get_contents($this->template->files[$handle])));
67
 
 
68
 
                // Actually compile the code now.
69
 
                $this->compile_write($handle, $this->template->compiled_code[$handle]);
70
 
 
71
 
                // Store in database if required...
72
 
                if ($store_in_db)
73
 
                {
74
 
                        global $db, $user;
75
 
 
76
 
                        $sql_ary = array(
77
 
                                'template_id'                   => $user->theme['template_id'],
78
 
                                'template_filename'             => $this->template->filename[$handle],
79
 
                                'template_included'             => '',
80
 
                                'template_mtime'                => time(),
81
 
                                'template_data'                 => trim(@file_get_contents($this->template->files[$handle])),
82
 
                        );
83
 
 
84
 
                        $sql = 'INSERT INTO ' . STYLES_TEMPLATE_DATA_TABLE . ' ' . $db->sql_build_array('INSERT', $sql_ary);
85
 
                        $db->sql_query($sql);
86
 
                }
87
 
        }
88
 
 
89
 
        /**
90
 
        * Remove any PHP tags that do not belong, these regular expressions are derived from
91
 
        * the ones that exist in zend_language_scanner.l
92
 
        * @access private
93
 
        */
94
 
        function remove_php_tags(&$code)
95
 
        {
96
 
                // This matches the information gathered from the internal PHP lexer
97
 
                $match = array(
98
 
                        '#<([\?%])=?.*?\1>#s',
99
 
                        '#<script\s+language\s*=\s*(["\']?)php\1\s*>.*?</script\s*>#s',
100
 
                        '#<\?php(?:\r\n?|[ \n\t]).*?\?>#s'
101
 
                );
102
 
 
103
 
                $code = preg_replace($match, '', $code);
104
 
        }
105
 
 
106
 
        /**
107
 
        * The all seeing all doing compile method. Parts are inspired by or directly from Smarty
108
 
        * @access private
109
 
        */
110
 
        function compile($code, $no_echo = false, $echo_var = '')
111
 
        {
112
 
                global $config;
113
 
 
114
 
                if ($echo_var)
115
 
                {
116
 
                        global $$echo_var;
117
 
                }
118
 
 
119
 
                // Remove any "loose" php ... we want to give admins the ability
120
 
                // to switch on/off PHP for a given template. Allowing unchecked
121
 
                // php is a no-no. There is a potential issue here in that non-php
122
 
                // content may be removed ... however designers should use entities
123
 
                // if they wish to display < and >
124
 
                $this->remove_php_tags($code);
125
 
 
126
 
                // Pull out all block/statement level elements and separate plain text
127
 
                preg_match_all('#<!-- PHP -->(.*?)<!-- ENDPHP -->#s', $code, $matches);
128
 
                $php_blocks = $matches[1];
129
 
                $code = preg_replace('#<!-- PHP -->.*?<!-- ENDPHP -->#s', '<!-- PHP -->', $code);
130
 
 
131
 
                preg_match_all('#<!-- INCLUDE ([a-zA-Z0-9\_\-\+\./]+) -->#', $code, $matches);
132
 
                $include_blocks = $matches[1];
133
 
                $code = preg_replace('#<!-- INCLUDE [a-zA-Z0-9\_\-\+\./]+ -->#', '<!-- INCLUDE -->', $code);
134
 
 
135
 
                preg_match_all('#<!-- INCLUDEPHP ([a-zA-Z0-9\_\-\+\./]+) -->#', $code, $matches);
136
 
                $includephp_blocks = $matches[1];
137
 
                $code = preg_replace('#<!-- INCLUDEPHP [a-zA-Z0-9\_\-\+\./]+ -->#', '<!-- INCLUDEPHP -->', $code);
138
 
 
139
 
                preg_match_all('#<!-- ([^<].*?) (.*?)? ?-->#', $code, $blocks, PREG_SET_ORDER);
140
 
 
141
 
                $text_blocks = preg_split('#<!-- [^<].*? (?:.*?)? ?-->#', $code);
142
 
 
143
 
                for ($i = 0, $j = sizeof($text_blocks); $i < $j; $i++)
144
 
                {
145
 
                        $this->compile_var_tags($text_blocks[$i]);
146
 
                }
147
 
                $compile_blocks = array();
148
 
 
149
 
                for ($curr_tb = 0, $tb_size = sizeof($blocks); $curr_tb < $tb_size; $curr_tb++)
150
 
                {
151
 
                        $block_val = &$blocks[$curr_tb];
152
 
 
153
 
                        switch ($block_val[1])
154
 
                        {
155
 
                                case 'BEGIN':
156
 
                                        $this->block_else_level[] = false;
157
 
                                        $compile_blocks[] = '<?php ' . $this->compile_tag_block($block_val[2]) . ' ?>';
158
 
                                break;
159
 
 
160
 
                                case 'BEGINELSE':
161
 
                                        $this->block_else_level[sizeof($this->block_else_level) - 1] = true;
162
 
                                        $compile_blocks[] = '<?php }} else { ?>';
163
 
                                break;
164
 
 
165
 
                                case 'END':
166
 
                                        array_pop($this->block_names);
167
 
                                        $compile_blocks[] = '<?php ' . ((array_pop($this->block_else_level)) ? '}' : '}}') . ' ?>';
168
 
                                break;
169
 
 
170
 
                                case 'IF':
171
 
                                        $compile_blocks[] = '<?php ' . $this->compile_tag_if($block_val[2], false) . ' ?>';
172
 
                                break;
173
 
 
174
 
                                case 'ELSE':
175
 
                                        $compile_blocks[] = '<?php } else { ?>';
176
 
                                break;
177
 
 
178
 
                                case 'ELSEIF':
179
 
                                        $compile_blocks[] = '<?php ' . $this->compile_tag_if($block_val[2], true) . ' ?>';
180
 
                                break;
181
 
 
182
 
                                case 'ENDIF':
183
 
                                        $compile_blocks[] = '<?php } ?>';
184
 
                                break;
185
 
 
186
 
                                case 'DEFINE':
187
 
                                        $compile_blocks[] = '<?php ' . $this->compile_tag_define($block_val[2], true) . ' ?>';
188
 
                                break;
189
 
 
190
 
                                case 'UNDEFINE':
191
 
                                        $compile_blocks[] = '<?php ' . $this->compile_tag_define($block_val[2], false) . ' ?>';
192
 
                                break;
193
 
 
194
 
                                case 'INCLUDE':
195
 
                                        $temp = array_shift($include_blocks);
196
 
                                        $compile_blocks[] = '<?php ' . $this->compile_tag_include($temp) . ' ?>';
197
 
                                        $this->template->_tpl_include($temp, false);
198
 
                                break;
199
 
 
200
 
                                case 'INCLUDEPHP':
201
 
                                        $compile_blocks[] = ($config['tpl_allow_php']) ? '<?php ' . $this->compile_tag_include_php(array_shift($includephp_blocks)) . ' ?>' : '';
202
 
                                break;
203
 
 
204
 
                                case 'PHP':
205
 
                                        $compile_blocks[] = ($config['tpl_allow_php']) ? '<?php ' . array_shift($php_blocks) . ' ?>' : '';
206
 
                                break;
207
 
 
208
 
                                default:
209
 
                                        $this->compile_var_tags($block_val[0]);
210
 
                                        $trim_check = trim($block_val[0]);
211
 
                                        $compile_blocks[] = (!$no_echo) ? ((!empty($trim_check)) ? $block_val[0] : '') : ((!empty($trim_check)) ? $block_val[0] : '');
212
 
                                break;
213
 
                        }
214
 
                }
215
 
 
216
 
                $template_php = '';
217
 
                for ($i = 0, $size = sizeof($text_blocks); $i < $size; $i++)
218
 
                {
219
 
                        $trim_check_text = trim($text_blocks[$i]);
220
 
                        $template_php .= (!$no_echo) ? (($trim_check_text != '') ? $text_blocks[$i] : '') . ((isset($compile_blocks[$i])) ? $compile_blocks[$i] : '') : (($trim_check_text != '') ? $text_blocks[$i] : '') . ((isset($compile_blocks[$i])) ? $compile_blocks[$i] : '');
221
 
                }
222
 
 
223
 
                // There will be a number of occasions where we switch into and out of
224
 
                // PHP mode instantaneously. Rather than "burden" the parser with this
225
 
                // we'll strip out such occurences, minimising such switching
226
 
                $template_php = str_replace(' ?><?php ', ' ', $template_php);
227
 
 
228
 
                return (!$no_echo) ? $template_php : "\$$echo_var .= '" . $template_php . "'";
229
 
        }
230
 
 
231
 
        /**
232
 
        * Compile variables
233
 
        * @access private
234
 
        */
235
 
        function compile_var_tags(&$text_blocks)
236
 
        {
237
 
                // change template varrefs into PHP varrefs
238
 
                $varrefs = array();
239
 
 
240
 
                // This one will handle varrefs WITH namespaces
241
 
                preg_match_all('#\{((?:[a-z0-9\-_]+\.)+)(\$)?([A-Z0-9\-_]+)\}#', $text_blocks, $varrefs, PREG_SET_ORDER);
242
 
 
243
 
                foreach ($varrefs as $var_val)
244
 
                {
245
 
                        $namespace = $var_val[1];
246
 
                        $varname = $var_val[3];
247
 
                        $new = $this->generate_block_varref($namespace, $varname, true, $var_val[2]);
248
 
 
249
 
                        $text_blocks = str_replace($var_val[0], $new, $text_blocks);
250
 
                }
251
 
 
252
 
                // This will handle the remaining root-level varrefs
253
 
                // transform vars prefixed by L_ into their language variable pendant if nothing is set within the tpldata array
254
 
                if (strpos($text_blocks, '{L_') !== false)
255
 
                {
256
 
                        $text_blocks = preg_replace('#\{L_([a-z0-9\-_]*)\}#is', "<?php echo ((isset(\$this->_rootref['L_\\1'])) ? \$this->_rootref['L_\\1'] : ((isset(\$user->lang['\\1'])) ? \$user->lang['\\1'] : '{ \\1 }')); ?>", $text_blocks);
257
 
                }
258
 
 
259
 
                // Handle addslashed language variables prefixed with LA_
260
 
                // If a template variable already exist, it will be used in favor of it...
261
 
                if (strpos($text_blocks, '{LA_') !== false)
262
 
                {
263
 
                        $text_blocks = preg_replace('#\{LA_([a-z0-9\-_]*)\}#is', "<?php echo ((isset(\$this->_rootref['LA_\\1'])) ? \$this->_rootref['LA_\\1'] : ((isset(\$this->_rootref['L_\\1'])) ? addslashes(\$this->_rootref['L_\\1']) : ((isset(\$user->lang['\\1'])) ? addslashes(\$user->lang['\\1']) : '{ \\1 }'))); ?>", $text_blocks);
264
 
                }
265
 
 
266
 
                // Handle remaining varrefs
267
 
                $text_blocks = preg_replace('#\{([a-z0-9\-_]*)\}#is', "<?php echo (isset(\$this->_rootref['\\1'])) ? \$this->_rootref['\\1'] : ''; ?>", $text_blocks);
268
 
                $text_blocks = preg_replace('#\{\$([a-z0-9\-_]*)\}#is', "<?php echo (isset(\$this->_tpldata['DEFINE']['.']['\\1'])) ? \$this->_tpldata['DEFINE']['.']['\\1'] : ''; ?>", $text_blocks);
269
 
 
270
 
                return;
271
 
        }
272
 
 
273
 
        /**
274
 
        * Compile blocks
275
 
        * @access private
276
 
        */
277
 
        function compile_tag_block($tag_args)
278
 
        {
279
 
                $no_nesting = false;
280
 
 
281
 
                // Is the designer wanting to call another loop in a loop?
282
 
                if (strpos($tag_args, '!') === 0)
283
 
                {
284
 
                        // Count the number if ! occurrences (not allowed in vars)
285
 
                        $no_nesting = substr_count($tag_args, '!');
286
 
                        $tag_args = substr($tag_args, $no_nesting);
287
 
                }
288
 
 
289
 
                // Allow for control of looping (indexes start from zero):
290
 
                // foo(2)    : Will start the loop on the 3rd entry
291
 
                // foo(-2)   : Will start the loop two entries from the end
292
 
                // foo(3,4)  : Will start the loop on the fourth entry and end it on the fifth
293
 
                // foo(3,-4) : Will start the loop on the fourth entry and end it four from last
294
 
                if (preg_match('#^([^()]*)\(([\-\d]+)(?:,([\-\d]+))?\)$#', $tag_args, $match))
295
 
                {
296
 
                        $tag_args = $match[1];
297
 
 
298
 
                        if ($match[2] < 0)
299
 
                        {
300
 
                                $loop_start = '($_' . $tag_args . '_count ' . $match[2] . ' < 0 ? 0 : $_' . $tag_args . '_count ' . $match[2] . ')';
301
 
                        }
302
 
                        else
303
 
                        {
304
 
                                $loop_start = '($_' . $tag_args . '_count < ' . $match[2] . ' ? $_' . $tag_args . '_count : ' . $match[2] . ')';
305
 
                        }
306
 
 
307
 
                        if (strlen($match[3]) < 1 || $match[3] == -1)
308
 
                        {
309
 
                                $loop_end = '$_' . $tag_args . '_count';
310
 
                        }
311
 
                        else if ($match[3] >= 0)
312
 
                        {
313
 
                                $loop_end = '(' . ($match[3] + 1) . ' > $_' . $tag_args . '_count ? $_' . $tag_args . '_count : ' . ($match[3] + 1) . ')';
314
 
                        }
315
 
                        else //if ($match[3] < -1)
316
 
                        {
317
 
                                $loop_end = '$_' . $tag_args . '_count' . ($match[3] + 1);
318
 
                        }
319
 
                }
320
 
                else
321
 
                {
322
 
                        $loop_start = 0;
323
 
                        $loop_end = '$_' . $tag_args . '_count';
324
 
                }
325
 
 
326
 
                $tag_template_php = '';
327
 
                array_push($this->block_names, $tag_args);
328
 
 
329
 
                if ($no_nesting !== false)
330
 
                {
331
 
                        // We need to implode $no_nesting times from the end...
332
 
                        $block = array_slice($this->block_names, -$no_nesting);
333
 
                }
334
 
                else
335
 
                {
336
 
                        $block = $this->block_names;
337
 
                }
338
 
 
339
 
                if (sizeof($block) < 2)
340
 
                {
341
 
                        // Block is not nested.
342
 
                        $tag_template_php = '$_' . $tag_args . "_count = (isset(\$this->_tpldata['$tag_args'])) ? sizeof(\$this->_tpldata['$tag_args']) : 0;";
343
 
                        $varref = "\$this->_tpldata['$tag_args']";
344
 
                }
345
 
                else
346
 
                {
347
 
                        // This block is nested.
348
 
                        // Generate a namespace string for this block.
349
 
                        $namespace = implode('.', $block);
350
 
 
351
 
                        // Get a reference to the data array for this block that depends on the
352
 
                        // current indices of all parent blocks.
353
 
                        $varref = $this->generate_block_data_ref($namespace, false);
354
 
 
355
 
                        // Create the for loop code to iterate over this block.
356
 
                        $tag_template_php = '$_' . $tag_args . '_count = (isset(' . $varref . ')) ? sizeof(' . $varref . ') : 0;';
357
 
                }
358
 
 
359
 
                $tag_template_php .= 'if ($_' . $tag_args . '_count) {';
360
 
 
361
 
                /**
362
 
                * The following uses foreach for iteration instead of a for loop, foreach is faster but requires PHP to make a copy of the contents of the array which uses more memory
363
 
                * <code>
364
 
                *       if (!$offset)
365
 
                *       {
366
 
                *               $tag_template_php .= 'foreach (' . $varref . ' as $_' . $tag_args . '_i => $_' . $tag_args . '_val){';
367
 
                *       }
368
 
                * </code>
369
 
                */
370
 
 
371
 
                $tag_template_php .= 'for ($_' . $tag_args . '_i = ' . $loop_start . '; $_' . $tag_args . '_i < ' . $loop_end . '; ++$_' . $tag_args . '_i){';
372
 
                $tag_template_php .= '$_'. $tag_args . '_val = &' . $varref . '[$_'. $tag_args. '_i];';
373
 
 
374
 
                return $tag_template_php;
375
 
        }
376
 
 
377
 
        /**
378
 
        * Compile IF tags - much of this is from Smarty with
379
 
        * some adaptions for our block level methods
380
 
        * @access private
381
 
        */
382
 
        function compile_tag_if($tag_args, $elseif)
383
 
        {
384
 
                // Tokenize args for 'if' tag.
385
 
                preg_match_all('/(?:
386
 
                        "[^"\\\\]*(?:\\\\.[^"\\\\]*)*"         |
387
 
                        \'[^\'\\\\]*(?:\\\\.[^\'\\\\]*)*\'     |
388
 
                        [(),]                                  |
389
 
                        [^\s(),]+)/x', $tag_args, $match);
390
 
 
391
 
                $tokens = $match[0];
392
 
                $is_arg_stack = array();
393
 
 
394
 
                for ($i = 0, $size = sizeof($tokens); $i < $size; $i++)
395
 
                {
396
 
                        $token = &$tokens[$i];
397
 
 
398
 
                        switch ($token)
399
 
                        {
400
 
                                case '!==':
401
 
                                case '===':
402
 
                                case '<<':
403
 
                                case '>>':
404
 
                                case '|':
405
 
                                case '^':
406
 
                                case '&':
407
 
                                case '~':
408
 
                                case ')':
409
 
                                case ',':
410
 
                                case '+':
411
 
                                case '-':
412
 
                                case '*':
413
 
                                case '/':
414
 
                                case '@':
415
 
                                break;
416
 
 
417
 
                                case '==':
418
 
                                case 'eq':
419
 
                                        $token = '==';
420
 
                                break;
421
 
 
422
 
                                case '!=':
423
 
                                case '<>':
424
 
                                case 'ne':
425
 
                                case 'neq':
426
 
                                        $token = '!=';
427
 
                                break;
428
 
 
429
 
                                case '<':
430
 
                                case 'lt':
431
 
                                        $token = '<';
432
 
                                break;
433
 
 
434
 
                                case '<=':
435
 
                                case 'le':
436
 
                                case 'lte':
437
 
                                        $token = '<=';
438
 
                                break;
439
 
 
440
 
                                case '>':
441
 
                                case 'gt':
442
 
                                        $token = '>';
443
 
                                break;
444
 
 
445
 
                                case '>=':
446
 
                                case 'ge':
447
 
                                case 'gte':
448
 
                                        $token = '>=';
449
 
                                break;
450
 
 
451
 
                                case '&&':
452
 
                                case 'and':
453
 
                                        $token = '&&';
454
 
                                break;
455
 
 
456
 
                                case '||':
457
 
                                case 'or':
458
 
                                        $token = '||';
459
 
                                break;
460
 
 
461
 
                                case '!':
462
 
                                case 'not':
463
 
                                        $token = '!';
464
 
                                break;
465
 
 
466
 
                                case '%':
467
 
                                case 'mod':
468
 
                                        $token = '%';
469
 
                                break;
470
 
 
471
 
                                case '(':
472
 
                                        array_push($is_arg_stack, $i);
473
 
                                break;
474
 
 
475
 
                                case 'is':
476
 
                                        $is_arg_start = ($tokens[$i-1] == ')') ? array_pop($is_arg_stack) : $i-1;
477
 
                                        $is_arg = implode('     ', array_slice($tokens, $is_arg_start, $i -     $is_arg_start));
478
 
 
479
 
                                        $new_tokens     = $this->_parse_is_expr($is_arg, array_slice($tokens, $i+1));
480
 
 
481
 
                                        array_splice($tokens, $is_arg_start, sizeof($tokens), $new_tokens);
482
 
 
483
 
                                        $i = $is_arg_start;
484
 
 
485
 
                                // no break
486
 
 
487
 
                                default:
488
 
                                        if (preg_match('#^((?:[a-z0-9\-_]+\.)+)?(\$)?(?=[A-Z])([A-Z0-9\-_]+)#s', $token, $varrefs))
489
 
                                        {
490
 
                                                $token = (!empty($varrefs[1])) ? $this->generate_block_data_ref(substr($varrefs[1], 0, -1), true, $varrefs[2]) . '[\'' . $varrefs[3] . '\']' : (($varrefs[2]) ? '$this->_tpldata[\'DEFINE\'][\'.\'][\'' . $varrefs[3] . '\']' : '$this->_rootref[\'' . $varrefs[3] . '\']');
491
 
                                        }
492
 
                                        else if (preg_match('#^\.((?:[a-z0-9\-_]+\.?)+)$#s', $token, $varrefs))
493
 
                                        {
494
 
                                                // Allow checking if loops are set with .loopname
495
 
                                                // It is also possible to check the loop count by doing <!-- IF .loopname > 1 --> for example
496
 
                                                $blocks = explode('.', $varrefs[1]);
497
 
 
498
 
                                                // If the block is nested, we have a reference that we can grab.
499
 
                                                // If the block is not nested, we just go and grab the block from _tpldata
500
 
                                                if (sizeof($blocks) > 1)
501
 
                                                {
502
 
                                                        $block = array_pop($blocks);
503
 
                                                        $namespace = implode('.', $blocks);
504
 
                                                        $varref = $this->generate_block_data_ref($namespace, true);
505
 
 
506
 
                                                        // Add the block reference for the last child.
507
 
                                                        $varref .= "['" . $block . "']";
508
 
                                                }
509
 
                                                else
510
 
                                                {
511
 
                                                        $varref = '$this->_tpldata';
512
 
 
513
 
                                                        // Add the block reference for the last child.
514
 
                                                        $varref .= "['" . $blocks[0] . "']";
515
 
                                                }
516
 
                                                $token = "sizeof($varref)";
517
 
                                        }
518
 
 
519
 
                                break;
520
 
                        }
521
 
                }
522
 
 
523
 
                return (($elseif) ? '} else if (' : 'if (') . (implode(' ', $tokens) . ') { ');
524
 
        }
525
 
 
526
 
        /**
527
 
        * Compile DEFINE tags
528
 
        * @access private
529
 
        */
530
 
        function compile_tag_define($tag_args, $op)
531
 
        {
532
 
                preg_match('#^((?:[a-z0-9\-_]+\.)+)?\$(?=[A-Z])([A-Z0-9_\-]*)(?: = (\'?)([^\']*)(\'?))?$#', $tag_args, $match);
533
 
 
534
 
                if (empty($match[2]) || (!isset($match[4]) && $op))
535
 
                {
536
 
                        return '';
537
 
                }
538
 
 
539
 
                if (!$op)
540
 
                {
541
 
                        return 'unset(' . (($match[1]) ? $this->generate_block_data_ref(substr($match[1], 0, -1), true, true) . '[\'' . $match[2] . '\']' : '$this->_tpldata[\'DEFINE\'][\'.\'][\'' . $match[2] . '\']') . ');';
542
 
                }
543
 
 
544
 
                // Are we a string?
545
 
                if ($match[3] && $match[5])
546
 
                {
547
 
                        $match[4] = str_replace(array('\\\'', '\\\\', '\''), array('\'', '\\', '\\\''), $match[4]);
548
 
 
549
 
                        // Compile reference, we allow template variables in defines...
550
 
                        $match[4] = $this->compile($match[4]);
551
 
 
552
 
                        // Now replace the php code
553
 
                        $match[4] = "'" . str_replace(array('<?php echo ', '; ?>'), array("' . ", " . '"), $match[4]) . "'";
554
 
                }
555
 
                else
556
 
                {
557
 
                        preg_match('#true|false|\.#i', $match[4], $type);
558
 
 
559
 
                        switch (strtolower($type[0]))
560
 
                        {
561
 
                                case 'true':
562
 
                                case 'false':
563
 
                                        $match[4] = strtoupper($match[4]);
564
 
                                break;
565
 
 
566
 
                                case '.':
567
 
                                        $match[4] = doubleval($match[4]);
568
 
                                break;
569
 
 
570
 
                                default:
571
 
                                        $match[4] = intval($match[4]);
572
 
                                break;
573
 
                        }
574
 
                }
575
 
 
576
 
                return (($match[1]) ? $this->generate_block_data_ref(substr($match[1], 0, -1), true, true) . '[\'' . $match[2] . '\']' : '$this->_tpldata[\'DEFINE\'][\'.\'][\'' . $match[2] . '\']') . ' = ' . $match[4] . ';';
577
 
        }
578
 
 
579
 
        /**
580
 
        * Compile INCLUDE tag
581
 
        * @access private
582
 
        */
583
 
        function compile_tag_include($tag_args)
584
 
        {
585
 
                return "\$this->_tpl_include('$tag_args');";
586
 
        }
587
 
 
588
 
        /**
589
 
        * Compile INCLUDE_PHP tag
590
 
        * @access private
591
 
        */
592
 
        function compile_tag_include_php($tag_args)
593
 
        {
594
 
                return "include('" . $tag_args . "');";
595
 
        }
596
 
 
597
 
        /**
598
 
        * parse expression
599
 
        * This is from Smarty
600
 
        * @access private
601
 
        */
602
 
        function _parse_is_expr($is_arg, $tokens)
603
 
        {
604
 
                $expr_end = 0;
605
 
                $negate_expr = false;
606
 
 
607
 
                if (($first_token = array_shift($tokens)) == 'not')
608
 
                {
609
 
                        $negate_expr = true;
610
 
                        $expr_type = array_shift($tokens);
611
 
                }
612
 
                else
613
 
                {
614
 
                        $expr_type = $first_token;
615
 
                }
616
 
 
617
 
                switch ($expr_type)
618
 
                {
619
 
                        case 'even':
620
 
                                if (@$tokens[$expr_end] == 'by')
621
 
                                {
622
 
                                        $expr_end++;
623
 
                                        $expr_arg = $tokens[$expr_end++];
624
 
                                        $expr = "!(($is_arg / $expr_arg) % $expr_arg)";
625
 
                                }
626
 
                                else
627
 
                                {
628
 
                                        $expr = "!($is_arg & 1)";
629
 
                                }
630
 
                        break;
631
 
 
632
 
                        case 'odd':
633
 
                                if (@$tokens[$expr_end] == 'by')
634
 
                                {
635
 
                                        $expr_end++;
636
 
                                        $expr_arg = $tokens[$expr_end++];
637
 
                                        $expr = "(($is_arg / $expr_arg) % $expr_arg)";
638
 
                                }
639
 
                                else
640
 
                                {
641
 
                                        $expr = "($is_arg & 1)";
642
 
                                }
643
 
                        break;
644
 
 
645
 
                        case 'div':
646
 
                                if (@$tokens[$expr_end] == 'by')
647
 
                                {
648
 
                                        $expr_end++;
649
 
                                        $expr_arg = $tokens[$expr_end++];
650
 
                                        $expr = "!($is_arg % $expr_arg)";
651
 
                                }
652
 
                        break;
653
 
                }
654
 
 
655
 
                if ($negate_expr)
656
 
                {
657
 
                        $expr = "!($expr)";
658
 
                }
659
 
 
660
 
                array_splice($tokens, 0, $expr_end, $expr);
661
 
 
662
 
                return $tokens;
663
 
        }
664
 
 
665
 
        /**
666
 
        * Generates a reference to the given variable inside the given (possibly nested)
667
 
        * block namespace. This is a string of the form:
668
 
        * ' . $this->_tpldata['parent'][$_parent_i]['$child1'][$_child1_i]['$child2'][$_child2_i]...['varname'] . '
669
 
        * It's ready to be inserted into an "echo" line in one of the templates.
670
 
        * NOTE: expects a trailing "." on the namespace.
671
 
        * @access private
672
 
        */
673
 
        function generate_block_varref($namespace, $varname, $echo = true, $defop = false)
674
 
        {
675
 
                // Strip the trailing period.
676
 
                $namespace = substr($namespace, 0, -1);
677
 
 
678
 
                // Get a reference to the data block for this namespace.
679
 
                $varref = $this->generate_block_data_ref($namespace, true, $defop);
680
 
                // Prepend the necessary code to stick this in an echo line.
681
 
 
682
 
                // Append the variable reference.
683
 
                $varref .= "['$varname']";
684
 
                $varref = ($echo) ? "<?php echo $varref; ?>" : ((isset($varref)) ? $varref : '');
685
 
 
686
 
                return $varref;
687
 
        }
688
 
 
689
 
        /**
690
 
        * Generates a reference to the array of data values for the given
691
 
        * (possibly nested) block namespace. This is a string of the form:
692
 
        * $this->_tpldata['parent'][$_parent_i]['$child1'][$_child1_i]['$child2'][$_child2_i]...['$childN']
693
 
        *
694
 
        * If $include_last_iterator is true, then [$_childN_i] will be appended to the form shown above.
695
 
        * NOTE: does not expect a trailing "." on the blockname.
696
 
        * @access private
697
 
        */
698
 
        function generate_block_data_ref($blockname, $include_last_iterator, $defop = false)
699
 
        {
700
 
                // Get an array of the blocks involved.
701
 
                $blocks = explode('.', $blockname);
702
 
                $blockcount = sizeof($blocks) - 1;
703
 
 
704
 
                // DEFINE is not an element of any referenced variable, we must use _tpldata to access it
705
 
                if ($defop)
706
 
                {
707
 
                        $varref = '$this->_tpldata[\'DEFINE\']';
708
 
                        // Build up the string with everything but the last child.
709
 
                        for ($i = 0; $i < $blockcount; $i++)
710
 
                        {
711
 
                                $varref .= "['" . $blocks[$i] . "'][\$_" . $blocks[$i] . '_i]';
712
 
                        }
713
 
                        // Add the block reference for the last child.
714
 
                        $varref .= "['" . $blocks[$blockcount] . "']";
715
 
                        // Add the iterator for the last child if requried.
716
 
                        if ($include_last_iterator)
717
 
                        {
718
 
                                $varref .= '[$_' . $blocks[$blockcount] . '_i]';
719
 
                        }
720
 
                        return $varref;
721
 
                }
722
 
                else if ($include_last_iterator)
723
 
                {
724
 
                        return '$_'. $blocks[$blockcount] . '_val';
725
 
                }
726
 
                else
727
 
                {
728
 
                        return '$_'. $blocks[$blockcount - 1] . '_val[\''. $blocks[$blockcount]. '\']';
729
 
                }
730
 
        }
731
 
 
732
 
        /**
733
 
        * Write compiled file to cache directory
734
 
        * @access private
735
 
        */
736
 
        function compile_write($handle, $data)
737
 
        {
738
 
                global $phpEx;
739
 
 
740
 
                $filename = $this->template->cachepath . str_replace('/', '.', $this->template->filename[$handle]) . '.' . $phpEx;
741
 
 
742
 
                if ($fp = @fopen($filename, 'wb'))
743
 
                {
744
 
                        @flock($fp, LOCK_EX);
745
 
                        @fwrite ($fp, $data);
746
 
                        @flock($fp, LOCK_UN);
747
 
                        @fclose($fp);
748
 
 
749
 
                        @chmod($filename, 0666);
750
 
                }
751
 
 
752
 
                return;
753
 
        }
754
 
}
755
 
 
756
 
?>
 
 
b'\\ No newline at end of file'