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