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

« back to all changes in this revision

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

  • Committer: dcoles
  • Date: 2008-02-13 04:10:55 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:443
Added Forum application along with unmodifed version of phpBB3 "Olympus" 3.0.0

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'