lib/haanga.php

   1 <?php
   2 /*
   3   +---------------------------------------------------------------------------------+
   4   | Copyright (c) 2010 Haanga                                                       |
   5   +---------------------------------------------------------------------------------+
   6   | Redistribution and use in source and binary forms, with or without              |
   7   | modification, are permitted provided that the following conditions are met:     |
   8   | 1. Redistributions of source code must retain the above copyright               |
   9   |    notice, this list of conditions and the following disclaimer.                |
  10   |                                                                                 |
  11   | 2. Redistributions in binary form must reproduce the above copyright            |
  12   |    notice, this list of conditions and the following disclaimer in the          |
  13   |    documentation and/or other materials provided with the distribution.         |
  14   |                                                                                 |
  15   | 3. All advertising materials mentioning features or use of this software        |
  16   |    must display the following acknowledgement:                                  |
  17   |    This product includes software developed by César D. Rodas.                  |
  18   |                                                                                 |
  19   | 4. Neither the name of the César D. Rodas nor the                               |
  20   |    names of its contributors may be used to endorse or promote products         |
  21   |    derived from this software without specific prior written permission.        |
  22   |                                                                                 |
  23   | THIS SOFTWARE IS PROVIDED BY CÉSAR D. RODAS ''AS IS'' AND ANY                   |
  24   | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED       |
  25   | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE          |
  26   | DISCLAIMED. IN NO EVENT SHALL CÉSAR D. RODAS BE LIABLE FOR ANY                  |
  27   | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES      |
  28   | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;    |
  29   | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND     |
  30   | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT      |
  31   | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS   |
  32   | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE                     |
  33   +---------------------------------------------------------------------------------+
  34   | Authors: César Rodas <crodas@php.net>                                           |
  35   +---------------------------------------------------------------------------------+
  36 */
  37
  38 define('HAANGA_DIR', dirname(__FILE__));
  39
  40 // Load needed files {{{
  41 require HAANGA_DIR."/lexer.php";
  42 require HAANGA_DIR."/generator.php";
  43 require HAANGA_DIR."/extensions.php";
  44 require HAANGA_DIR."/tags.php";
  45 require HAANGA_DIR."/filters.php";
  46 // }}}
  47
  48 // Exception Class {{{
  49 /**
  50  *  Exception class
  51  *
  52  */
  53 class Haanga_CompilerException extends Exception
  54 {
  55 }
  56 // }}}
  57
  58
  59 class Haanga_Compiler
  60 {
  61
  62     // properties {{{
  63     protected static $block_var=NULL;
  64     protected $generator;
  65     protected $forloop = array();
  66     protected $forid = 0;
  67     protected $sub_template = FALSE;
  68     protected $name;
  69     protected $blocks=array();
  70     /**
  71      *  number of blocks :-)
  72      */
  73     protected $in_block=0;
  74     /**
  75      *  output buffers :-)
  76      */
  77     protected $ob_start=0;
  78     protected $append;
  79     protected $prepend_op;
  80     /**
  81      *  Table which contains all variables
  82      *  aliases defined in the template
  83      */
  84     protected $var_alias;
  85     /**
  86      *  Flag the current variable as safe. This means
  87      *  that escape won't be called if autoescape is
  88      *  activated (which is activated by default)
  89      */
  90     public $var_is_safe=FALSE;
  91     protected $autoescape=TRUE;
  92     protected $force_whitespaces=0;
  93     /**
  94      *  Debug file
  95      */
  96     protected $debug;
  97     // }}}
  98
  99     function __construct()
 100     {
 101         $this->generator = new Haanga_CodeGenerator;
 102         if (self::$block_var===NULL) {
 103             self::$block_var = '{{block.'.md5('super').'}}';
 104         }
 105     }
 106
 107     // setDebug($file) {{{
 108     function setDebug($file)
 109     {
 110         $this->debug = $file;
 111     }
 112     // }}}
 113
 114     // reset() {{{
 115     function reset()
 116     {
 117         $avoid_cleaning = array('strip_whitespaces' => 1, 'block_var' => 1, 'autoescape'=>1);
 118         foreach (array_keys(get_object_vars($this)) as $key) {
 119             if (isset($avoid_cleaning[$key])) {
 120                 continue;
 121             }
 122             $this->$key = NULL;
 123         }
 124         $this->generator = new Haanga_CodeGenerator;
 125         $this->blocks = array();
 126         $this->cycle  = array();
 127     }
 128     // }}}
 129
 130     // get_template_name() {{{
 131     final function get_template_name()
 132     {
 133         return $this->name;
 134     }
 135     // }}}
 136
 137     // Set template name {{{
 138     function set_template_name($path)
 139     {
 140         return ($this->name = strstr(basename($path),'.', TRUE));
 141     }
 142     // }}}
 143
 144     // get_function_name(string $name) {{{
 145     function get_function_name($name)
 146     {
 147         return "{$name}_template";
 148     }
 149     // }}}
 150
 151     // Compile ($code, $name=NULL) {{{
 152     final function compile($code, $name=NULL)
 153     {
 154         $this->name = $name;
 155
 156         $parsed = do_parsing($code);
 157         $code   = "";
 158         $this->subtemplate = FALSE;
 159
 160         if ($parsed[0]['operation'] == 'base') {
 161             /* {% base ... %} found */
 162             $base  = $parsed[0][0];
 163             $code .= $this->get_base_template($base);
 164             unset($parsed[0]);
 165         }
 166
 167         if ($name) {
 168             if (isset($this->_file)) {
 169                 $op_code[] = $this->op_comment("Generated from {$this->_base_dir}/{$this->_file}");
 170             }
 171             $op_code[] = $this->op_declare_function($this->get_function_name($name));
 172             $op_code[] = $this->op_expr($this->expr_exec('extract', $this->expr_var('vars')));
 173         }
 174
 175         $this->ob_start($op_code);
 176         $this->generate_op_code($parsed, $op_code);
 177         if ($this->subtemplate) {
 178             $expr = $this->expr_call_base_template();
 179             $this->generate_op_print(array('expr' => $expr), $op_code);
 180         }
 181         $this->ob_start--;
 182
 183         /* Add last part */
 184         $expr = $this->expr('==', $this->expr_var('return'), TRUE);
 185         $op_code[] = $this->op_if($expr);
 186         $op_code[] = $this->op_return($this->expr_var('buffer1'));
 187         $op_code[] = $this->op_else();
 188         $this->generate_op_print(array('variable' => 'buffer1'), $op_code);
 189         $op_code[] = $this->op_end('if');
 190
 191         if ($name) {
 192             $op_code[] = $this->op_end('function');
 193         }
 194
 195         if (count($this->prepend_op)) {
 196             $op_code = array_merge($this->prepend_op, $op_code);
 197         }
 198
 199         $code .= $this->generator->getCode($op_code);
 200         if (!empty($this->append)) {
 201             $code .= $this->append;
 202         }
 203         if (!empty($this->debug)) {
 204             file_put_contents($this->debug, print_r($op_code, TRUE));
 205         }
 206         return $code;
 207     }
 208     // }}}
 209
 210     // compile_file($file) {{{
 211     /**
 212      *  Compile a file
 213      *
 214      *  @param string $file File path
 215      *
 216      *  @return Generated PHP code
 217      */
 218     final function compile_file($file)
 219     {
 220         if (!is_readable($file)) {
 221             throw new Haanga_CompilerException("$file is not a file");
 222         }
 223         $this->_base_dir = dirname($file);
 224         $this->_file     = basename($file);
 225         $name            = $this->set_template_name($file);
 226         return $this->compile(file_get_contents($file), $name);
 227     }
 228     // }}}
 229
 230     // is_expr methods {{{
 231     function is_expr(Array $cmd, $type=NULL)
 232     {
 233         if (isset($cmd['op_expr'])) {
 234             if (!$type || $type == $cmd['op_expr']) {
 235                 return TRUE;
 236             }
 237         }
 238         return FALSE;
 239     }
 240
 241     function is_exec(Array $cmd)
 242     {
 243         return $this->is_expr($cmd, 'exec');
 244     }
 245
 246     function is_var(Array $cmd)
 247     {
 248         return isset($cmd['var']);
 249     }
 250     // }}}
 251
 252     // op_* helper methods {{{
 253     /**
 254      *  Return an stand alone expression
 255      *
 256      */
 257     function op_expr($expr)
 258     {
 259         return array('op' => 'expr', $expr);
 260     }
 261
 262     function op_comment($comment)
 263     {
 264         return array('op' => 'comment', 'comment' => $comment);
 265     }
 266
 267     function op_foreach($array, $value, $key=NULL)
 268     {
 269         foreach (array('array', 'value', 'key') as $var) {
 270             $var = &$$var;
 271             if (is_array($var) && isset($var['var'])) {
 272                 $var = $var['var'];
 273             }
 274             unset($var);
 275         }
 276         $def = array('op' => 'foreach', 'array' => $array, 'value' => $value);
 277         if ($key) {
 278             $def['key'] = $key;
 279         }
 280         return $def;
 281     }
 282
 283     function op_if($expr)
 284     {
 285         return array('op' => 'if', 'expr' => $expr);
 286     }
 287
 288     function op_else()
 289     {
 290         return array('op' => 'else');
 291     }
 292
 293     function op_return($expr)
 294     {
 295         return array('op' => 'return', $expr);
 296     }
 297
 298     function op_end($op)
 299     {
 300         return array('op' => "end_{$op}");
 301     }
 302
 303     function op_declare($name, $value)
 304     {
 305         if (is_array($name)) {
 306             if (isset($name['var'])) {
 307                 $name = $name['var'];
 308             }
 309         }
 310
 311         if (is_array($value)) {
 312             if (isset($value['op_expr'])) {
 313                 $value = array('expr' => $value);
 314             }
 315         }
 316
 317         return array('op' => 'declare', 'name' => $name, $value);
 318     }
 319
 320     function op_append($name, $expr)
 321     {
 322         return array('op' => 'append_var', 'name' => $name, $expr);
 323     }
 324
 325
 326     function op_inc($name)
 327     {
 328         return array('op' => 'inc', 'name' => $name);
 329     }
 330
 331     function op_declare_function($name)
 332     {
 333         return array('op' => 'function', 'name' => $name);
 334     }
 335
 336     //}}}
 337
 338     // expr_* helper methods {{{
 339     function expr_cond($expr, $true, $false)
 340     {
 341         return array('expr_cond' => $expr, 'true' => $true, 'false' => $false);
 342     }
 343
 344     function expr_const($name)
 345     {
 346         return array('constant' => $name);
 347     }
 348
 349     /**
 350      *  Generate code to call base template
 351      *
 352      */
 353     function expr_call_base_template()
 354     {
 355         return $this->expr_exec(
 356             $this->get_function_name($this->subtemplate),
 357             $this->expr_var('vars'),
 358             $this->expr_TRUE(),
 359             $this->expr_var('blocks')
 360         );
 361     }
 362
 363     /**
 364      *  return a function call for isset($var) === $isset
 365      *
 366      *  @return array
 367      */
 368     final function expr_isset($var, $isset=TRUE)
 369     {
 370         return $this->expr('==', $this->expr_exec('isset', $this->expr_var($var)), $isset);
 371     }
 372
 373     final function expr_isset_ex($var, $isset=TRUE)
 374     {
 375         return $this->expr('==', $this->expr_exec('isset', $var), $isset);
 376     }
 377
 378     final function expr_array()
 379     {
 380         $def = array();
 381         foreach (func_get_args() as $arg) {
 382             if (count($arg) == 2) {
 383                 if (!is_array($arg[0])) {
 384                     $arg[0] = $this->expr_str($arg[0]);
 385                 }
 386                 $arg = array('key' => $arg);
 387             }
 388             $def[] = $arg;
 389         }
 390         return array("array" => $def);
 391     }
 392
 393     final function expr_array_first($values)
 394     {
 395         $def = array();
 396         foreach ($values as $arg) {
 397             if (count($arg) == 2) {
 398                 if (!is_array($arg[0])) {
 399                     $arg[0] = $this->expr_str($arg[0]);
 400                 }
 401                 $arg = array('key' => $arg);
 402             }
 403             $def[] = $arg;
 404         }
 405         return array("array" => $def);
 406     }
 407
 408
 409     /**
 410      *  return an number definition of $num
 411      *
 412      *  @return array
 413      */
 414     final function expr_number($num=0)
 415     {
 416         return array('number' =>$num);
 417     }
 418
 419     /**
 420      *  return an string definition of $str
 421      *
 422      *  @return array
 423      */
 424     final function expr_str($str='')
 425     {
 426         return array('string' => $str);
 427     }
 428
 429     /**
 430      *  Generate expression that for
 431      *  boolean TRUE
 432      *
 433      *  @return array
 434      */
 435     final function expr_TRUE()
 436     {
 437         return array('expr' => TRUE);
 438     }
 439
 440     /**
 441      *  Generate expression that for
 442      *  boolean FALSE
 443      *
 444      *  @return array
 445      */
 446     final function expr_FALSE()
 447     {
 448         return array('expr' => FALSE);
 449     }
 450
 451     /**
 452      *  Return expr for variable reference
 453      *
 454      *  @return array
 455      */
 456     final function expr_var($var)
 457     {
 458         return array('var' => func_get_args());
 459     }
 460
 461     /**
 462      *  Return expr for variable reference
 463      *
 464      *  @return array
 465      */
 466     final function expr_var_ex(Array $var)
 467     {
 468         return array('var' => $var);
 469     }
 470
 471     /**
 472      *  Generate expression for
 473      *  a function calling inside an expression
 474      *
 475      *  @return array
 476      */
 477     final function expr_exec($function)
 478     {
 479         $args = func_get_args();
 480         unset($args[0]);
 481         $args = array_values($args);
 482
 483         return array(
 484             'exec' => $function,
 485             'args' => $args
 486         );
 487     }
 488
 489
 490
 491     /**
 492      *  Generate a generic expression
 493      *
 494      *  @return array
 495      */
 496     final function expr($operation, $expr1, $expr2=NULL)
 497     {
 498         $expr = array('op_expr' => $operation, $expr1);
 499         if ($expr2 !== NULL) {
 500             $expr[] = $expr2;
 501         }
 502
 503         return $expr;
 504     }
 505     // }}}
 506
 507     // get_base_template($base) {{{
 508     /**
 509      *  Handle {% base  "" %} definition. By default only
 510      *  static (string) are supported, but this can be overrided
 511      *  on subclasses.
 512      *
 513      *  This method load the base class, compile it and return
 514      *  the generated code.
 515      *
 516      *  @param array $base Base structure
 517      *
 518      *  @return string Generated source code
 519      */
 520     function get_base_template($base)
 521     {
 522         if (!isset($base['string'])) {
 523             throw new Haanga_CompilerException("Dynamic inheritance is not supported for compilated templates");
 524         }
 525         $file = $base['string'];
 526         list($this->subtemplate, $new_code) = $this->compile_required_template($file);
 527         return $new_code."\n\n";
 528     }
 529     // }}}
 530
 531     // {% base "foo.html" %} {{{
 532     protected function generate_op_base()
 533     {
 534         throw new exception("{% base %} can be only as first statement");
 535     }
 536     // }}}
 537
 538     // Main Loop {{{
 539     protected function generate_op_code($parsed, &$out)
 540     {
 541         if (!is_array($parsed)) {
 542             throw new Haanga_CompilerException("Invalid \$parsed array");
 543         }
 544         foreach ($parsed as $op) {
 545             if (!isset($op['operation'])) {
 546                 throw new Haanga_CompilerException("Malformed $parsed array");
 547             }
 548             if ($this->subtemplate && $this->in_block == 0 && $op['operation'] != 'block') {
 549                 /* ignore most of tokens in subtemplates */
 550                 continue;
 551             }
 552             $method = "generate_op_".$op['operation'];
 553             if (!is_callable(array($this, $method))) {
 554                 throw new Haanga_CompilerException("Compiler: Missing method $method");
 555             }
 556             $this->$method($op, $out);
 557         }
 558     }
 559     // }}}
 560
 561     // Check the current expr  {{{
 562     protected function check_expr(&$expr)
 563     {
 564         if (is_array($expr) && isset($expr['op_expr'])) {
 565             if ($expr['op_expr'] == 'in') {
 566                 if (isset($expr[1]['string'])) {
 567                     $expr = $this->expr("!==",
 568                         $this->expr_exec("strpos", $expr[1], $expr[0]),
 569                         FALSE
 570                     );
 571                 } else {
 572                     $expr = $this->expr("!==", $this->expr_cond(
 573                         $this->expr("==", $this->expr_exec("is_array", $expr[1]), TRUE),
 574                         $this->expr_exec("array_search", $expr[0], $expr[1]),
 575                         $this->expr_exec("strpos", $expr[1], $expr[0])
 576                     ), FALSE);
 577
 578                 }
 579             }
 580             $this->check_expr($expr[0]);
 581             $this->check_expr($expr[1]);
 582         } else {
 583             if (is_array($expr)) {
 584                 if (isset($expr['var'])) {
 585                     $expr = $this->generate_variable_name($expr['var']);
 586                 } else if (isset($expr['var_filter'])) {
 587                     foreach ($expr['var_filter'] as $id => $f) {
 588                         if ($id == 0) {
 589                             $exec = $this->generate_variable_name($f);
 590                         } else {
 591                             $exec = $this->expr_exec($f, $exec);
 592                         }
 593                     }
 594                     $expr = $exec;
 595                 } else if (isset($expr['args'])) {
 596                     /* check every arguments */
 597                     foreach ($expr['args'] as &$v) {
 598                         $this->check_expr($v);
 599                     }
 600                     unset($v);
 601                 } else  if (isset($expr['expr_cond'])) {
 602                     /* Check expr conditions */
 603                     $this->check_expr($expr['expr_cond']);
 604                     $this->check_expr($expr['true']);
 605                     $this->check_expr($expr['false']);
 606                 }
 607             }
 608         }
 609     }
 610     // }}}
 611
 612     // {% if <expr> %} HTML {% else %} TWO {% endif $} {{{
 613     protected function generate_op_if($details, &$out)
 614     {
 615         $this->check_expr($details['expr']);
 616         $out[] = $this->op_if($details['expr']);
 617         $this->generate_op_code($details['body'], $out);
 618         if (isset($details['else'])) {
 619             $out[] = $this->op_else();
 620             $this->generate_op_code($details['else'], $out);
 621         }
 622         $out[] = $this->op_end('if');
 623     }
 624     // }}}
 625
 626     // Overload template {{{
 627     protected function compile_required_template($file)
 628     {
 629         if (!is_file($file)) {
 630             if (isset($this->_base_dir)) {
 631                 $file = $this->_base_dir.'/'.$file;
 632             }
 633         }
 634         if (!is_file($file)) {
 635             throw new Haanga_CompilerException("can't find {$file} file template");
 636         }
 637         $class = get_class($this);
 638         $comp  = new  $class;
 639         $comp->reset();
 640         $code = $comp->compile_file($file);
 641         return array($comp->get_template_name(), $code);
 642     }
 643     // }}}
 644
 645     // include "file.html" | include <var1> {{{
 646     protected function generate_op_include($details, &$out)
 647     {
 648         if (!$details[0]['string']) {
 649             throw new Haanga_CompilerException("Dynamic inheritance is not supported for compilated templates");
 650         }
 651         list($name,$code) = $this->compile_required_template($details[0]['string']);
 652         $this->append .= "\n\n{$code}";
 653         $expr = $this->expr_exec(
 654             $this->get_function_name($this->subtemplate),
 655             $this->expr_var('vars'),
 656             $this->expr_var('blocks'),
 657             $this->expr_TRUE()
 658         );
 659         $this->generate_op_print($expr, $op_code);
 660         $this->generate_op_print($expr, $out);
 661     }
 662     // }}}
 663
 664     // Handle HTML code {{{
 665     protected function generate_op_html($details, &$out)
 666     {
 667         $this->generate_op_print($details, $out);
 668     }
 669     // }}}
 670
 671     // get_var_filtered {{{
 672     /**
 673      *  This method handles all the filtered variable (piped_list(X)'s
 674      *  output in the parser.
 675      *
 676      *
 677      *  @param array $variable      (Output of piped_list(B) (parser))
 678      *  @param array &$varname      Variable name
 679      *  @param bool  $accept_string  TRUE is string output are OK (ie: block.parent)
 680      *
 681      *  @return expr
 682      *
 683      */
 684     function get_filtered_var($variable, &$varname, $accept_string=FALSE)
 685     {
 686         $this->var_is_safe = FALSE;
 687         if (count($variable) > 1) {
 688             $count  = count($variable);
 689             $target = $this->generate_variable_name($variable[0]);
 690
 691             if (!isset($target['var'])) {
 692                 /* block.super can't have any filter */
 693                 throw new Haanga_CompilerException("This variable can't have any filter");
 694             }
 695
 696             for ($i=1; $i < $count; $i++) {
 697                 $func_name = $variable[$i];
 698                 if ($func_name == 'escape') {
 699                     /* to avoid double cleaning */
 700                     $this->var_is_safe = TRUE;
 701                 }
 702                 $args = array(isset($exec) ? $exec : $target);
 703                 $exec = $this->do_filtering($func_name, $args);
 704             }
 705             unset($variable);
 706             $varname = $args[0];
 707             $details = $exec;
 708         } else {
 709             $details = $this->generate_variable_name($variable[0]);
 710             $varname = $variable[0];
 711
 712             if (!isset($details['var']) && !$accept_string) {
 713                 /* generate_variable_name didn't replied a variable, weird case
 714                     currently just used for {{block.super}}.
 715                 */
 716                 throw new Haanga_CompilerException("Invalid variable name {$variable[0]}");
 717             }
 718         }
 719
 720         return $details;
 721     }
 722     // }}}
 723
 724     // generate_op_print_var {{{
 725     /**
 726      *  Generate code to print a variable with its filters, if there is any.
 727      *
 728      *  All variable (except those flagged as |safe) are automatically
 729      *  escaped if autoescape is "on".
 730      *
 731      */
 732     protected function generate_op_print_var($details, &$out)
 733     {
 734
 735         $details = $this->get_filtered_var($details['variable'], $variable, TRUE);
 736
 737         if (!isset($details['var']) && !isset($details['exec'])) {
 738             /* generate_variable_name didn't replied a variable, weird case
 739                 currently just used for {{block.super}}.
 740             */
 741             $this->generate_op_print($details, $out);
 742             return;
 743         }
 744
 745
 746         if (!$this->var_is_safe && $this->autoescape) {
 747             $args    = array($details);
 748             $details = $this->do_filtering('escape', $args);
 749         }
 750
 751         $this->generate_op_print($details, $out);
 752     }
 753     // }}}
 754
 755     // is_last_op_print($out) {{{
 756     /**
 757      *  Return TRUE if the last stacked operation
 758      *  is a print (declare or append_var).
 759      *
 760      *  @param array $out Stack of operations
 761      *
 762      *  @return bool
 763      */
 764     protected function is_last_op_print($out)
 765     {
 766         $last   = count($out)-1;
 767         $sprint = array('print', 'declare', 'append_var');
 768         return $last >= 0 && array_search($out[$last]['op'], $sprint) !== FALSE;
 769     }
 770     // }}}
 771
 772     // {# something #} {{{
 773     protected function generate_op_comment($details, &$out)
 774     {
 775         if ($this->is_last_op_print($out)) {
 776             /* If there is a print declared previously, we pop it
 777                and add it after the cycle declaration
 778              */
 779             $old_print = array_pop($out);
 780         }
 781         $out[] = $this->op_comment($details['comment']);
 782         if (isset($old_print)) {
 783             $out[] = $old_print;
 784         }
 785     }
 786     // }}}
 787
 788     // {% block 'name' %} ... {% endblock %} {{{
 789     protected function generate_op_block($details, &$out)
 790     {
 791         $this->in_block++;
 792         $this->blocks[] = $details['name'];
 793         $block_name = $this->expr_var('blocks', $details['name']);
 794
 795         $this->ob_start($out);
 796         $buffer_var = 'buffer'.$this->ob_start;
 797
 798         $this->generate_op_code($details['body'], $body);
 799
 800         $out = array_merge($out, $body);
 801         $this->ob_start--;
 802
 803         $buffer = $this->expr_var($buffer_var);
 804
 805         /* {{{ */
 806         /**
 807          *  isset previous block (parent block)?
 808          *  TRUE
 809          *      has reference to self::$block_var ?
 810          *      TRUE
 811          *          replace self::$block_var for current block value (buffer)
 812          *      FALSE
 813          *          print parent block
 814          *  FALSE
 815          *      print current block
 816          *
 817          */
 818         $declare = $this->expr_cond(
 819             $this->expr_isset_ex($block_name),
 820             $this->expr_cond(
 821                 $this->expr("===", $this->expr_exec('strpos', $block_name,
 822                         $this->expr_str(self::$block_var)
 823                     ), $this->expr_FALSE()
 824                 ),
 825                 $block_name,
 826                 $this->expr_exec('str_replace',
 827                     $this->expr_str(self::$block_var),
 828                     $buffer,
 829                     $block_name
 830                 )
 831             ),
 832             $buffer
 833         );
 834         /* }}} */
 835
 836         if (!$this->subtemplate) {
 837             $this->generate_op_print($declare, $out);
 838         } else {
 839             $out[] = $this->op_declare($block_name, $declare);
 840             if ($this->in_block > 1) {
 841                 $this->generate_op_print($block_name, $out);
 842             }
 843         }
 844         array_pop($this->blocks);
 845         $this->in_block--;
 846
 847     }
 848     // }}}
 849
 850     // regroup <var1> by <field> as <foo> {{{
 851     protected function generate_op_regroup($details, &$out)
 852     {
 853         $out[] = $this->op_comment("Temporary sorting");
 854         $array = $this->get_filtered_var($details['array'], $varname);
 855
 856         if (isset($array['exec'])) {
 857             $varname = $this->expr_var($details['as']);
 858             $out[]   = $this->op_declare($varname, $array);
 859         }
 860         $var = $this->expr_var('item', $details['row']);
 861
 862         $out[] = $this->op_declare('temp_group', $this->expr_array());
 863         $out[] = $this->op_foreach($varname, 'item');
 864
 865
 866         $out[] = $this->op_declare(array('temp_group', $var, NULL),  $this->expr_var('item'));
 867         $out[] = $this->op_end('foreach');
 868
 869         $out[] = $this->op_comment("Proper format");
 870         $out[] = $this->op_declare($details['as'], $this->expr_array_first(array()));
 871         $out[] = $this->op_foreach('temp_group', 'item', 'group');
 872
 873         $array = $this->expr_array(
 874             array("grouper", $this->expr_var('group')),
 875             array("list",    $this->expr_var('item'))
 876         );
 877
 878         $out[] = $this->op_declare(array($details['as'], NULL), $array );
 879
 880         $out[] = $this->op_end('foreach');
 881         $out[] = $this->op_comment("Sorting done");
 882     }
 883     // }}}
 884
 885     // Get variable name {{{
 886     protected function generate_variable_name($variable)
 887     {
 888         if (is_array($variable)) {
 889             switch ($variable[0]) {
 890             case 'forloop':
 891                 if (!$this->forid) {
 892                     throw new Haanga_CompilerException("Invalid forloop reference outside of a loop");
 893                 }
 894                 switch ($variable[1]) {
 895                 case 'counter':
 896                     $this->forloop[$this->forid]['counter'] = TRUE;
 897                     $variable = 'forcounter1_'.$this->forid;
 898                     break;
 899                 case 'counter0':
 900                     $this->forloop[$this->forid]['counter0'] = TRUE;
 901                     $variable = 'forcounter0_'.$this->forid;
 902                     break;
 903                 case 'last':
 904                     $this->forloop[$this->forid]['counter'] = TRUE;
 905                     $this->forloop[$this->forid]['last']    = TRUE;
 906                     $variable = 'islast_'.$this->forid;
 907                     break;
 908                 case 'first':
 909                     $this->forloop[$this->forid]['first']    = TRUE;
 910                     $variable = 'isfirst_'.$this->forid;
 911                     break;
 912                 case 'revcounter':
 913                     $this->forloop[$this->forid]['revcounter'] = TRUE;
 914                     $variable = 'revcount_'.$this->forid;
 915                     break;
 916                 case 'revcounter0':
 917                     $this->forloop[$this->forid]['revcounter0'] = TRUE;
 918                     $variable = 'revcount0_'.$this->forid;
 919                     break;
 920                 case 'parentloop':
 921                     unset($variable[1]);
 922                     $this->forid--;
 923                     $variable = $this->generate_variable_name(array_values($variable));
 924                     $variable = $variable['var'];
 925                     $this->forid++;
 926                     break;
 927                 default:
 928                     throw new Haanga_CompilerException("Unexpected forloop.{$variable[1]}");
 929                 }
 930                 /* no need to escape it */
 931                 $this->var_is_safe = TRUE;
 932                 break;
 933             case 'block':
 934                 if ($this->in_block == 0) {
 935                     throw new Haanga_CompilerException("Can't use block.super outside a block");
 936                 }
 937                 if (!$this->subtemplate) {
 938                     throw new Haanga_CompilerException("Only subtemplates can call block.super");
 939                 }
 940                 /* no need to escape it */
 941                 $this->var_is_safe = TRUE;
 942                 return $this->expr_str(self::$block_var);
 943                 break;
 944             }
 945
 946         } else if (isset($this->var_alias[$variable])) {
 947             $variable = $this->var_alias[$variable];
 948         }
 949
 950         return $this->expr_var($variable);
 951     }
 952     // }}}
 953
 954     // Print {{{
 955     public function generate_op_print($details, &$out)
 956     {
 957         $last = count($out)-1;
 958         if (isset($details['variable'])) {
 959             $content = $this->generate_variable_name($details['variable']);
 960         } else if (isset($details['html']))  {
 961             $html = $details['html'];
 962             $content = $this->expr_str($html);
 963         } else {
 964             $content = $details;
 965         }
 966
 967         $var_name = 'buffer'.$this->ob_start;
 968
 969         if ($this->ob_start == 0) {
 970             $operation = 'print';
 971         } else {
 972             $operation = 'append_var';
 973         }
 974
 975         if ($last >= 0 && $out[$last]['op'] == $operation && ($operation != 'append_var' || $out[$last]['name'] === $var_name)) {
 976             /* try to append this to the previous print if it exists */
 977             $out[$last][] = $content;
 978         } else {
 979             if ($this->ob_start == 0) {
 980                 $out[] = array('op' => 'print', $content);
 981             } else {
 982                 if (isset($out[$last]) && $out[$last]['op'] == 'declare' && $out[$last]['name'] == $var_name) {
 983                     /* override an empty declaration of a empty buffer
 984                        if the next operation is an 'append'
 985                     */
 986                     $out[$last][] = $content;
 987                 } else {
 988                     $out[] = $this->op_append('buffer'.$this->ob_start, $content);
 989                 }
 990             }
 991         }
 992     }
 993     // }}}
 994
 995     // for [<key>,]<val> in <array> {{{
 996     protected function generate_op_loop($details, &$out)
 997     {
 998         if (isset($details['empty'])) {
 999             $expr = $this->expr('==',
1000                 $this->expr_exec('count', $this->expr_var($details['array'])),
1001                 0
1002             );
1003
1004             $out[] = $this->op_if($expr);
1005             $this->generate_op_code($details['empty'], $out);
1006             $out[] = $this->op_else();
1007         }
1008
1009         /* ForID */
1010         $oldid       = $this->forid;
1011         $this->forid = $oldid+1;
1012
1013         $this->forloop[$this->forid] = array();
1014
1015         /* Loop body */
1016         $for_loop_body = array();
1017         $this->generate_op_code($details['body'], $for_loop_body);
1018
1019         $oid  = $this->forid;
1020         $size = $this->expr_var('psize_'.$oid);
1021
1022         // counter {{{
1023         if (isset($this->forloop[$oid]['counter'])) {
1024             $var   = 'forcounter1_'.$oid;
1025             $out[] = $this->op_declare($var, $this->expr_number(1));
1026             $for_loop_body[] = $this->op_inc($var);
1027         }
1028         // }}}
1029
1030         // counter0 {{{
1031         if (isset($this->forloop[$oid]['counter0'])) {
1032             $var   = 'forcounter0_'.$oid;
1033             $out[] = $this->op_declare($var, $this->expr_number(0) );
1034             $for_loop_body[] = $this->op_inc($var);
1035         }
1036         // }}}
1037
1038         // last {{{
1039         if (isset($this->forloop[$oid]['last'])) {
1040             if (!isset($cnt)) {
1041                 $cnt = $this->op_declare('psize_'.$oid, $this->expr_exec('count', $this->expr_var($details['array'])));
1042                 $out[] = $cnt;
1043             }
1044             $var  = 'islast_'.$oid;
1045             $expr = $this->op_declare($var, $this->expr("==", $this->expr_var('forcounter1_'.$oid), $size));
1046
1047             $out[] = $expr;
1048
1049             $for_loop_body[] = $expr;
1050         }
1051         // }}}
1052
1053         // first {{{
1054         if (isset($this->forloop[$oid]['first'])) {
1055             $out[] = $this->op_declare('isfirst_'.$oid, $this->expr_TRUE());
1056
1057             $for_loop_body[] = $this->op_declare('isfirst_'.$oid, $this->expr_FALSE());
1058         }
1059         // }}}
1060
1061         // revcounter {{{
1062         if (isset($this->forloop[$oid]['revcounter'])) {
1063             if (!isset($cnt)) {
1064                 $cnt   = $this->op_declare('psize_'.$oid, $this->expr_exec('count', $this->expr_var($details['array'])));
1065                 $out[] = $cnt;
1066             }
1067             $var = $this->expr_var('revcount_'.$oid);
1068             $out[] = $this->op_declare($var, $size );
1069
1070             $for_loop_body[] = $this->op_declare($var, $this->expr("-", $var, $this->expr_number(1)));
1071         }
1072          // }}}
1073
1074         // revcounter0 {{{
1075         if (isset($this->forloop[$oid]['revcounter0'])) {
1076             if (!isset($cnt)) {
1077                 $cnt = $this->op_declare('psize_'.$oid, $this->expr_exec('count', $this->expr_var($details['array'])));
1078                 $out[] = $cnt;
1079             }
1080             $var = $this->expr_var('revcount0_'.$oid);
1081             $out[] = $this->op_declare($var, $this->expr("-", $size, $this->expr_number(1)));
1082
1083             $for_loop_body[] = $this->op_declare($var, $this->expr("-", $var, $this->expr_number(1)));
1084         }
1085         // }}}
1086
1087         /* Restore old ForID */
1088         $this->forid = $oldid;
1089
1090         /* Merge loop body  */
1091         $array = $this->get_filtered_var($details['array'], $varname);
1092         $loop  = $this->op_foreach($array, $details['variable'], $details['index']);
1093
1094         $out[] = $loop;
1095         $out   = array_merge($out, $for_loop_body);
1096         $out[] = $this->op_end('foreach');
1097         if (isset($details['empty'])) {
1098             $out[] = $this->op_end('if');
1099         }
1100     }
1101     // }}}
1102
1103     // ifchanged [<var1> <var2] {{{
1104     protected function generate_op_ifchanged($details, &$out)
1105     {
1106         static $ifchanged = 0;
1107
1108         $ifchanged++;
1109         $var1 = 'ifchanged'.$ifchanged;
1110         if (!isset($details['check'])) {
1111             /* ugly */
1112             $this->ob_start($out);
1113             $var2 = 'buffer'.$this->ob_start;
1114
1115             $expr = $this->expr('OR',
1116                 $this->expr_isset($var1, FALSE),
1117                 $this->expr('!=',
1118                     $this->expr_var($var1),
1119                     $this->expr_var($var2)
1120                 )
1121             );
1122
1123             $this->generate_op_code($details['body'], $out);
1124             $this->ob_start--;
1125             $out[] = $this->op_if($expr);
1126             $this->generate_op_print(array('variable' => $var2), $out);
1127             $out[] = $this->op_declare($var1, $this->expr_var($var2));
1128         } else {
1129             /* beauty :-) */
1130             foreach ($details['check'] as $id=>$type) {
1131                 if (!isset($type['var'])) {
1132                     throw new Haanga_CompilerException("Unexpected string {$type['string']}, expected a varabile");
1133                 }
1134                 $this_expr = $this->expr('OR',
1135                     $this->expr_isset("{$var1}[{$id}]", FALSE),
1136                     $this->expr('!=',
1137                         $this->expr_var("{$var1}[{$id}]"),
1138                         $this->expr_var($type['var'])
1139                     )
1140                 );
1141                 if (isset($expr)) {
1142                     $this_expr = $this->expr('AND',
1143                         $this->expr('expr', $this_expr),
1144                         $expr
1145                     );
1146                 }
1147
1148                 $expr = $this_expr;
1149
1150             }
1151             $out[] = $this->op_if($expr);
1152             $this->generate_op_code($details['body'], $out);
1153             $out[] = $this->op_declare($var1, $this->expr_array_first($details['check']));
1154         }
1155
1156         if (isset($details['else'])) {
1157             $out[] = $this->op_else();
1158             $this->generate_op_code($details['else'], $out);
1159         }
1160         $out[] = $this->op_end('if');
1161     }
1162     // }}}
1163
1164     // autoescape ON|OFF {{{
1165     function generate_op_autoescape($details, &$out)
1166     {
1167         $old_autoescape   = $this->autoescape;
1168         $this->autoescape = strtolower($details['value']) == 'on';
1169         $this->generate_op_code($details['body'], $out);
1170         $this->autoescape = $old_autoescape;
1171     }
1172     // }}}
1173
1174     // ob_Start(array &$out) {{{
1175     /**
1176      *  Start a new buffering
1177      *
1178      */
1179     function ob_start(&$out)
1180     {
1181         $this->ob_start++;
1182         $out[] = $this->op_declare('buffer'.$this->ob_start, array('string' => ''));
1183     }
1184     // }}}
1185
1186     // Custom Tags {{{
1187     function get_custom_tag($name)
1188     {
1189         $function = $this->get_function_name().'_tag_'.$name;
1190         $this->append .= "\n\n".Haanga_Extensions::getInstance('Haanga_Tag')->getFunctionBody($name, $function);
1191         return $function;
1192     }
1193
1194     /**
1195      *  Generate needed code for custom tags (tags that aren't
1196      *  handled by the compiler).
1197      *
1198      */
1199     function generate_op_custom_tag($details, &$out)
1200     {
1201         static $tags;
1202         if (!$tags) {
1203             $tags = Haanga_Extensions::getInstance('Haanga_Tag');
1204         }
1205
1206         $tag_name    = $details['name'];
1207         $tagFunction = $tags->getFunctionAlias($tag_name);
1208
1209         if (!$tagFunction && !$tags->hasGenerator($tag_name)) {
1210             $function = $this->get_custom_tag($tag_name, isset($details['as']));
1211         } else {
1212             $function = $tagFunction;
1213         }
1214
1215         if (isset($details['body'])) {
1216             /*
1217                if the custom tag has 'body'
1218                then it behave the same way as a filter
1219             */
1220             $this->ob_start($out);
1221             $this->generate_op_code($details['body'], $out);
1222             $target = $this->expr_var('buffer'.$this->ob_start);
1223             if ($tags->hasGenerator($tag_name)) {
1224                 $exec = $tags->generator($tag_name, $this, array($target));
1225             } else {
1226                 $exec = $this->expr_exec($function, $target);
1227             }
1228             $this->ob_start--;
1229             $this->generate_op_print($exec, $out);
1230             return;
1231         }
1232
1233         $var  = isset($details['as']) ? $details['as'] : NULL;
1234         $args = array_merge(array($function), $details['list']);
1235
1236         if ($tags->hasGenerator($tag_name)) {
1237             $exec = $tags->generator($tag_name, $this, $details['list'], $var);
1238             if ($exec InstanceOf ArrayIterator) {
1239                 /*
1240                    The generator returned more than one statement,
1241                    so we assume the output is already handled
1242                    by one of those stmts.
1243                 */
1244                 $out = array_merge($out, $exec->getArrayCopy());
1245                 return;
1246             }
1247         } else {
1248             $exec = call_user_func_array(array($this, 'expr_exec'), $args);
1249         }
1250
1251         if ($var) {
1252             $out[] = $this->op_declare($var, $exec);
1253         } else {
1254             $this->generate_op_print($exec, $out);
1255         }
1256     }
1257     // }}}
1258
1259     // with <variable> as <var> {{{
1260     /**
1261      *
1262      *
1263      */
1264     function generate_op_alias($details, &$out)
1265     {
1266         $this->var_alias[ $details['as'] ] = $details['var'];
1267         $this->generate_op_code($details['body'], $out);
1268         unset($this->var_alias[ $details['as'] ] );
1269     }
1270     // }}}
1271
1272     // Custom Filters {{{
1273     function get_custom_filter($name)
1274     {
1275         $function = $this->get_function_name().'_filter_'.$name;
1276         $this->append .= "\n\n".Haanga_Extensions::getInstance('Haanga_Filter')->getFunctionBody($name, $function);
1277         return $function;
1278     }
1279
1280
1281     function do_filtering($name, $args)
1282     {
1283         static $filter;
1284         if (!$filter) {
1285             $filter = Haanga_Extensions::getInstance('Haanga_Filter');
1286         }
1287
1288         if (is_array($name)) {
1289             /*
1290                prepare array for ($func_name, $arg1, $arg2 ... )
1291                where $arg1 = last expression and $arg2.. $argX is
1292                defined in the template
1293              */
1294             $args = array_merge($args, $name['args']);
1295             $name = $name[0];
1296         }
1297
1298         if (!$filter->isValid($name)) {
1299             throw new Haanga_CompilerException("{$name} is an invalid filter");
1300         }
1301         if ($filter->hasGenerator($name)) {
1302             return $filter->generator($name, $this, $args);
1303         }
1304         $fnc = $filter->getFunctionAlias($name);
1305         if (!$fnc) {
1306             $fnc = $this->get_custom_filter($name);
1307         }
1308         $args = array_merge(array($fnc), $args);
1309         $exec = call_user_func_array(array($this, 'expr_exec'), $args);
1310
1311         return $exec;
1312     }
1313
1314     function generate_op_filter($details, &$out)
1315     {
1316         $this->ob_start($out);
1317         $this->generate_op_code($details['body'], $out);
1318         $target = $this->expr_var('buffer'.$this->ob_start);
1319         foreach ($details['functions'] as $f) {
1320             $param = (isset($exec) ? $exec : $target);
1321             $exec  = $this->do_filtering($f, array($param));
1322         }
1323         $this->ob_start--;
1324         $this->generate_op_print($exec, $out);
1325     }
1326     // }}}
1327
1328     final static function main_cli()
1329     {
1330         $argv = $GLOBALS['argv'];
1331         $haanga = new Haanga_Compiler;
1332         $code = $haanga->compile_file($argv[1]);
1333         echo "<?php\n\n$code\n";
1334     }
1335
1336 }
1337
1338
1339 /**
1340  *  Runtime compiler
1341  *
1342  */
1343 final class Haanga_Compiler_Runtime extends Haanga_Compiler
1344 {
1345
1346     // get_function_name($name=NULL) {{{
1347     /**
1348      *
1349      *
1350      */
1351     function get_function_name($name=NULL)
1352     {
1353         if ($name === NULL) {
1354             $name = $this->name;
1355         }
1356         return "haanga_".sha1($name);
1357     }
1358     // }}}
1359
1360     // set_template_name($path) {{{
1361     function set_template_name($path)
1362     {
1363         return $path;
1364     }
1365     // }}}
1366
1367     // Override {% include %} {{{
1368     protected function generate_op_include($details, &$out)
1369     {
1370         $expr = $this->expr_exec(
1371             'Haanga::Load',
1372             $details[0],
1373             $this->expr_var('vars'),
1374             $this->expr_TRUE(),
1375             $this->expr_var('blocks')
1376         );
1377         $this->generate_op_print(array('expr' => $expr), $out);
1378     }
1379     // }}}
1380
1381     // {% base "" %} {{{
1382     function expr_call_base_template()
1383     {
1384         return $this->expr_exec(
1385             'Haanga::Load',
1386             $this->subtemplate,
1387             $this->expr_var('vars'),
1388             $this->expr_TRUE(),
1389             $this->expr_var('blocks')
1390         );
1391     }
1392     // }}}
1393
1394     // get_base_template($base) {{{
1395     function get_base_template($base)
1396     {
1397         $this->subtemplate = $base;
1398     }
1399     // }}}
1400
1401     // Override get_Custom_tag {{{
1402     /**
1403      *
1404      *
1405      */
1406     function get_custom_tag($name)
1407     {
1408         $loaded = &$this->tags;
1409
1410         if (!isset($loaded[$name])) {
1411             $this->prepend_op[] = $this->op_comment("Load tag {$name} definition");
1412             $this->prepend_op[] = $this->op_expr($this->expr_exec("Haanga::doInclude", $this->Expr_str(Haanga_Extensions::getInstance('Haanga_Tag')->getFilePath($name, FALSE))));
1413             $loaded[$name] = TRUE;
1414         }
1415
1416         $name = ucfirst($name);
1417
1418         return "{$name}_Tag::main";
1419     }
1420     // }}}
1421
1422     // Override get_custom_filter {{{
1423     function get_custom_filter($name)
1424     {
1425         $loaded = &$this->filters;
1426
1427         if (!isset($loaded[$name])) {
1428             $this->prepend_op[] = $this->op_comment("Load filter {$name} definition");
1429             $this->prepend_op[] = $this->op_expr($this->expr_exec("Haanga::doInclude", $this->Expr_str(Haanga_Extensions::getInstance('Haanga_Filter')->getFilePath($name, FALSE))));
1430             $loaded[$name] = TRUE;
1431         }
1432
1433         $name = ucfirst($name);
1434
1435         return "{$name}_Filter::main";
1436     }
1437     // }}}
1438
1439 }
1440
1441 /*
1442  * Local variables:
1443  * tab-width: 4
1444  * c-basic-offset: 4
1445  * End:
1446  * vim600: sw=4 ts=4 fdm=marker
1447  * vim<600: sw=4 ts=4
1448  */