lib/Haanga/Compiler.php

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