fork download
copy 
  1. <?php
  2.  
  3. final class SimpleTemplate_SyntaxError extends \Exception {
  4. 	function __construct($message) {
  5. 		$this->message = 'SimpleTemplate - Syntax Error: ' . $message;
  6. 	}
  7. }
  8.  
  9. final class SimpleTemplate_FN_Invalid extends \Exception {
  10. 	function __construct($message) {
  11. 		$this->message = 'SimpleTemplate_FN - Invalid function: ' . $message;
  12. 	}
  13. }
  14.  
  15. // contains all functions needed
  16. final class SimpleTemplate_FN {
  17. 	private static function fn_array_flat(){
  18. 		$return = array();
  19. 		$array = func_get_args();
  20. 		array_walk_recursive($array, function($value)use(&$return){
  21. 			$return[] = $value;
  22. 		});
  23. 		return $return;
  24. 	}
  25.  
  26. 	private static function fn_inc($_, $by = 1){
  27. 		// if there's no increment value
  28. 		if(!$by)
  29. 		{
  30. 			return $_;
  31. 		}
  32.  
  33. 		// if there's no value
  34. 		if(!$_)
  35. 		{
  36. 			return $by;
  37. 		}
  38.  
  39. 		$fn = function($_, $by){
  40. 			switch(gettype($_))
  41. 			{
  42. 				case 'NULL':
  43. 				case 'null':
  44. 					return $by;
  45. 				case 'integer':
  46. 				case 'double':
  47. 				case 'float':
  48. 					return $_ + $by;
  49. 				case 'string':
  50. 					if($_ === '')
  51. 					{
  52. 						return '';
  53. 					}
  54.  
  55. 					$_by = abs($by);
  56.  
  57. 					for($i = 0; $i < $_by; $i++)
  58. 					{
  59. 						if($by > 0)
  60. 						{
  61. 							++$_;
  62. 						}
  63. 						else
  64. 						{
  65. 							$last = strlen($_) - 1;
  66.  
  67. 							if($_[$last] === 'a' || $_[$last] === 'A')
  68. 							{
  69. 								// handles aaaa -> zzz
  70. 								$_ = preg_replace_callback('@[aA]+$@', function($str){
  71. 									return str_repeat($str[0][0] === 'a' ? 'z': 'Z', strlen($str[0]) - 1);
  72. 								}, $_);
  73. 							}
  74. 							else
  75. 							{
  76. 								$_[$last] = chr(ord($_[$last]) - 1);
  77. 							}
  78. 						}
  79. 					}
  80.  
  81. 					return $_;
  82. 				default:
  83. 					return $by;
  84. 			}
  85. 		};
  86.  
  87.  
  88. 		if(gettype($_) === 'array')
  89. 		{
  90. 			array_walk_recursive($_, function(&$value)use(&$fn, &$by){
  91. 				$value = $fn($value, $by);
  92. 			});
  93. 		}
  94. 		else
  95. 		{
  96. 			$_ = $fn($_, $by);
  97. 		}
  98.  
  99. 		return $_;
  100. 	}
  101.  
  102. 	private static function fn_len($args){
  103. 		$result = array();
  104.  
  105. 		if(func_num_args() > 1)
  106. 		{
  107. 			$args = func_get_args();
  108. 		}
  109. 		else
  110. 		{
  111. 			$args = array($args);
  112. 		}
  113.  
  114. 		foreach($args as $arg)
  115. 		{
  116. 			switch(gettype($arg))
  117. 			{
  118. 				case 'array':
  119. 					$result[] = count($arg);
  120. 					break;
  121. 				case 'string':
  122. 					$result[] = strlen($arg);
  123. 					break;
  124. 				case 'integer':
  125. 				case 'double':
  126. 				case 'float':
  127. 					$result[] = 0;
  128. 					break;
  129. 				default:
  130. 					$result[] = null;
  131. 			}
  132. 		}
  133.  
  134. 		return $result;
  135. 	}
  136.  
  137. 	private static function fn_repeat($_, $times = 1){
  138. 		if($times < 1)
  139. 		{
  140. 			return '';
  141. 		}
  142.  
  143. 		array_walk_recursive($_, function(&$value)use(&$times){
  144. 			$value = str_repeat($value, $times);
  145. 		});
  146.  
  147. 		return $_;
  148. 	}
  149.  
  150. 	// *******************************************************************************
  151.  
  152. 	static function call(){
  153. 		$args = func_get_args();
  154. 		$fn = array_shift($args);
  155.  
  156. 		if(!self::method_exists($fn))
  157. 		{
  158. 			throw new SimpleTemplate_FN_Invalid($fn);
  159. 		}
  160.  
  161. 		return call_user_func_array(array(__CLASS__, 'fn_' . $fn), $args);
  162. 	}
  163.  
  164. 	static function name_list(){
  165. 		static $list = array();
  166.  
  167. 		if(!$list)
  168. 		{
  169. 			foreach(get_class_methods(__CLASS__) as $method)
  170. 			{
  171. 				if(strpos($method, 'fn_') === 0)
  172. 				{
  173. 					$list[] = preg_replace('@^fn_@', '', $method);
  174. 				}
  175. 			}
  176. 		}
  177.  
  178. 		return $list;
  179. 	}
  180.  
  181. 	static function method_exists($method){
  182. 		static $exist = array();
  183.  
  184. 		return isset($exist[$method])
  185. 			? $exist[$method]
  186. 			: (
  187. 				is_null($exist[$method] = @method_exists(__CLASS__, 'fn_' . $method))
  188. 					? in_array($method, self::name_list())
  189. 					: $exist[$method]
  190. 			);
  191. 	}
  192. }
  193.  
  194. // compiler class
  195. class SimpleTemplate_Compiler {
  196. 	private $uuid = null;
  197.  
  198. 	private static $var_name = 'DATA';
  199. 	private static $default_var_name = '_';
  200.  
  201. 	private static $regex = array(
  202. 		'var' => '(?:(?:(?:U|unsafe|R|ref|reference)\:)?[_a-zA-Z]\w*(?:\.(?:\[[_a-zA-Z]\w*(?:\.\w*)*\]|\w*))*)',
  203. 		'var_name' => '(?:[_a-zA-Z]\w*)',
  204. 		'var_simple' => '(?:(?:(?:U|unsafe|R|ref|reference)\:)?[_a-zA-Z]\w*(?:\.\w*)*)',
  205. 		'value' => '(?:(?:"[^"\\\\]*(?:\\\\.[^"\\\\]*)*")|[\-+]?\d*(?:\.\d*)?|true|false|null)',
  206. 		'var_value' => '(?:(?:"[^"\\\\]*(?:\\\\.[^"\\\\]*)*")|[\-+]?[\d\W]\d*(?:\.\d*)?|true|false|null|(?:(?:(?:U|unsafe|R|ref|reference)\:)?[_a-zA-Z]\w*(?:\.(?:\[[_a-zA-Z]\w*(?:\.\w*)*\]|\w*))*))'
  207. 	);
  208.  
  209. 	private $options = array();
  210. 	private $template = null;
  211.  
  212. 	private $fn = null;
  213. 	private $php = '$_ = &$DATA;' . PHP_EOL;
  214.  
  215. 	private static function render_var($name = null, $safe = true, $allow_ref = false){
  216. 		// preg_match('@^\s*(?:(?<unsafe>U|unsafe)\s+)?(?<var>.*)$@', $name ?: self::$default_var_name, $bits);
  217. 		preg_match('@^\s*(?:(?:(?<unsafe>U|unsafe)|(?<ref>R|ref|reference))\:)?(?<var>.*)$@', $name ?: self::$default_var_name, $bits);
  218.  
  219. 		if(strpos($bits['var'], '['))
  220. 		{
  221. 			$var = preg_replace_callback('@\.\[([_a-zA-Z]\w*(?:\.\w*)?)\]@', function($matches){
  222. 				return '[' . self::render_var($matches[1], false) . ']';
  223. 			}, $bits['var']);
  224.  
  225. 			$var = '$' . self::$var_name . ($bits['var'] ? '[\'' . implode('\'][\'', explode('.', $var)) . '\']' : '');
  226.  
  227. 			$var = preg_replace(
  228. 				array('@\'(\w+)\[@', '@\'\]\]\'\]@'),
  229. 				array('\'$1\'][', '\']]'),
  230. 				$var
  231. 			);
  232. 		}
  233. 		else
  234. 		{
  235. 			$var = '$' . self::$var_name . ($bits['var'] ? '[\'' . implode('\'][\'', explode('.', $bits['var'])) . '\']' : '');
  236. 		}
  237.  
  238. 		return $allow_ref && isset($bits['ref']) && $bits['ref']
  239. 			? '&' . $var
  240. 			: (
  241. 				$safe && !$bits['unsafe']
  242. 					? '(isset(' . $var . ')?' . $var . ':null)'
  243. 					: $var
  244. 			);
  245. 	}
  246.  
  247. 	private static function split_values($values, $delimiter = '\s*,\s*'){
  248. 		// http://stackoverflow.com/a/5696141/ --> regex quoted string
  249. 		// http://stackoverflow.com/a/632552/ --> regex to match $delimiter outside quotes
  250. 		return preg_split('@(' . ($delimiter ?: '\s*,\s*') . ')(?=(?:[^"]|"[^"\\\\]*(?:\\\\.[^"\\\\]*)*")*$)@', $values);
  251. 	}
  252.  
  253. 	private static function parse_values($values, $delimiter = '\s*,\s*', $safe = true, $allow_ref = true){
  254. 		$value_bits = self::split_values($values, $delimiter);
  255.  
  256. 		foreach($value_bits as $k => $value)
  257. 		{
  258. 			$value_bits[$k] = self::parse_value($value, $safe, $allow_ref);
  259. 		}
  260.  
  261. 		return $value_bits;
  262. 	}
  263.  
  264. 	private static function parse_boolean($data){
  265. 		if(
  266. 			!preg_match(
  267. 				'@(' . self::$regex['var_value'] . ')\s*(?:(isset|is(?:(?:\s*not|n\'?t)?\s*(?:(?:greater|lower)(?:\s*than)?|equal(?:\s*to)?|equal|a|(?:(?:instance|multiple|mod)(?:\s*of)?)|matches))?|has(?:\s*not)?|(?:not\s*)?matches)\s*(' . self::$regex['var_value'] . ')?)?(?:\s*(.+))?@',
  268. 				$data, $bits
  269. 			)
  270. 		)
  271. 		{
  272. 			return '';
  273. 		}
  274.  
  275. 		$fn = array(
  276. 			'is' => function($data, $var1, $var2){
  277. 				$symbols = array(
  278. 					'' => '%s === %s',
  279. 					'a' => 'gettype(%s) === %s',
  280. 					'instance' => 'is_a(%s, %s)',
  281. 					'equal' => '%s == %s',
  282. 					'lower' => '%s < %s',
  283. 					'greater' => '%s > %s',
  284. 					'multiple' => '!(%s %% %s)',
  285. 					'mod' => '%s %% %s',
  286. 					'matches' => 'preg_match(%2$s, %1$s)'
  287. 				);
  288.  
  289. 				preg_match('@(?<not>not)?\s*(?<operation>equal|lower|greater|a|instance|multiple|mod|matches)?\s*(?:of|to|than)?\s*@', $data, $bits);
  290.  
  291. 				return (isset($bits['not']) && $bits['not'] !== '' ? '!': '') . '(' . sprintf($symbols[isset($bits['operation']) ? $bits['operation']: ''], self::parse_value($var1), self::parse_value($var2)) . ')';
  292. 			},
  293. 			'has' => function($data, $var1, $var2){
  294. 				return ($data === 'not' ? '!': '') . 'array_key_exists(' . self::parse_value($var2) . ', (array)' . self::parse_value($var1) . ')';
  295. 			},
  296. 			'isset' => function($data, $var1){
  297. 				return ($data === 'not' ? '!': '') . 'isset(' . self::render_var($var1, false) . ')';
  298. 			},
  299. 			'matches' => function($data, $var1, $var2, $extra){
  300. 				if($extra && self::is_var($extra = self::parse_value($extra, false)))
  301. 				{
  302. 					return ($data === 'not' ? '!': '') . 'preg_match(' . self::parse_value($var2) . ', ' . self::parse_value($var1) . ', ' . $extra . ')';
  303. 				}
  304. 				else
  305. 				{
  306. 					return ($data === 'not' ? '!': '') . 'preg_match(' . self::parse_value($var2) . ', ' . self::parse_value($var1) . ')';
  307. 				}
  308. 			}
  309. 		);
  310.  
  311. 		if(isset($bits[2]))
  312. 		{
  313. 			$ops = explode(' ', $bits[2], 2);
  314.  
  315. 			return $fn[$ops[0]](
  316. 				isset($ops[1]) ? $ops[1]: '',
  317. 				$bits[1],
  318. 				isset($bits[3]) ? $bits[3] : self::$default_var_name,
  319. 				isset($bits[4]) ? $bits[4] : ''
  320. 			);
  321. 		}
  322. 		else
  323. 		{
  324. 			return self::parse_value($bits[1]);
  325. 		}
  326. 	}
  327.  
  328. 	private static function parse_value($value, $safe = true, $allow_ref = false){
  329. 		if($value === '' || $value === '""')
  330. 		{
  331. 			return $value;
  332. 		}
  333. 		else if(preg_match('@^' . self::$regex['value'] . '$@', $value))
  334. 		{
  335. 			return $value[0] === '"'
  336. 				? self::parse_value_string($value)
  337. 				: $value;
  338. 		}
  339. 		else if(preg_match('@^' . self::$regex['var'] . '$@', $value))
  340. 		{
  341. 			return self::render_var($value, $safe, $allow_ref);
  342. 		}
  343. 		else
  344. 		{
  345. 			throw new SimpleTemplate_SyntaxError('Invalid value syntax: ' . $value);
  346. 		}
  347. 	}
  348.  
  349. 	private static function parse_value_string($value){
  350. 		return preg_replace_callback(
  351. 			'@#{([_a-zA-Z]\w*(?:\.(?:\[[_a-zA-Z]\w*(?:\.\w*)*\]|\w*))*)}@',
  352. 			function($matches){
  353. 				return '{' . self::render_var($matches[1], false) . '}';
  354. 			},
  355. 			str_replace('$', '\\$', $value)
  356. 		);
  357. 	}
  358.  
  359. 	private static function is_value($value){
  360. 		return strlen($value)
  361. 			&& $value[0] !== '$'
  362. 			&& $value[0] !== '('
  363. 			&& $value[0] !== '&'
  364. 			/*&& (
  365. 				$value[0] !== '"'
  366. 				|| strpos($value, '{$' . self::$var_name) === false
  367. 			)*/;
  368. 	}
  369.  
  370. 	private static function is_var($value){
  371. 		return strlen($value)
  372. 			&& (
  373. 				$value[0] === '$'
  374. 				|| $value[0] === '('
  375. 				|| $value[0] === '&'
  376. 			);
  377. 	}
  378.  
  379. 	private function format_code($code, $tabs, $skip_first = false, $skip_last = false){
  380. 		$lines = preg_split("@(?:\r?\n|\r)+@", $code);
  381. 		$heredoc_closing = self::$var_name . $this->uuid;
  382.  
  383. 		$return = $skip_first ? array_shift($lines) : '';
  384. 		$last = $skip_last ? PHP_EOL . array_pop($lines): '';
  385.  
  386. 		foreach($lines as $line)
  387. 		{
  388. 			if($return)
  389. 			{
  390. 				$return .= PHP_EOL;
  391. 			}
  392.  
  393. 			if($line === $heredoc_closing)
  394. 			{
  395. 				$return .= $heredoc_closing;
  396. 			}
  397. 			else
  398. 			{
  399. 				$return .= (
  400. 					preg_match('@^\s*\)+;?\s*$@', $line)
  401. 						? substr($tabs, 1)
  402. 						: $tabs
  403. 				). ltrim($line);
  404. 			}
  405. 		}
  406.  
  407. 		return $return . $last;
  408. 	}
  409.  
  410. 	private function compile($str){
  411. 		$UUID = $this->uuid;
  412.  
  413. 		$brackets = 0;
  414. 		$tabs = '';
  415.  
  416. 		$replacement = array(
  417. 			'/' => function($data)use(&$replacement, &$brackets, &$tabs){
  418. 				if($brackets > 0)
  419. 				{
  420. 					--$brackets;
  421.  
  422. 					return $tabs . '};';
  423. 				}
  424. 				else
  425. 				{
  426. 					return $tabs . ';';
  427. 				}
  428. 			},
  429. 			'//' => function(){
  430. 				return '';
  431. 			},
  432. 			'echo' => function($data)use(&$replacement, &$brackets, &$tabs){
  433. 				preg_match('@^(?:separator\s+(?<separator>' . self::$regex['var_value'] . ')\s*)?(?<data>.*)$@', $data, $bits);
  434.  
  435. 				$separator = $bits['separator'] ? self::parse_value($bits['separator']): '\'\'';
  436.  
  437. 				return $tabs . 'echo implode(' . $separator . ', SimpleTemplate_FN::call(\'array_flat\', ' . implode(', ', self::parse_values($bits['data'])) . '));';
  438. 			},
  439. 			'echol' => function($data)use(&$replacement, &$brackets, &$tabs){
  440. 				return $replacement['echo']($data) . 'echo PHP_EOL;';
  441. 			},
  442. 			'echoj' => function($data)use(&$replacement, &$brackets, &$tabs){
  443. 				return $replacement['echo']('separator ' . $data);
  444. 			},
  445. 			'echojl' => function($data)use(&$replacement, &$brackets, &$tabs){
  446. 				return $replacement['echol']('separator ' . $data);
  447. 			},
  448. 			'echof' => function($data)use(&$replacement, &$brackets, &$tabs){
  449. 				return $replacement['echol']('separator ' . $data);
  450. 			},
  451. 			'print' => function($data)use(&$replacement, &$brackets, &$tabs){
  452. 				return $replacement['call']((strpos('into', $data) === 0 ? 's' : '') . 'printf ' . $data);
  453. 			},
  454. 			'if' => function($data)use(&$replacement, &$brackets, &$tabs){
  455. 				++$brackets;
  456.  
  457. 				return $tabs . 'if(' . self::parse_boolean($data) . ') {';
  458. 			},
  459. 			'else' => function($data)use(&$replacement, &$brackets, &$tabs){
  460. 				preg_match('@(?<if>if)(?<data>.*)@', $data, $bits);
  461.  
  462. 				$return = substr($tabs, 1) . '} else';
  463.  
  464. 				if(isset($bits['if']) && isset($bits['data']))
  465. 				{
  466. 					--$brackets;
  467.  
  468. 					$return .= ltrim($replacement['if'](trim($bits['data'])));
  469. 				}
  470. 				else
  471. 				{
  472. 					$return .= ' {';
  473. 				}
  474.  
  475. 				return $return;
  476. 			},
  477. 			'each' => function($data)use(&$replacement, &$brackets, &$tabs){
  478. 				++$brackets;
  479.  
  480. 				preg_match('@^(?<var>' . self::$regex['var'] . ')\s*(?:as\s*(?<as>' . self::$regex['var'] . ')(?:\s*key\s*(?<key>' . self::$regex['var'] . ')\s*)?)?$@', $data, $bits);
  481.  
  482. 				static $count = 0;
  483.  
  484. 				$var_name = self::$var_name;
  485. 				$tmp_name = 'tmp_' . (++$count) . '_';
  486.  
  487. 				$vars_var = self::render_var($bits['var'], false);
  488. 				$vars_as = self::render_var(isset($bits['as']) ? $bits['as'] : '', false);
  489. 				$vars_key = self::render_var(isset($bits['key']) ? $bits['key'] : '__', false);
  490.  
  491. 				return <<<PHP
  492. {$tabs}// loop variables
  493. {$tabs}\${$tmp_name}val = isset({$vars_var}) ? \${$tmp_name}val = &{$vars_var} : null;
  494. {$tabs}\${$tmp_name}keys = gettype({$vars_var}) == 'array'
  495. {$tabs}	? array_keys({$vars_var})
  496. {$tabs}	: array_keys(range(0, strlen(\${$tmp_name}val = \${$tmp_name}val . '') - 1));
  497. {$tabs}\${$tmp_name}key_last = end(\${$tmp_name}keys);
  498. {$tabs}
  499. {$tabs}// loop
  500. {$tabs}foreach(\${$tmp_name}keys as \${$tmp_name}index => \${$tmp_name}key){
  501. {$tabs}	\${$var_name}['loop'] = array(
  502. {$tabs}		'index' => \${$tmp_name}index,
  503. {$tabs}		'i' => \${$tmp_name}index,
  504. {$tabs}		'key' => \${$tmp_name}key,
  505. {$tabs}		'k' => \${$tmp_name}key,
  506. {$tabs}		'value' => \${$tmp_name}val[\${$tmp_name}key],
  507. {$tabs}		'v' => \${$tmp_name}val[\${$tmp_name}key],
  508. {$tabs}		'first' => \${$tmp_name}key === \${$tmp_name}keys[0],
  509. {$tabs}		'last' => \${$tmp_name}key === \${$tmp_name}key_last,
  510. {$tabs}	);
  511. {$tabs}	{$vars_key} = \${$tmp_name}key;
  512. {$tabs}	{$vars_as} = \${$tmp_name}val[\${$tmp_name}key];
  513. PHP;
  514. 			},
  515. 			'while' => function($data)use(&$replacement, &$brackets, &$tabs){
  516. 				++$brackets;
  517.  
  518. 				return $tabs . 'while(' . self::parse_boolean($data) . '){';
  519. 			},
  520. 			'for' => function($data)use(&$replacement, &$brackets, &$tabs){
  521. 				++$brackets;
  522.  
  523. 				return preg_replace_callback(
  524. 					'@(?<var>' . self::$regex['var'] . ')?\s*(?:from\s*(?<start>' . self::$regex['var_value'] . '))?(?:\s*to\s*(?<end>' . self::$regex['var_value'] . '))(?:\s*step\s*(?<step>' . self::$regex['var_value'] . '))?@',
  525. 					function($matches)use(&$replacement, &$brackets, &$tabs){
  526.  
  527. 						$values = array(
  528. 							'start' => isset($matches['start']) && $matches['start'] !== '' ? self::parse_value($matches['start']) : '0',
  529. 							'end' => isset($matches['end']) ? self::parse_value($matches['end']) : self::parse_value($matches['start']),
  530. 							'step' => isset($matches['step']) ? self::parse_value($matches['step']) : '1'
  531. 						);
  532.  
  533. 						$return = $tabs . 'foreach(';
  534.  
  535. 						if(self::is_value($values['start']) && self::is_value($values['end']) && self::is_value($values['step']))
  536. 						{
  537. 							if($this->options['optimize'])
  538. 							{
  539. 								$return = "{$tabs}// ~ optimization enabled ~ inlining the results\r\n{$return}" . self::format_code(
  540. 									var_export(
  541. 										range(
  542. 											preg_replace('@^"|"$@', '', $values['start']),
  543. 											preg_replace('@^"|"$@', '', $values['end']),
  544. 											abs($values['step'])
  545. 										),
  546. 										true
  547. 									),
  548. 									$tabs . "\t",
  549. 									true
  550. 								);
  551. 							}
  552. 							else
  553. 							{
  554. 								$return = "{$tabs}// ~ optimization DISABLED ~ results could be inlined\r\n{$return}range({$values['start']}, {$values['end']}, abs({$values['step']}))";
  555. 							}
  556. 						}
  557. 						else
  558. 						{
  559. 							$return .= 'range(' . $values['start'] . ', ' . $values['end'] . ', abs(' . $values['step'] . '))';
  560. 						}
  561.  
  562. 						return $return . ' as ' . self::render_var(isset($matches['var']) ? $matches['var'] : '', false) . '){';
  563. 					},
  564. 					$data
  565. 				);
  566. 			},
  567. 			'do' => function($data)use(&$replacement, &$brackets, &$tabs){
  568. 				++$brackets;
  569.  
  570. 				return $tabs . 'do{';
  571. 			},
  572. 			'until' => function($data)use(&$replacement, &$brackets, &$tabs){
  573. 				--$brackets;
  574.  
  575. 				return substr($tabs, 1) . '}while(!(' . self::parse_boolean($data) . '));';
  576. 			},
  577. 			'set' => function($data)use(&$replacement, &$brackets, &$tabs){
  578. 				preg_match('@^\s*(?<op>[\+\-\*\\\/\%])?\s*(?<var>' . self::$regex['var'] . ')\s*(?:(?<op_val>' . self::$regex['var_value'] . ')\s)?\s*(?<values>.*)$@', $data, $bits);
  579.  
  580. 				$values = self::parse_values($bits['values']);
  581. 				$count = count($values);
  582.  
  583. 				$return = $tabs . self::render_var($bits['var'], false) . ' = ';
  584.  
  585. 				$close = 0;
  586.  
  587. 				if(isset($bits['op']))
  588. 				{
  589. 					switch($bits['op'])
  590. 					{
  591. 						case '-':
  592. 							$return .= <<<PHP
  593. call_user_func_array(function(){
  594. {$tabs}	\$args = func_get_args();
  595. {$tabs}	\$initial = array_shift(\$args);
  596. {$tabs}	return array_reduce(\$args, function(\$carry, \$value){
  597. {$tabs}		return \$carry - \$value;
  598. {$tabs}	}, \$initial);
  599. {$tabs}}, SimpleTemplate_FN::call('array_flat', 
  600. PHP;
  601. 							$close = 2;
  602. 							break;
  603. 						case '+':
  604. 							$return .= 'array_sum(SimpleTemplate_FN::call(\'array_flat\', ';
  605. 							$close = 2;
  606. 							break;
  607. 						case '*':
  608. 							$return .= 'array_product(SimpleTemplate_FN::call(\'array_flat\', ';
  609. 							$close = 2;
  610. 							break;
  611. 						case '\\':
  612. 						case '/':
  613. 						case '%':
  614. 							$ops = array(
  615. 								'\\' => 'round(%s / $value)',
  616. 								'/' => '(%s / $value)',
  617. 								'%' => '(%s %% $value)'
  618. 							);
  619.  
  620. 							$return .= 'array_map(function($value)use(&$' . self::$var_name . '){'
  621. 								.'return ' . sprintf(
  622. 									$ops[$bits['op']],
  623. 									isset($bits['op_val'])
  624. 										? self::parse_value($bits['op_val'])
  625. 										: self::render_var($bits['var'], false)
  626. 								)
  627. 								. ';}, SimpleTemplate_FN::call(\'array_flat\', ';
  628. 							$close = 2;
  629. 							break;
  630. 					}
  631. 				}
  632.  
  633. 				if($count > 1)
  634. 				{
  635. 					$return .= 'array(' . implode(',', $values) . ')';
  636. 				}
  637. 				else
  638. 				{
  639. 					$return .= ($count && strlen($values[0]) ? $values[0] : 'null');
  640. 				}
  641.  
  642. 				return $return . str_repeat(')', $close) . ';';
  643. 			},
  644. 			'unset' => function($data)use(&$replacement, &$brackets, &$tabs){
  645. 				$values = self::parse_values($data, null, false);
  646. 				$vars = array_filter($values, function($var){
  647. 					return !self::is_value($var);
  648. 				});
  649.  
  650. 				$return = $tabs . (
  651. 					count($values) !== count($vars)
  652. 						? '// Warning: invalid values were passed' . PHP_EOL . $tabs
  653. 						: ''
  654. 				);
  655.  
  656. 				return $return . (
  657. 					$vars
  658. 						? 'unset(' . implode(',', $vars) . ');'
  659. 						: '// Warning: no values were passed or all were filtered out'
  660. 				);
  661. 			},
  662. 			'global' => function($data)use(&$replacement, &$brackets, &$tabs){
  663. 				$data = self::split_values($data, ' ');
  664.  
  665. 				return $tabs . self::render_var(array_shift($data), false) . ' = $GLOBALS[\'' . join('\'][\'', $data) . '\'];';
  666. 			},
  667. 			'call' => function($data)use(&$replacement, &$brackets, &$tabs){
  668. 				preg_match('@^\s*(?<fn>' . self::$regex['var'] . ')\s*(?:into\s*(?<into>' . self::$regex['var'] . ')\s*)?(?<args>.*?)$@', $data, $bits);
  669.  
  670. 				$var = self::render_var($bits['fn'], false);
  671.  
  672. 				$into = $bits['into'] ? self::render_var($bits['into'], false) . ' = ' : '';
  673. 				$args = implode(', ', self::parse_values($bits['args']));
  674. 				$alt_name = str_replace('.', '_', $bits['fn']);
  675.  
  676. 				return <<<PHP
  677. {$tabs}{$into}call_user_func_array(
  678. {$tabs}	(isset({$var}) && is_callable({$var})
  679. {$tabs}		? {$var}
  680. {$tabs}		: (SimpleTemplate_FN::method_exists('{$bits['fn']}')
  681. {$tabs}			? SimpleTemplate_FN::call('{$bits['fn']}')
  682. {$tabs}			: '{$alt_name}'
  683. {$tabs}		)
  684. {$tabs}	),
  685. {$tabs}	array({$args})
  686. {$tabs});
  687. PHP;
  688. 			},
  689. 			'php' => function($data)use(&$replacement, &$brackets, &$tabs){
  690. 				return $tabs . 'call_user_func_array(function(&$' . self::$var_name . '){' . PHP_EOL
  691. 					   . "{$tabs}\t{$data};" . PHP_EOL
  692. 					   . $tabs . '}, array(&$' . self::$var_name . '));';
  693. 			},
  694. 			'return' => function($data)use(&$replacement, &$brackets, &$tabs){
  695. 				return $tabs . 'return ' . ($data ? self::parse_value($data): '').';';
  696. 			},
  697. 			'inc' => function($data)use(&$replacement, &$brackets, &$tabs){
  698. 				preg_match('@^(?:\s*by\s*(?<by>' . self::$regex['var_value'] . ')\s*)?(?<values>.*?)$@', $data, $bits);
  699. 				$values = self::parse_values($bits['values'], '\s*,\s*', false);
  700. 				$inc = isset($bits['by']) && $bits['by'] !== '' ? self::parse_value($bits['by']): '1';
  701.  
  702. 				$return = '';
  703.  
  704. 				if(!$inc || $inc === '"0"' || $inc === 'null' || $inc === 'false')
  705. 				{
  706. 					if($this->options['optimize'])
  707. 					{
  708. 						return "{$tabs}// ~ optimization enabled ~ increment by {$inc} removed";
  709. 					}
  710. 					else
  711. 					{
  712. 						$return .= "{$tabs}// ~ optimization DISABLED ~ increment by {$inc} could be removed" . PHP_EOL;
  713. 					}
  714. 				}
  715.  
  716. 				$var_name = self::$var_name;
  717.  
  718. 				foreach($values as $value)
  719. 				{
  720. 					if(!isset($value[0]) && !self::is_value($value[0]))
  721. 					{
  722. 						continue;
  723. 					}
  724.  
  725. 					$return .= "{$tabs}{$value} = SimpleTemplate_FN::call('inc', isset({$value})?{$value}:0, {$inc});" . PHP_EOL;
  726. 				}
  727.  
  728. 				return $return;
  729.  
  730. 			},
  731. 			'fn' => function($data)use(&$replacement, &$brackets, &$tabs){
  732. 				if(
  733. 					preg_match(
  734. 						'@^\s*(' . self::$regex['var_simple'] . ')(?:\s+(' . self::$regex['var_name'] . '(?:,\s*' . self::$regex['var_name'] . ')*))?$@',
  735. 						$data, $bits
  736. 					) === false
  737. 				)
  738. 				{
  739. 					return '';
  740. 				}
  741.  
  742. 				++$brackets;
  743.  
  744. 				$version = SimpleTemplate::version();
  745. 				$var_name = self::$var_name;
  746.  
  747. 				$return = $tabs . self::render_var($bits ? $bits[1] : null, false) . <<<PHP
  748. = function()use(&\$_){
  749. {$tabs}	\${$var_name} = array(
  750. {$tabs}		'argv' => func_get_args(),
  751. {$tabs}		'argc' => func_num_args(),
  752. {$tabs}		'VERSION' => '{$version}',
  753. {$tabs}		'EOL' => PHP_EOL,
  754. {$tabs}		'PARENT' => &\$_
  755. {$tabs}	);
  756. {$tabs}	\$_ = &\${$var_name};
  757.  
  758. PHP;
  759. 				if(isset($bits[2]) && $bits[2])
  760. 				{
  761. 					$args = array();
  762. 					foreach(self::split_values($bits[2]) as $value)
  763. 					{
  764. 						if(!self::is_value(self::parse_value($value)))
  765. 						{
  766. 							$args[] = $value;
  767. 						}
  768. 					}
  769.  
  770. 					foreach($args as $k => $arg)
  771. 					{
  772. 						$return .= "{$tabs}	\${$var_name}[\"{$arg}\"] = &\${$var_name}[\"argv\"][{$k}];" . PHP_EOL;
  773. 					}
  774. 				}
  775.  
  776. 				return $return;
  777. 			},
  778. 			'eval' => function($data)use(&$replacement, &$brackets, &$tabs){
  779. 				$return = '';
  780. 				$value = self::parse_value($data);
  781.  
  782. 				if($this->options['optimize'] && self::is_value($value))
  783. 				{
  784. 					$return = $tabs . '// ~ optimization enabled ~ trying to avoid compiling in runtime' . PHP_EOL;
  785.  
  786. 					static $cached = array();
  787.  
  788. 					$sha1 = sha1($value);
  789.  
  790. 					if(isset($cached[$sha1]))
  791. 					{
  792. 						$return .= $tabs . '// {@eval} cached code found: cache entry ';
  793. 					}
  794. 					else
  795. 					{
  796. 						$return .= $tabs . '// {@eval} no cached code found: creating entry ';
  797.  
  798. 						$compiler = new SimpleTemplate_Compiler($this->template, stripslashes(trim($value, '"')), $this->options);
  799.  
  800. 						$cached[$sha1] = self::format_code($compiler->getPHP() . '// {@eval} ended', $tabs);
  801.  
  802. 						unset($compiler);
  803. 					}
  804.  
  805. 					$return .= $sha1 . PHP_EOL . $cached[$sha1];
  806. 				}
  807. 				else
  808. 				{
  809. 					$options = self::format_code(var_export($this->options, true), $tabs . "\t\t", true);
  810.  
  811. 					$return = <<<PHP
  812. {$tabs}// ~ optimization DISABLED or unfeasable ~ compilation in runtime is required
  813. {$tabs}call_user_func_array(function()use(&\$DATA){
  814. {$tabs}	\$compiler = new SimpleTemplate_Compiler(\$this, {$value}, {$options});
  815. {$tabs}	\$fn = \$compiler->getFN();
  816. {$tabs}	return \$fn(\$DATA);
  817. {$tabs}}, array());
  818. PHP;
  819. 				}
  820.  
  821. 				return $return;
  822. 			}
  823. 		);
  824.  
  825. 		$trim_fn = $this->options['trim'] ? 'trim' : '';
  826.  
  827. 		$this->php .= "\r\necho {$trim_fn}(<<<'" . self::$var_name . "{$UUID}'\r\n"
  828. 			. preg_replace_callback(
  829. 				// http://stackoverflow.com/a/6464500
  830. 				'~{@(eval|echoj?l?|print|if|else|for|while|each|do|until|(?:un)?set|call|global|php|return|inc|fn|//?)(?:\\s*(.*?))?}(?=(?:[^"\\\\]*(?:\\\\.|"(?:[^"\\\\]*\\\\.)*[^"\\\\]*"))*[^"]*$)~',
  831. 				function($matches)use(&$replacement, &$brackets, &$tabs, &$UUID, &$trim_fn){
  832.  
  833. 					$tabs = $brackets
  834. 						? str_repeat("\t", $brackets - ($matches[1] === '/'))
  835. 						: '';
  836.  
  837. 					$var_name = self::$var_name;
  838.  
  839. 					$php = $replacement[$matches[1]](isset($matches[2]) ? $matches[2] : null);
  840.  
  841. 					return "\r\n{$var_name}{$UUID}\r\n);\r\n{$tabs}// {$matches[0]}\r\n{$php}\r\n\r\n{$tabs}echo {$trim_fn}(<<<'{$var_name}{$UUID}'\r\n";
  842. 				},
  843. 				$str . ''
  844. 			)
  845. 			. "\r\n" . self::$var_name . "{$UUID}\r\n);\r\n";
  846.  
  847. 		$this->php = preg_replace(
  848. 			array(
  849. 				'@\r\n\t*echo\s*' . $trim_fn . '\(<<<\'' . self::$var_name . $UUID . '\'(?:\s*\r\n)?' . self::$var_name . $UUID . '\r\n\);@',
  850. 				'@\r\n' . self::$var_name . $UUID . '\r\n\);(\r\n)*\t*echo\s*' . $trim_fn . '\(<<<\'' . self::$var_name . $UUID . '\'@'
  851. 			),
  852. 			array(
  853. 				'', ''
  854. 			),
  855. 			$this->php
  856. 		);
  857.  
  858. 		if($brackets)
  859. 		{
  860. 			$this->php .=  "\r\n// AUTO-CLOSE\r\n" . str_repeat('};', $brackets);
  861. 		}
  862. 	}
  863.  
  864. 	function getPHP(){
  865. 		return $this->php;
  866. 	}
  867.  
  868. 	function getFN(){
  869. 		if(!$this->fn)
  870. 		{
  871. 			$this->fn = eval('return function(&$' . self::$var_name . '){'
  872. 					. PHP_EOL . $this->php . PHP_EOL
  873. 				. '};'
  874. 			);
  875.  
  876. 			$this->fn = $this->fn->bindTo($this->template);
  877. 		}
  878.  
  879. 		return $this->fn;
  880. 	}
  881.  
  882. 	function __construct(SimpleTemplate $template, $code, array $options = array()){
  883. 		$this->options = $options;
  884. 		$this->template = $template;
  885.  
  886. 		// ALMOST unguessable name, to avoid syntax errors
  887. 		$this->uuid = str_shuffle(mt_rand() . time() . sha1($code));
  888.  
  889. 		$this->compile($code);
  890. 	}
  891. }
  892.  
  893. // base class
  894. class SimpleTemplate {
  895. 	private static $version = '0.82';
  896.  
  897. 	private $data = array();
  898. 	private $settings = array(
  899. 		'optimize' => true,
  900. 		'trim' => false
  901. 	);
  902.  
  903. 	private $compiler = null;
  904.  
  905. 	function __construct($code, array $options = array()){
  906. 		if(!$code)
  907. 		{
  908. 			throw new Exception('No code was provided');
  909. 		}
  910.  
  911. 		if($options)
  912. 		{
  913. 			$this->settings = array_merge($this->settings, $options);
  914. 		}
  915.  
  916. 		$this->compiler = new SimpleTemplate_Compiler($this, $code, $this->settings);
  917. 	}
  918.  
  919. 	function setData($key, $value){
  920. 		$this->data[$key] = $value;
  921. 	}
  922.  
  923. 	function getData($key, $value){
  924. 		return isset($this->data[$key]) ? $this->data[$key] : null;
  925. 	}
  926.  
  927. 	function unsetData($key){
  928. 		unset($this->data[$key]);
  929. 	}
  930.  
  931. 	function loadData($data){
  932. 		foreach($data as $k => $value)
  933. 		{
  934. 			$this->data[$k] = $value;
  935. 		}
  936. 	}
  937.  
  938. 	function clearData(){
  939. 		$this->data = array();
  940. 	}
  941.  
  942. 	function getPHP(){
  943. 		return $this->compiler->getPHP();
  944. 	}
  945.  
  946. 	function render(){
  947. 		$this->data['argv'] = func_get_args();
  948. 		$this->data['argc'] = func_num_args();
  949.  
  950. 		$this->data['VERSION'] = self::$version;
  951. 		$this->data['EOL'] = PHP_EOL;
  952.  
  953. 		$fn = $this->compiler->getFN();
  954.  
  955. 		return $fn($this->data);
  956. 	}
  957.  
  958. 	static function fromFile($path, array $options = array()){
  959. 		return new self(file_get_contents($path), $options);
  960. 	}
  961.  
  962. 	static function fromString($string, array $options = array()){
  963. 		return new self($string, $options);
  964. 	}
  965.  
  966. 	static function version(){
  967. 		return self::$version;
  968. 	}
  969. }
  970.  
  971. $code = <<<'CODE'
  972. {@fn F A,B}{@whileA is notmultipleB}{@incA}{@/}{@returnA}{@/}
  973.  
  974. {@fn Fn numberA, numberB}
  975.     {@while numberA is not multiple of numberB}
  976.         {@inc by 1 numberA}
  977.     {@/}
  978.     {@return numberA}
  979. {@/}
  980.  
  981. {@call F into result 5, 3}
  982. {@echo result}
  983. CODE;
  984.  
  985. $x = new SimpleTemplate($code);
  986.  
  987. echo $x->render(), PHP_EOL, PHP_EOL, '----------------- v PHP v -----------------', PHP_EOL, $x->getPHP();
Success #stdin #stdout 0.02s 24968KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
6

----------------- v PHP v -----------------
$_ = &$DATA;

// {@fn F A,B}
$DATA['F']= function()use(&$_){
	$DATA = array(
		'argv' => func_get_args(),
		'argc' => func_num_args(),
		'VERSION' => '0.82',
		'EOL' => PHP_EOL,
		'PARENT' => &$_
	);
	$_ = &$DATA;
	$DATA["A"] = &$DATA["argv"][0];
	$DATA["B"] = &$DATA["argv"][1];


	// {@whileA is notmultipleB}
	while(!(!((isset($DATA['A'])?$DATA['A']:null) % (isset($DATA['B'])?$DATA['B']:null)))){

		// {@incA}
		$DATA['A'] = SimpleTemplate_FN::call('inc', isset($DATA['A'])?$DATA['A']:0, 1);


	// {@/}
	};

	// {@returnA}
	return (isset($DATA['A'])?$DATA['A']:null);

// {@/}
};

// {@fn Fn numberA, numberB}
$DATA['Fn']= function()use(&$_){
	$DATA = array(
		'argv' => func_get_args(),
		'argc' => func_num_args(),
		'VERSION' => '0.82',
		'EOL' => PHP_EOL,
		'PARENT' => &$_
	);
	$_ = &$DATA;
	$DATA["numberA"] = &$DATA["argv"][0];
	$DATA["numberB"] = &$DATA["argv"][1];


	// {@while numberA is not multiple of numberB}
	while(!(!((isset($DATA['numberA'])?$DATA['numberA']:null) % (isset($DATA['numberB'])?$DATA['numberB']:null)))){

		// {@inc by 1 numberA}
		$DATA['numberA'] = SimpleTemplate_FN::call('inc', isset($DATA['numberA'])?$DATA['numberA']:0, 1);


	// {@/}
	};

	// {@return numberA}
	return (isset($DATA['numberA'])?$DATA['numberA']:null);

// {@/}
};

// {@call F into result 5, 3}
$DATA['result'] = call_user_func_array(
	(isset($DATA['F']) && is_callable($DATA['F'])
		? $DATA['F']
		: (SimpleTemplate_FN::method_exists('F')
			? SimpleTemplate_FN::call('F')
			: 'F'
		)
	),
	array(5, 3)
);

// {@echo result}
echo implode('', SimpleTemplate_FN::call('array_flat', (isset($DATA['result'])?$DATA['result']:null)));
https://ideone.com/MR7t1E
language:
PHP (php 7.3.5)
created:
4 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!