From ab1a35700cd8590ec8c674c4e668820c04fa7d53 Mon Sep 17 00:00:00 2001 From: Kevin Chabowski Date: Mon, 28 Oct 2013 23:34:49 +0100 Subject: New STE version included --- r7r_repo/main.php | 2 +- r7r_repo/ste.php | 1668 +++++++++++++++++++++++++++++++++++ r7r_repo/stupid_template_engine.php | 1297 --------------------------- 3 files changed, 1669 insertions(+), 1298 deletions(-) create mode 100644 r7r_repo/ste.php delete mode 100644 r7r_repo/stupid_template_engine.php diff --git a/r7r_repo/main.php b/r7r_repo/main.php index a7f075b..6ea6e2f 100644 --- a/r7r_repo/main.php +++ b/r7r_repo/main.php @@ -43,7 +43,7 @@ CREATE TABLE IF NOT EXISTS `PREFIX_users` ( } /* Include more files... */ -require_once(dirname(__FILE__) . "/stupid_template_engine.php"); +require_once(dirname(__FILE__) . "/ste.php"); require_once(dirname(__FILE__) . "/models.php"); require_once(dirname(__FILE__) . "/urlprocess.php"); require_once(dirname(__FILE__) . "/pwhash.php"); diff --git a/r7r_repo/ste.php b/r7r_repo/ste.php new file mode 100644 index 0000000..03d2d68 --- /dev/null +++ b/r7r_repo/ste.php @@ -0,0 +1,1668 @@ +tpl = $tpl; + $this->offset = $off; + } +} + +class TextNode extends ASTNode { + public $text; + public function __construct($tpl, $off, $text = "") { + parent::__construct($tpl, $off); + $this->text = $text; + } +} + +class TagNode extends ASTNode { + public $name; + public $params = array(); + public $sub = array(); + public function __construct($tpl, $off, $name = "") { + parent::__construct($tpl, $off); + $this->name = $name; + } +} + +class VariableNode extends ASTNode { + public $name; + public $arrayfields = array(); + public function transcompile() { + $varaccess = '@$ste->vars[' . (is_numeric($this->name) ? $this->name : '"' . escape_text($this->name) . '"'). ']'; + foreach($this->arrayfields as $af) { + if((count($af) == 1) and ($af[0] instanceof TextNode) and is_numeric($af[0]->text)) { + $varaccess .= '[' . $af->text . ']'; + } else { + $varaccess .= '[' . implode(".", array_map(function($node) { + if($node instanceof TextNode) { + return "\"" . escape_text($node->text) . "\""; + } else if($node instanceof VariableNode) { + return $node->transcompile(); + } + }, $af)). ']'; + } + } + return $varaccess; + } +} + +class ParseCompileError extends \Exception { + public $msg; + public $tpl; + public $off; + + public function __construct($msg, $tpl, $offset, $code = 0, $previous = NULL) { + $this->msg = $msg; + $this->tpl = $tpl; + $this->off = $offset; + $this->message = "$msg (Template $tpl, Offset $offset)"; + } + + public function rewrite($code) { + $line = substr_count(str_replace("\r\n", "\n", substr($code, 0, $this->off)), "\n") + 1; + $this->message = "{$this->msg} (Template {$this->tpl}, Line $line)"; + $this->is_rewritten = true; + } +} + +/* + * Class: RuntimeError + * An Exception that a tag can throw, if a non-fatal runtime error occurred. + * By default this will return in no output at all. But if is false, this will generate a error message instead of the tag's output. + */ +class RuntimeError extends \Exception {} + +/* + * Class: FatalRuntimeError + * An Exception a tag can throw, if a fatal (irreparable) runtime error occurred. + * This Exception will always "bubble up" so you probably want to catch them. Remember that this exception is also in the namespace ste! + */ +class FatalRuntimeError extends \Exception {} + +/* + * Class: Parser + * The class, where the parser lives in. Can not be constructed manually. + * Use the static method parse. + */ +class Parser { + private $text; + private $name; + private $off; + private $len; + + const PARSE_SHORT = 1; + const PARSE_TAG = 2; + + const ESCAPES_DEFAULT = '$?~{}|\\'; + + private function __construct($text, $name) { + $this->text = $text; + $this->name = $name; + $this->off = 0; + $this->len = mb_strlen($text); + } + + private function next($n = 1) { + if($n <= 0) { + throw new \InvalidArgumentException("\$n must be > 0"); + } + $c = mb_substr($this->text, $this->off, $n); + $this->off = min($this->off + $n, $this->len); + return $c; + } + + + private function back($n = 1) { + if($n <= 0) { + throw new \InvalidArgumentException("\$n must be > 0"); + } + $this->off = max($this->off - $n, 0); + } + + private function search_off($needle) { + return mb_strpos($this->text, $needle, $this->off); + } + + private function search_multi($needles) { + $oldoff = $this->off; + + $minoff = $this->len; + $which = NULL; + + foreach($needles as $key => $needle) { + if(($off = $this->search_off($needle)) === false) { + continue; + } + + if($off < $minoff) { + $minoff = $off; + $which = $key; + } + } + + $this->off = $minoff + (($which === NULL) ? 0 : mb_strlen((string) $needles[$which])); + + return array($which, $minoff, mb_substr($this->text, $oldoff, $minoff - $oldoff), $oldoff); + } + + private function search($needle) { + $oldoff = $this->off; + + $off = $this->search_off($needle); + if($off === false) { + $this->off = $this->len; + return array(false, mb_substr($this->text, $oldoff), $oldoff); + } + + $this->off = $off + mb_strlen($needle); + return array($off, mb_substr($this->text, $oldoff, $off - $oldoff), $oldoff); + } + + private function take_while($cb) { + $s = ""; + while($c = $this->next()) { + if(!call_user_func($cb, $c)) { + $this->back(); + return $s; + } + $s .= $c; + } + return $s; + } + + private function skip_ws() { + $this->take_while("ctype_space"); + } + + private function get_name() { + $off = $this->off; + $name = $this->take_while(function($c) { return ctype_alnum($c) || ($c == "_"); }); + if(mb_strlen($name) == 0) { + throw new ParseCompileError("Expected a name (alphanumeric chars + '_', at least one char)", $this->name, $off); + } + return $name; + } + + /* + * Function: parse + * Parses the input into an AST. + * + * You only need this function, if you want to manually trnascompile a template. + * + * Parameters: + * $text - The input code. + * $name - The name of the template. + * + * Returns: + * An array of objects. + * + * Throws: + * + */ + public static function parse($text, $name) { + $obj = new self($text, $name); + $res = $obj->parse_text( + self::ESCAPES_DEFAULT, /* Escapes */ + self::PARSE_SHORT | self::PARSE_TAG /* Flags */ + ); + return self::tidyup_ast($res[0]); + } + + private static function tidyup_ast($ast) { + $out = array(); + + $prevtext = NULL; + $first = true; + + foreach($ast as $node) { + if($node instanceof TextNode) { + if($prevtext === NULL) { + $prevtext = $node; + } else { + $prevtext->text .= $node->text; + } + } else { + if($prevtext !== NULL) { + if($first) { + $prevtext->text = ltrim($prevtext->text); + } + if($prevtext->text != "") { + $out[] = $prevtext; + } + } + $prevtext = NULL; + $first = false; + + if($node instanceof TagNode) { + $node->sub = self::tidyup_ast($node->sub); + foreach($node->params as $k => &$v) { + $v = self::tidyup_ast($v); + } + unset($v); + } else { /* VariableNode */ + foreach($node->arrayfields as &$v) { + $v = self::tidyup_ast($v); + } + unset($v); + } + + $out[] = $node; + } + } + + if($prevtext !== NULL) { + if($first) { + $prevtext->text = ltrim($prevtext->text); + } + if($prevtext->text != "") { + $out[] = $prevtext; + } + } + + return $out; + } + + private function parse_text($escapes, $flags, $breakon = NULL, $separator = NULL, $nullaction = NULL, $opentag = NULL, $openedat = -1) { + $elems = array(); + $astlist = array(); + + $needles = array( + "commentopen" => "", + "rawopen" => "", + "escape" => '\\', + "varcurlyopen" => '${', + "var" => '$', + ); + + if($flags & self::PARSE_TAG) { + $needles["tagopen"] = 'search_multi($needles); + + $astlist[] = new TextNode($this->name, $offbefore, $before); + + switch($which) { + case NULL: + if($nullaction === NULL) { + $elems[] = $astlist; + return $elems; + } else { + call_user_func($nullaction); + } + break; + case "commentopen": + list($off, $before, $offbefore) = $this->search(""); + if($off === false) { + throw new ParseCompileError("ste:comment was not closed", $this->name, $offbefore); + } + break; + case "rawopen": + $off_start = $off; + list($off, $before, $offbefore) = $this->search(""); + if($off === false) { + throw new ParseCompileError("ste:rawtext was not closed", $this->name, $off_start); + } + $astlist[] = new TextNode($this->name, $off_start, $before); + break; + case "tagopen": + $astlist[] = $this->parse_tag($off); + break; + case "closetagopen": + $off_start = $off; + $name = $this->get_name(); + $this->skip_ws(); + $off = $this->off; + if($this->next() != ">") { + throw new ParseCompileError("Expected '>' in closing ste-Tag", $this->name, $off); + } + + if($opentag === NULL) { + throw new ParseCompileError("Found closing ste:$name tag, but no tag was opened", $this->name, $off_start); + } + if($opentag != $name) { + throw new ParseCompileError("Open ste:$opentag was not closed", $this->name, $openedat); + } + + $elems[] = $astlist; + return $elems; + case "escape": + $c = $this->next(); + if(mb_strpos($escapes, $c) !== false) { + $astlist[] = new TextNode($this->name, $off, $c); + } else { + $astlist[] = new TextNode($this->name, $off, '\\'); + $this->back(); + } + break; + case "shortifopen": + $shortelems = $this->parse_short("?{", $off); + if(count($shortelems) != 3) { + throw new ParseCompileError("A short if tag must have the form ?{..|..|..}", $this->name, $off); + } + + list($cond, $then, $else) = $shortelems; + $thentag = new TagNode($this->name, $off); + $thentag->name = "then"; + $thentag->sub = $then; + + $elsetag = new TagNode($this->name, $off); + $elsetag->name = "else"; + $elsetag->sub = $else; + + $iftag = new TagNode($this->name, $off); + $iftag->name = "if"; + $iftag->sub = $cond; + $iftag->sub[] = $thentag; + $iftag->sub[] = $elsetag; + + $astlist[] = $iftag; + break; + case "shortcompopen": + $shortelems = $this->parse_short("~{", $off); + if(count($shortelems) != 3) { + throw new ParseCompileError("A short comparasion tag must have the form ~{..|..|..}", $this->name, $off); + } + + // TODO: What will happen, if a tag was in one of the elements? + list($a, $op, $b) = $shortelems; + $cmptag = new TagNode($this->name, $off); + $cmptag->name = "cmp"; + $cmptag->params["text_a"] = $a; + $cmptag->params["op"] = $op; + $cmptag->params["text_b"] = $b; + + $astlist[] = $cmptag; + break; + case "sep": + $elems[] = $astlist; + $astlist = array(); + break; + case "varcurlyopen": + $astlist[] = $this->parse_var($off, true); + break; + case "var": + $astlist[] = $this->parse_var($off, false); + break; + case "break": + $elems[] = $astlist; + return $elems; + } + } + + $elems[] = $astlist; + return $elems; + } + + private function parse_short($shortname, $openedat) { + $tplname = $this->name; + + return $this->parse_text( + self::ESCAPES_DEFAULT, /* Escapes */ + self::PARSE_SHORT | self::PARSE_TAG, /* Flags */ + '}', /* Break on */ + '|', /* Separator */ + function() use ($shortname, $tplname, $openedat) { /* NULL action */ + throw new ParseCompileError("Unclosed $shortname", $tplname, $openedat); + }, + NULL, /* Open tag */ + $openedat /* Opened at */ + ); + } + + private function parse_var($openedat, $curly) { + $varnode = new VariableNode($this->name, $openedat); + $varnode->name = $this->get_name(); + $varnode->arrayfields = $this->parse_array(); + + if(($curly) && ($this->next() != "}")) { + throw new ParseCompileError("Unclosed '\${'", $this->name, $openedat); + } + return $varnode; + } + + private function parse_array() { + $tplname = $this->name; + + $arrayfields = array(); + + while($this->next() == "[") { + $openedat = $this->off - 1; + $res = $this->parse_text( + self::ESCAPES_DEFAULT, /* Escapes */ + 0, /* Flags */ + ']', /* Break on */ + NULL, /* Separator */ + function() use ($tplname, $openedat) { /* NULL action */ + throw new ParseCompileError("Unclosed array access '[...]'", $tplname, $openedat); + }, + NULL, /* Open tag */ + $openedat /* Opened at */ + ); + $arrayfields[] = $res[0]; + } + + $this->back(); + return $arrayfields; + } + + private function parse_tag($openedat) { + $tplname = $this->name; + + $this->skip_ws(); + $tag = new TagNode($this->name, $openedat); + $name = $tag->name = $this->get_name(); + $tag->params = array(); + $tag->sub = array(); + + for(;;) { + $this->skip_ws(); + + switch($this->next()) { + case '/': /* Self-closing tag */ + $this->skip_ws(); + if($this->next() != '>') { + throw new ParseCompileError("Unclosed opening )", $this->name, $openedat); + } + + return $tag; + case '>': + $sub = $this->parse_text( + self::ESCAPES_DEFAULT, /* Escapes */ + self::PARSE_SHORT | self::PARSE_TAG, /* Flags */ + NULL, /* Break on */ + NULL, /* Separator */ + function() use ($name, $tplname, $openedat) { /* NULL action */ + throw new ParseCompileError("Open ste:$name tag was not closed", $tplname, $openedat); + }, + $tag->name, /* Open tag */ + $openedat /* Opened at */ + ); + $tag->sub = $sub[0]; + return $tag; + default: + $this->back(); + + $param = $this->get_name(); + + $this->skip_ws(); + if($this->next() != '=') { + throw new ParseCompileError("Expected '=' after tag parameter name", $this->name, $this->off - 1); + } + $this->skip_ws(); + + $quot = $this->next(); + if(($quot != '"') && ($quot != "'")) { + throw new ParseCompileError("Expected ' or \" after '=' of tag parameter", $this->name, $this->off - 1); + } + + $off = $this->off - 1; + $paramval = $this->parse_text( + self::ESCAPES_DEFAULT . $quot, /* Escapes */ + 0, /* Flags */ + $quot, /* Break on */ + NULL, /* Separator */ + function() use ($quot, $tplname, $off) { /* NULL action */ + throw new ParseCompileError("Open tag parameter value ($quot) was not closed", $tplname, $off); + }, + NULL, /* Open tag */ + $off /* Opened at */ + ); + $tag->params[$param] = $paramval[0]; + } + } + } +} + +function indent_code($code) { + return implode( + "\n", + array_map(function($line) { return "\t$line"; }, explode("\n", $code)) + ); +} + +/* We could also just eval() the $infix_math code, but this is much cooler :-D (Parser inception) */ +function shunting_yard($infix_math) { + $operators = array( + "+" => array("l", 2), + "-" => array("l", 2), + "*" => array("l", 3), + "/" => array("l", 3), + "^" => array("r", 4), + "_" => array("r", 5), + "(" => array("", 0), + ")" => array("", 0) + ); + + preg_match_all("/\s*(?:(?:[+\\-\\*\\/\\^\\(\\)])|(\\d*[\\.]?\\d*))\\s*/s", $infix_math, $tokens, PREG_PATTERN_ORDER); + $tokens_raw = array_filter(array_map('trim', $tokens[0]), function($x) { return ($x === "0") || (!empty($x)); }); + $output_queue = array(); + $op_stack = array(); + + $lastpriority = NULL; + /* Make - unary, if neccessary */ + $tokens = array(); + foreach($tokens_raw as $token) { + $priority = isset($operators[$token]) ? $operators[$token][1] : -1; + if(($token == "-") && (($lastpriority === NULL) || ($lastpriority >= 0))) { + $priority = $operators["_"][1]; + $tokens[] = "_"; + } else { + $tokens[] = $token; + } + $lastpriority = $priority; + } + + while(!empty($tokens)) { + $token = array_shift($tokens); + if(is_numeric($token)) { + $output_queue[] = $token; + } else if($token == "(") { + $op_stack[] = $token; + } else if($token == ")") { + $lbr_found = false; + while(!empty($op_stack)) { + $op = array_pop($op_stack); + if($op == "(") { + $lbr_found = true; + break; + } + $output_queue[] = $op; + } + if(!$lbr_found) { + throw new RuntimeError("Bracket mismatch."); + } + } else if(!isset($operators[$token])) { + throw new RuntimeError("Invalid token ($token): Not a number, bracket or operator. Stop."); + } else { + $priority = $operators[$token][1]; + if($operators[$token][0] == "l") { + while((!empty($op_stack)) and ($priority <= $operators[$op_stack[count($op_stack)-1]][1])) { + $output_queue[] = array_pop($op_stack); + } + } else { + while((!empty($op_stack)) and ($priority < $operators[$op_stack[count($op_stack)-1]][1])) { + $output_queue[] = array_pop($op_stack); + } + } + $op_stack[] = $token; + } + } + + while(!empty($op_stack)) { + $op = array_pop($op_stack); + if($op == "(") { + throw new RuntimeError("Bracket mismatch..."); + } + $output_queue[] = $op; + } + + return $output_queue; +} + +function pop2(&$array) { + $rv = array(array_pop($array), array_pop($array)); + if(array_search(NULL, $rv, true) !== false) { + throw new RuntimeError("Not enough numbers on stack. Invalid formula."); + } + return $rv; +} + +function calc_rpn($rpn) { + $stack = array(); + foreach($rpn as $token) { + switch($token) { + case "+": + list($b, $a) = pop2($stack); + $stack[] = $a + $b; + break; + case "-": + list($b, $a) = pop2($stack); + $stack[] = $a - $b; + break; + case "*": + list($b, $a) = pop2($stack); + $stack[] = $a * $b; + break; + case "/": + list($b, $a) = pop2($stack); + $stack[] = $a / $b; + break; + case "^": + list($b, $a) = pop2($stack); + $stack[] = pow($a, $b); + break; + case "_": + $a = array_pop($stack); + if($a === NULL) { + throw new RuntimeError("Not enough numbers on stack. Invalid formula."); + } + $stack[] = -$a; + break; + default: + $stack[] = $token; + break; + } + } + return array_pop($stack); +} + +function loopbody($code) { + return "try\n{\n" . indent_code($code) . "\n}\ncatch(\ste\BreakException \$e) { break; }\ncatch(\ste\ContinueException \$e) { continue; }\n"; +} + +$ste_builtins = array( + "if" => function($ast) { + $output = ""; + $condition = array(); + $then = NULL; + $else = NULL; + + foreach($ast->sub as $node) { + if(($node instanceof TagNode) and ($node->name == "then")) { + $then = $node->sub; + } else if(($node instanceof TagNode) and ($node->name == "else")) { + $else = $node->sub; + } else { + $condition[] = $node; + } + } + + if($then === NULL) { + throw new ParseCompileError("Transcompile error: Missing in .", $ast->tpl, $ast->offset); + } + + $output .= "\$outputstack[] = \"\";\n\$outputstack_i++;\n"; + $output .= _transcompile($condition); + $output .= "\$outputstack_i--;\nif(\$ste->evalbool(array_pop(\$outputstack)))\n{\n"; + $output .= indent_code(_transcompile($then)); + $output .= "\n}\n"; + if($else !== NULL) { + $output .= "else\n{\n"; + $output .= indent_code(_transcompile($else)); + $output .= "\n}\n"; + } + return $output; + }, + "cmp" => function($ast) { + $operators = array( + array('eq', '=='), + array('neq', '!='), + array('lt', '<'), + array('lte', '<='), + array('gt', '>'), + array('gte', '>=') + ); + + $code = ""; + + if(isset($ast->params["var_b"])) { + list($val, $pre) = _transcompile($ast->params["var_b"], true); + $code .= $pre; + $b = '$ste->get_var_by_name(' . $val . ')'; + } else if(isset($ast->params["text_b"])) { + list($b, $pre) = _transcompile($ast->params["text_b"], true); + $code .= $pre; + } else { + throw new ParseCompileError("Transcompile error: neiter var_b nor text_b set in .", $ast->tpl, $ast->offset); + } + + if(isset($ast->params["var_a"])) { + list($val, $pre) = _transcompile($ast->params["var_a"], true); + $code .= $pre; + $a = '$ste->get_var_by_name(' . $val . ')'; + } else if(isset($ast->params["text_a"])) { + list($a, $pre) = _transcompile($ast->params["text_a"], true); + $code .= $pre; + } else { + throw new ParseCompileError("Transcompile error: neiter var_a nor text_a set in .", $ast->tpl, $ast->offset); + } + + if(!isset($ast->params["op"])) { + throw new ParseCompileError("Transcompile error: op not given in .", $ast->tpl, $ast->offset); + } + if((count($ast->params["op"]) == 1) and ($ast->params["op"][0] instanceof TextNode)) { + /* Operator is known at compile time, this saves *a lot* of output code! */ + $op = trim($ast->params["op"][0]->text); + $op_php = NULL; + foreach($operators as $v) { + if($v[0] == $op) { + $op_php = $v[1]; + break; + } + } + if($op_php === NULL) { + throw new ParseCompileError("Transcompile Error: Unknown operator in ", $ast->tpl, $ast->offset); + } + $code .= "\$outputstack[\$outputstack_i] .= (($a) $op_php ($b)) ? 'yes' : '';\n"; + } else { + list($val, $pre) = _transcompile($ast->params["op"], true); + $code .= $pre . "switch(trim(" . $val . "))\n{\n\t"; + $code .= implode("", array_map( + function($op) use ($a,$b) + { + list($op_stetpl, $op_php) = $op; + return "case '$op_stetpl':\n\t\$outputstack[\$outputstack_i] .= (($a) $op_php ($b)) ? 'yes' : '';\n\tbreak;\n\t"; + }, $operators + )); + $code .= "default: throw new \\ste\\RuntimeError('Unknown operator in .');\n}\n"; + } + return $code; + }, + "not" => function($ast) { + $code = "\$outputstack[] = '';\n\$outputstack_i++;\n"; + $code .= _transcompile($ast->sub); + $code .= "\$outputstack_i--;\n\$outputstack[\$outputstack_i] .= (!\$ste->evalbool(array_pop(\$outputstack))) ? 'yes' : '';\n"; + return $code; + }, + "even" => function($ast) { + $code = "\$outputstack[] = '';\n\$outputstack_i++;\n"; + $code .= _transcompile($ast->sub); + $code .= "\$outputstack_i--;\n\$tmp_even = array_pop(\$outputstack);\n\$outputstack[\$outputstack_i] .= (is_numeric(\$tmp_even) and (\$tmp_even % 2 == 0)) ? 'yes' : '';\n"; + return $code; + }, + "for" => function($ast) { + $code = ""; + $loopname = "forloop_" . str_replace(".", "_", uniqid("",true)); + if(empty($ast->params["start"])) { + throw new ParseCompileError("Transcompile error: Missing 'start' parameter in .", $ast->tpl, $ast->offset); + } + list($val, $pre) = _transcompile($ast->params["start"], true); + $code .= $pre; + $code .= "\$${loopname}_start = " . $val . ";\n"; + + if(empty($ast->params["stop"])) { + throw new ParseCompileError("Transcompile error: Missing 'end' parameter in .", $ast->tpl, $ast->offset); + } + list($val, $pre) = _transcompile($ast->params["stop"], true); + $code .= $pre; + $code .= "\$${loopname}_stop = " . $val . ";\n"; + + $step = NULL; /* i.e. not known at compilation time */ + if(empty($ast->params["step"])) { + $step = 1; + } else if((count($ast->params["step"]) == 1) and ($ast->params["step"][0] instanceof TextNode)) { + $step = $ast->params["step"][0]->text + 0; + } else { + list($val, $pre) = _transcompile($ast->params["step"], true); + $code .= $pre; + $code .= "\$${loopname}_step = " . $val . ";\n"; + } + + if(!empty($ast->params["counter"])) { + list($val, $pre) = _transcompile($ast->params["counter"], true); + $code .= $pre; + $code .= "\$${loopname}_countername = " . $val . ";\n"; + } + + $loopbody = empty($ast->params["counter"]) ? "" : "\$ste->set_var_by_name(\$${loopname}_countername, \$${loopname}_counter);\n"; + $loopbody .= _transcompile($ast->sub); + $loopbody = indent_code("{\n" . loopbody(indent_code($loopbody)) . "\n}\n"); + + if($step === NULL) { + $code .= "if(\$${loopname}_step == 0)\n\tthrow new \\ste\\RuntimeError('step can not be 0 in .');\n"; + $code .= "if(\$${loopname}_step > 0)\n{\n"; + $code .= "\tfor(\$${loopname}_counter = \$${loopname}_start; \$${loopname}_counter <= \$${loopname}_stop; \$${loopname}_counter += \$${loopname}_step)\n"; + $code .= $loopbody; + $code .= "\n}\nelse\n{\n"; + $code .= "\tfor(\$${loopname}_counter = \$${loopname}_start; \$${loopname}_counter >= \$${loopname}_stop; \$${loopname}_counter += \$${loopname}_step)\n"; + $code .= $loopbody; + $code .= "\n}\n"; + } else if($step == 0) { + throw new ParseCompileError("Transcompile Error: step can not be 0 in .", $ast->tpl, $ast->offset); + } else if($step > 0) { + $code .= "for(\$${loopname}_counter = \$${loopname}_start; \$${loopname}_counter <= \$${loopname}_stop; \$${loopname}_counter += $step)\n$loopbody\n"; + } else { + $code .= "for(\$${loopname}_counter = \$${loopname}_start; \$${loopname}_counter >= \$${loopname}_stop; \$${loopname}_counter += $step)\n$loopbody\n"; + } + + return $code; + }, + "foreach" => function($ast) { + $loopname = "foreachloop_" . str_replace(".", "_", uniqid("",true)); + $code = ""; + + if(empty($ast->params["array"])) { + throw new ParseCompileError("Transcompile Error: array not given in .", $ast->tpl, $ast->offset); + } + list($val, $pre) = _transcompile($ast->params["array"], true); + $code .= $pre; + $code .= "\$${loopname}_arrayvar = " . $val . ";\n"; + + if(empty($ast->params["value"])) { + throw new ParseCompileError("Transcompile Error: value not given in .", $ast->tpl, $ast->offset); + } + list($val, $pre) = _transcompile($ast->params["value"], true); + $code .= $pre; + $code .= "\$${loopname}_valuevar = " . $val . ";\n"; + + if(!empty($ast->params["key"])) { + list($val, $pre) = _transcompile($ast->params["key"], true); + $code .= $pre; + $code .= "\$${loopname}_keyvar = " . $val . ";\n"; + } + + if(!empty($ast->params["counter"])) { + list($val, $pre) = _transcompile($ast->params["counter"], true); + $code .= $pre; + $code .= "\$${loopname}_countervar = " . $val . ";\n"; + } + + $loopbody = ""; + $code .= "\$${loopname}_array = \$ste->get_var_by_name(\$${loopname}_arrayvar);\n"; + $code .= "if(!is_array(\$${loopname}_array))\n\t\$${loopname}_array = array();\n"; + if(!empty($ast->params["counter"])) { + $code .= "\$${loopname}_counter = -1;\n"; + $loopbody .= "\$${loopname}_counter++;\n\$ste->set_var_by_name(\$${loopname}_countervar, \$${loopname}_counter);\n"; + } + + $loop = array(); + $else = array(); + foreach($ast->sub as $node) { + if(($node instanceof TagNode) && ($node->name == "else")) { + $else = array_merge($else, $node->sub); + } else { + $loop[] = $node; + } + } + + $loopbody .= "\$ste->set_var_by_name(\$${loopname}_valuevar, \$${loopname}_value);\n"; + if(!empty($ast->params["key"])) { + $loopbody .= "\$ste->set_var_by_name(\$${loopname}_keyvar, \$${loopname}_key);\n"; + } + $loopbody .= "\n"; + $loopbody .= _transcompile($loop); + $loopbody = "{\n" . loopbody(indent_code($loopbody)) . "\n}\n"; + + if(!empty($else)) { + $code .= "if(empty(\$${loopname}_array))\n{\n"; + $code .= indent_code(_transcompile($else)); + $code .= "\n}\nelse "; + } + $code .= "foreach(\$${loopname}_array as \$${loopname}_key => \$${loopname}_value)\n$loopbody\n"; + + return $code; + }, + "infloop" => function($ast) { + return "while(true)\n{\n" . indent_code(loopbody(indent_code(_transcompile($ast->sub)))) . "\n}\n"; + }, + "break" => function($ast) { + return "throw new \\ste\\BreakException();\n"; + }, + "continue" => function($ast) { + return "throw new \\ste\\ContinueException();\n"; + }, + "block" => function($ast) { + if(empty($ast->params["name"])) { + throw new ParseCompileError("Transcompile Error: name missing in .", $ast->tpl, $ast->offset); + } + + $blknamevar = "blockname_" . str_replace(".", "_", uniqid("", true)); + + list($val, $code) = _transcompile($ast->params["name"], true); + $code .= "\$${blknamevar} = " . $val . ";\n"; + + $tmpblk = uniqid("", true); + $code .= "\$ste->blocks['$tmpblk'] = array_pop(\$outputstack);\n\$ste->blockorder[] = '$tmpblk';\n\$outputstack = array('');\n\$outputstack_i = 0;\n"; + + $code .= _transcompile($ast->sub); + + $code .= "\$ste->blocks[\$${blknamevar}] = array_pop(\$outputstack);\n"; + $code .= "if(array_search(\$${blknamevar}, \$ste->blockorder) === false)\n\t\$ste->blockorder[] = \$${blknamevar};\n\$outputstack = array('');\n\$outputstack_i = 0;\n"; + + return $code; + }, + "load" => function($ast) { + if(empty($ast->params["name"])) { + throw new ParseCompileError("Transcompile Error: name missing in .", $ast->tpl, $ast->offset); + } + + list($val, $code) = _transcompile($ast->params["name"], true); + $code .= "\$outputstack[\$outputstack_i] .= \$ste->load(" . $val . ");\n"; + return $code; + }, + "mktag" => function($ast) { + $code = ""; + + if(empty($ast->params["name"])) { + throw new ParseCompileError("Transcompile Error: name missing in .", $ast->tpl, $ast->offset); + } + + $fxbody = "\$outputstack = array(''); \$outputstack_i = 0;\$ste->vars['_tag_parameters'] = \$params;\n"; + + list($tagname, $tagname_pre) = _transcompile($ast->params["name"], true); + + $usemandatory = ""; + if(!empty($ast->params["mandatory"])) { + $usemandatory = " use (\$mandatory_params)"; + $code .= "\$outputstack[] = '';\n\$outputstack_i++;\n"; + $code .= _transcompile($ast->params["mandatory"]); + $code .= "\$outputstack_i--;\n\$mandatory_params = explode('|', array_pop(\$outputstack));\n"; + + $fxbody .= "foreach(\$mandatory_params as \$mp)\n{\n\tif(!isset(\$params[\$mp]))\n\t\tthrow new \\ste\\RuntimeError(\"\$mp missing in .\");\n}"; + } + + $fxbody .= _transcompile($ast->sub); + $fxbody .= "return array_pop(\$outputstack);"; + + $code .= "\$tag_fx = function(\$ste, \$params, \$sub)" . $usemandatory . "\n{\n" . indent_code($fxbody) . "\n};\n"; + $code .= $tagname_pre; + $code .= "\$ste->register_tag($tagname, \$tag_fx);\n"; + + return $code; + }, + "tagcontent" => function($ast) { + return "\$outputstack[\$outputstack_i] .= \$sub(\$ste);"; + }, + "set" => function($ast) { + if(empty($ast->params["var"])) { + throw new ParseCompileError("Transcompile Error: var missing in .", $ast->tpl, $ast->offset); + } + + $code = "\$outputstack[] = '';\n\$outputstack_i++;\n"; + $code .= _transcompile($ast->sub); + $code .= "\$outputstack_i--;\n"; + + list($val, $pre) = _transcompile($ast->params["var"], true); + $code .= $pre; + $code .= "\$ste->set_var_by_name(" . $val . ", array_pop(\$outputstack));\n"; + + return $code; + }, + "get" => function($ast) { + if(empty($ast->params["var"])) { + throw new ParseCompileError("Transcompile Error: var missing in .", $ast->tpl, $ast->offset); + } + + list($val, $pre) = _transcompile($ast->params["var"], true); + $code .= $pre; + return "\$outputstack[\$outputstack_i] .= \$ste->get_var_by_name(" . $val . ");"; + }, + "calc" => function($ast) { + $code = "\$outputstack[] = '';\n\$outputstack_i++;\n"; + $code .= _transcompile($ast->sub); + $code .= "\$outputstack_i--;\n\$outputstack[\$outputstack_i] .= \$ste->calc(array_pop(\$outputstack));\n"; + + return $code; + } +); + +function escape_text($text) { + return addcslashes($text, "\r\n\t\$\0..\x1f\\\"\x7f..\xff"); +} + +function _transcompile($ast, $avoid_outputstack = false) { /* The real transcompile function, does not add boilerplate code. */ + $code = ""; + global $ste_builtins; + + $text_and_var_buffer = array(); + + foreach($ast as $node) { + if($node instanceof TextNode) { + $text_and_var_buffer[] = '"' . escape_text($node->text) . '"'; + } else if($node instanceof VariableNode) { + $text_and_var_buffer[] = $node->transcompile(); + } else if($node instanceof TagNode) { + if(!empty($text_and_var_buffer)) { + $code .= "\$outputstack[\$outputstack_i] .= " . implode (" . ", $text_and_var_buffer) . ";\n"; + $text_and_var_buffer = array(); + } + if(isset($ste_builtins[$node->name])) { + $code .= $ste_builtins[$node->name]($node); + } else { + $paramarray = "parameters_" . str_replace(".", "_", uniqid("", true)); + $code .= "\$$paramarray = array();\n"; + + foreach($node->params as $pname => $pcontent) { + list($pval, $pre) = _transcompile($pcontent, true); + $code .= $pre . "\$${paramarray}['" . escape_text($pname) . "'] = " . $pval . ";\n"; + } + + $code .= "\$outputstack[\$outputstack_i] .= \$ste->call_tag('" . escape_text($node->name) . "', \$${paramarray}, "; + $code .= empty($node->sub) ? "function(\$ste) { return ''; }" : transcompile($node->sub); + $code .= ");\n"; + } + } + } + + if($avoid_outputstack && ($code == "")) { + return array(implode (" . ", $text_and_var_buffer), ""); + } + + if(!empty($text_and_var_buffer)) { + $code .= "\$outputstack[\$outputstack_i] .= ". implode (" . ", $text_and_var_buffer) . ";\n"; + } + + if($avoid_outputstack) { + $tmpvar = "tmp_" . str_replace(".", "_", uniqid("",true)); + $code = "\$outputstack[] = '';\n\$outputstack_i++;" . $code; + $code .= "\$$tmpvar = array_pop(\$outputstack);\n\$outputstack_i--;\n"; + return array("\$$tmpvar", $code); + } + + return $code; +} + +$ste_transc_boilerplate = "\$outputstack = array('');\n\$outputstack_i = 0;\n"; + +/* + * Function: transcompile + * Transcompiles an abstract syntax tree to PHP. + * You only need this function, if you want to manually transcompile a template. + * + * Parameters: + * $ast - The abstract syntax tree to transcompile. + * + * Returns: + * PHP code. The PHP code is an anonymous function expecting a instance as its parameter and returns a string (everything that was not pached into a section). + */ +function transcompile($ast) { /* Transcompile and add some boilerplate code. */ + global $ste_transc_boilerplate; + return "function(\$ste)\n{\n" . indent_code($ste_transc_boilerplate . _transcompile($ast) . "return array_pop(\$outputstack);") . "\n}"; +} + +/* + * Constants: Template modes + * + * MODE_SOURCE - The Templates source + * MODE_TRANSCOMPILED - The transcompiled template + */ +const MODE_SOURCE = 0; +const MODE_TRANSCOMPILED = 1; + +abstract class StorageAccessFailure extends \Exception { } + +/* + * Class: CantLoadTemplate + * An exception that a implementation can throw, if it is unable to load a template. + */ +class CantLoadTemplate extends StorageAccessFailure { } + +/* + * Class: CantSaveTemplate + * An exception that a implementation can throw, if it is unable to save a template. + */ +class CantSaveTemplate extends StorageAccessFailure { } + +/* + * Class: StorageAccess + * An interface. + * A StorageAccess implementation is used to access the templates from any storage. + * This means, that you are not limited to store the Templates inside directories, you can also use a database or something else. + */ +interface StorageAccess { + /* + * Function: load + * Loading a template. + * + * Parameters: + * $tpl - The name of the template. + * &$mode - Which mode is preferred? One of the