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_value'] . ')\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::parse_value(isset($bits['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. 				if(self::is_var($vars_var))
  492. 				{
  493. 					return <<<PHP
  494. {$tabs}// ~ optimization unfeasable ~ variable used in the first argument
  495. {$tabs}// loop variables - variable
  496. {$tabs}\${$tmp_name}val = isset({$vars_var}) ? \${$tmp_name}val = &{$vars_var} : null;
  497. {$tabs}\${$tmp_name}keys = gettype({$vars_var}) == 'array'
  498. {$tabs}	? array_keys({$vars_var})
  499. {$tabs}	: ((\${$tmp_name}val = \${$tmp_name}val . '')
  500. {$tabs}		? array_keys(range(0, strlen(\${$tmp_name}val = \${$tmp_name}val . '') - 1))
  501. {$tabs}		: array()
  502. {$tabs}	);
  503. {$tabs}\${$tmp_name}key_last = end(\${$tmp_name}keys);
  504. {$tabs}
  505. {$tabs}// loop
  506. {$tabs}foreach(\${$tmp_name}keys as \${$tmp_name}index => \${$tmp_name}key){
  507. {$tabs}	\${$var_name}['loop'] = array(
  508. {$tabs}		'index' => \${$tmp_name}index,
  509. {$tabs}		'i' => \${$tmp_name}index,
  510. {$tabs}		'key' => \${$tmp_name}key,
  511. {$tabs}		'k' => \${$tmp_name}key,
  512. {$tabs}		'value' => \${$tmp_name}val[\${$tmp_name}key],
  513. {$tabs}		'v' => \${$tmp_name}val[\${$tmp_name}key],
  514. {$tabs}		'first' => \${$tmp_name}key === \${$tmp_name}keys[0],
  515. {$tabs}		'last' => \${$tmp_name}key === \${$tmp_name}key_last,
  516. {$tabs}	);
  517. {$tabs}	{$vars_key} = \${$tmp_name}key;
  518. {$tabs}	{$vars_as} = \${$tmp_name}val[\${$tmp_name}key];
  519. PHP;
  520. 				}
  521. 				else if($this->options['optimize'])
  522. 				{
  523. 					$keys = '';
  524.  
  525. 					if($vars_var !== '""')
  526. 					{
  527. 						$keys = implode(
  528. 							',',
  529. 							range(
  530. 								0,
  531. 								strlen($vars_var) - ($vars_var[0] === '"' ? 3 : 1)
  532. 							)
  533. 						);
  534. 					}
  535.  
  536. 					return <<<PHP
  537. {$tabs}// ~ optimization ENABLED ~ \${$tmp_name}keys was inlined
  538. {$tabs}// loop variables - inline value
  539. {$tabs}\${$tmp_name}val = ({$vars_var}) . ''; // convert to string
  540. {$tabs}\${$tmp_name}keys = array({$keys});
  541. {$tabs}\${$tmp_name}key_last = end(\${$tmp_name}keys);
  542. {$tabs}
  543. {$tabs}// loop
  544. {$tabs}foreach(\${$tmp_name}keys as \${$tmp_name}index => \${$tmp_name}key){
  545. {$tabs}	\${$var_name}['loop'] = array(
  546. {$tabs}		'index' => \${$tmp_name}index,
  547. {$tabs}		'i' => \${$tmp_name}index,
  548. {$tabs}		'key' => \${$tmp_name}key,
  549. {$tabs}		'k' => \${$tmp_name}key,
  550. {$tabs}		'value' => \${$tmp_name}val[\${$tmp_name}key],
  551. {$tabs}		'v' => \${$tmp_name}val[\${$tmp_name}key],
  552. {$tabs}		'first' => \${$tmp_name}key === \${$tmp_name}keys[0],
  553. {$tabs}		'last' => \${$tmp_name}key === \${$tmp_name}key_last,
  554. {$tabs}	);
  555. {$tabs}	{$vars_key} = \${$tmp_name}key;
  556. {$tabs}	{$vars_as} = \${$tmp_name}val[\${$tmp_name}key];
  557. PHP;
  558. 				}
  559. 				else
  560. 				{
  561. 					return <<<PHP
  562. {$tabs}// ~ optimization DISABLED ~ \${$tmp_name}keys could be inlined
  563. {$tabs}// loop variables - inline value
  564. {$tabs}\${$tmp_name}val = ({$vars_var}) . ''; // convert to string
  565. {$tabs}\${$tmp_name}keys = \${$tmp_name}val
  566. {$tabs}	? array_keys(range(0, strlen(\${$tmp_name}val) - 1))
  567. {$tabs}	: array();
  568. {$tabs}\${$tmp_name}key_last = end(\${$tmp_name}keys);
  569. {$tabs}
  570. {$tabs}// loop
  571. {$tabs}foreach(\${$tmp_name}keys as \${$tmp_name}index => \${$tmp_name}key){
  572. {$tabs}	\${$var_name}['loop'] = array(
  573. {$tabs}		'index' => \${$tmp_name}index,
  574. {$tabs}		'i' => \${$tmp_name}index,
  575. {$tabs}		'key' => \${$tmp_name}key,
  576. {$tabs}		'k' => \${$tmp_name}key,
  577. {$tabs}		'value' => \${$tmp_name}val[\${$tmp_name}key],
  578. {$tabs}		'v' => \${$tmp_name}val[\${$tmp_name}key],
  579. {$tabs}		'first' => \${$tmp_name}key === \${$tmp_name}keys[0],
  580. {$tabs}		'last' => \${$tmp_name}key === \${$tmp_name}key_last,
  581. {$tabs}	);
  582. {$tabs}	{$vars_key} = \${$tmp_name}key;
  583. {$tabs}	{$vars_as} = \${$tmp_name}val[\${$tmp_name}key];
  584. PHP;
  585. 				}
  586. 			},
  587. 			'while' => function($data)use(&$replacement, &$brackets, &$tabs){
  588. 				++$brackets;
  589.  
  590. 				return $tabs . 'while(' . self::parse_boolean($data) . '){';
  591. 			},
  592. 			'for' => function($data)use(&$replacement, &$brackets, &$tabs){
  593. 				++$brackets;
  594.  
  595. 				return preg_replace_callback(
  596. 					'@(?<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'] . '))?@',
  597. 					function($matches)use(&$replacement, &$brackets, &$tabs){
  598.  
  599. 						$values = array(
  600. 							'start' => isset($matches['start']) && $matches['start'] !== '' ? self::parse_value($matches['start']) : '0',
  601. 							'end' => isset($matches['end']) ? self::parse_value($matches['end']) : self::parse_value($matches['start']),
  602. 							'step' => isset($matches['step']) ? self::parse_value($matches['step']) : '1'
  603. 						);
  604.  
  605. 						$return = $tabs . 'foreach(';
  606.  
  607. 						if(self::is_value($values['start']) && self::is_value($values['end']) && self::is_value($values['step']))
  608. 						{
  609. 							if($this->options['optimize'])
  610. 							{
  611. 								$return = "{$tabs}// ~ optimization enabled ~ inlining the results\r\n{$return}" . self::format_code(
  612. 									var_export(
  613. 										range(
  614. 											preg_replace('@^"|"$@', '', $values['start']),
  615. 											preg_replace('@^"|"$@', '', $values['end']),
  616. 											abs($values['step'])
  617. 										),
  618. 										true
  619. 									),
  620. 									$tabs . "\t",
  621. 									true
  622. 								);
  623. 							}
  624. 							else
  625. 							{
  626. 								$return = "{$tabs}// ~ optimization DISABLED ~ results could be inlined\r\n{$return}range({$values['start']}, {$values['end']}, abs({$values['step']}))";
  627. 							}
  628. 						}
  629. 						else
  630. 						{
  631. 							$return .= 'range(' . $values['start'] . ', ' . $values['end'] . ', abs(' . $values['step'] . '))';
  632. 						}
  633.  
  634. 						return $return . ' as ' . self::render_var(isset($matches['var']) ? $matches['var'] : '', false) . '){';
  635. 					},
  636. 					$data
  637. 				);
  638. 			},
  639. 			'do' => function($data)use(&$replacement, &$brackets, &$tabs){
  640. 				++$brackets;
  641.  
  642. 				return $tabs . 'do{';
  643. 			},
  644. 			'until' => function($data)use(&$replacement, &$brackets, &$tabs){
  645. 				--$brackets;
  646.  
  647. 				return substr($tabs, 1) . '}while(!(' . self::parse_boolean($data) . '));';
  648. 			},
  649. 			'set' => function($data)use(&$replacement, &$brackets, &$tabs){
  650. 				preg_match('@^\s*(?<op>[\+\-\*\\\/\%])?\s*(?<var>' . self::$regex['var'] . ')\s*(?:(?<op_val>' . self::$regex['var_value'] . ')\s)?\s*(?<values>.*)$@', $data, $bits);
  651.  
  652. 				$values = self::parse_values($bits['values']);
  653. 				$count = count($values);
  654.  
  655. 				$return = $tabs . self::render_var($bits['var'], false) . ' = ';
  656.  
  657. 				$close = 0;
  658.  
  659. 				if(isset($bits['op']))
  660. 				{
  661. 					switch($bits['op'])
  662. 					{
  663. 						case '-':
  664. 							$return .= <<<PHP
  665. call_user_func_array(function(){
  666. {$tabs}	\$args = func_get_args();
  667. {$tabs}	\$initial = array_shift(\$args);
  668. {$tabs}	return array_reduce(\$args, function(\$carry, \$value){
  669. {$tabs}		return \$carry - \$value;
  670. {$tabs}	}, \$initial);
  671. {$tabs}}, SimpleTemplate_FN::call('array_flat', 
  672. PHP;
  673. 							$close = 2;
  674. 							break;
  675. 						case '+':
  676. 							$return .= 'array_sum(SimpleTemplate_FN::call(\'array_flat\', ';
  677. 							$close = 2;
  678. 							break;
  679. 						case '*':
  680. 							$return .= 'array_product(SimpleTemplate_FN::call(\'array_flat\', ';
  681. 							$close = 2;
  682. 							break;
  683. 						case '\\':
  684. 						case '/':
  685. 						case '%':
  686. 							$ops = array(
  687. 								'\\' => 'round(%s / $value)',
  688. 								'/' => '(%s / $value)',
  689. 								'%' => '(%s %% $value)'
  690. 							);
  691.  
  692. 							$return .= 'array_map(function($value)use(&$' . self::$var_name . '){'
  693. 								.'return ' . sprintf(
  694. 									$ops[$bits['op']],
  695. 									isset($bits['op_val'])
  696. 										? self::parse_value($bits['op_val'])
  697. 										: self::render_var($bits['var'], false)
  698. 								)
  699. 								. ';}, SimpleTemplate_FN::call(\'array_flat\', ';
  700. 							$close = 2;
  701. 							break;
  702. 					}
  703. 				}
  704.  
  705. 				if($count > 1)
  706. 				{
  707. 					$return .= 'array(' . implode(',', $values) . ')';
  708. 				}
  709. 				else
  710. 				{
  711. 					$return .= ($count && strlen($values[0]) ? $values[0] : 'null');
  712. 				}
  713.  
  714. 				return $return . str_repeat(')', $close) . ';';
  715. 			},
  716. 			'unset' => function($data)use(&$replacement, &$brackets, &$tabs){
  717. 				$values = self::parse_values($data, null, false);
  718. 				$vars = array_filter($values, function($var){
  719. 					return !self::is_value($var);
  720. 				});
  721.  
  722. 				$return = $tabs . (
  723. 					count($values) !== count($vars)
  724. 						? '// Warning: invalid values were passed' . PHP_EOL . $tabs
  725. 						: ''
  726. 				);
  727.  
  728. 				return $return . (
  729. 					$vars
  730. 						? 'unset(' . implode(',', $vars) . ');'
  731. 						: '// Warning: no values were passed or all were filtered out'
  732. 				);
  733. 			},
  734. 			'global' => function($data)use(&$replacement, &$brackets, &$tabs){
  735. 				$data = self::split_values($data, ' ');
  736.  
  737. 				return $tabs . self::render_var(array_shift($data), false) . ' = $GLOBALS[\'' . join('\'][\'', $data) . '\'];';
  738. 			},
  739. 			'call' => function($data)use(&$replacement, &$brackets, &$tabs){
  740. 				preg_match('@^\s*(?<fn>' . self::$regex['var'] . ')\s*(?:into\s*(?<into>' . self::$regex['var'] . ')\s*)?(?<args>.*?)$@', $data, $bits);
  741.  
  742. 				$var = self::render_var($bits['fn'], false);
  743.  
  744. 				$into = $bits['into'] ? self::render_var($bits['into'], false) . ' = ' : '';
  745. 				$args = implode(', ', self::parse_values($bits['args']));
  746. 				$alt_name = str_replace('.', '_', $bits['fn']);
  747.  
  748. 				return <<<PHP
  749. {$tabs}{$into}call_user_func_array(
  750. {$tabs}	(isset({$var}) && is_callable({$var})
  751. {$tabs}		? {$var}
  752. {$tabs}		: (SimpleTemplate_FN::method_exists('{$bits['fn']}')
  753. {$tabs}			? SimpleTemplate_FN::call('{$bits['fn']}')
  754. {$tabs}			: '{$alt_name}'
  755. {$tabs}		)
  756. {$tabs}	),
  757. {$tabs}	array({$args})
  758. {$tabs});
  759. PHP;
  760. 			},
  761. 			'php' => function($data)use(&$replacement, &$brackets, &$tabs){
  762. 				return $tabs . 'call_user_func_array(function(&$' . self::$var_name . '){' . PHP_EOL
  763. 					   . "{$tabs}\t{$data};" . PHP_EOL
  764. 					   . $tabs . '}, array(&$' . self::$var_name . '));';
  765. 			},
  766. 			'return' => function($data)use(&$replacement, &$brackets, &$tabs){
  767. 				return $tabs . 'return' . ($data || $data === '0' ? ' ' . self::parse_value($data) : '') . ';';
  768. 			},
  769. 			'inc' => function($data)use(&$replacement, &$brackets, &$tabs){
  770. 				preg_match('@^(?:\s*by\s*(?<by>' . self::$regex['var_value'] . ')\s*)?(?<values>.*?)$@', $data, $bits);
  771. 				$values = self::parse_values($bits['values'], '\s*,\s*', false);
  772. 				$inc = isset($bits['by']) && $bits['by'] !== '' ? self::parse_value($bits['by']): '1';
  773.  
  774. 				$return = '';
  775.  
  776. 				if(!$inc || $inc === '"0"' || $inc === 'null' || $inc === 'false')
  777. 				{
  778. 					if($this->options['optimize'])
  779. 					{
  780. 						return "{$tabs}// ~ optimization enabled ~ increment by {$inc} removed";
  781. 					}
  782. 					else
  783. 					{
  784. 						$return .= "{$tabs}// ~ optimization DISABLED ~ increment by {$inc} could be removed" . PHP_EOL;
  785. 					}
  786. 				}
  787.  
  788. 				$var_name = self::$var_name;
  789.  
  790. 				foreach($values as $value)
  791. 				{
  792. 					if(!isset($value[0]) && !self::is_value($value[0]))
  793. 					{
  794. 						continue;
  795. 					}
  796.  
  797. 					$return .= "{$tabs}{$value} = SimpleTemplate_FN::call('inc', isset({$value})?{$value}:0, {$inc});" . PHP_EOL;
  798. 				}
  799.  
  800. 				return $return;
  801.  
  802. 			},
  803. 			'fn' => function($data)use(&$replacement, &$brackets, &$tabs){
  804. 				if(
  805. 					preg_match(
  806. 						'@^\s*(' . self::$regex['var_simple'] . ')(?:\s+(' . self::$regex['var_name'] . '(?:,\s*' . self::$regex['var_name'] . ')*))?$@',
  807. 						$data, $bits
  808. 					) === false
  809. 				)
  810. 				{
  811. 					return '';
  812. 				}
  813.  
  814. 				++$brackets;
  815.  
  816. 				$version = SimpleTemplate::version();
  817. 				$var_name = self::$var_name;
  818.  
  819. 				$return = $tabs . self::render_var($bits ? $bits[1] : null, false) . <<<PHP
  820. = function()use(&\$_){
  821. {$tabs}	\${$var_name} = array(
  822. {$tabs}		'argv' => func_get_args(),
  823. {$tabs}		'argc' => func_num_args(),
  824. {$tabs}		'VERSION' => '{$version}',
  825. {$tabs}		'EOL' => PHP_EOL,
  826. {$tabs}		'PARENT' => &\$_
  827. {$tabs}	);
  828. {$tabs}	\$_ = &\${$var_name};
  829.  
  830. PHP;
  831. 				if(isset($bits[2]) && $bits[2])
  832. 				{
  833. 					$args = array();
  834. 					foreach(self::split_values($bits[2]) as $value)
  835. 					{
  836. 						if(!self::is_value(self::parse_value($value)))
  837. 						{
  838. 							$args[] = $value;
  839. 						}
  840. 					}
  841.  
  842. 					foreach($args as $k => $arg)
  843. 					{
  844. 						$return .= "{$tabs}	\${$var_name}[\"{$arg}\"] = &\${$var_name}[\"argv\"][{$k}];" . PHP_EOL;
  845. 					}
  846. 				}
  847.  
  848. 				return $return;
  849. 			},
  850. 			'eval' => function($data)use(&$replacement, &$brackets, &$tabs){
  851. 				$return = '';
  852. 				$value = self::parse_value($data);
  853.  
  854. 				if($this->options['optimize'] && self::is_value($value))
  855. 				{
  856. 					$return = $tabs . '// ~ optimization enabled ~ trying to avoid compiling in runtime' . PHP_EOL;
  857.  
  858. 					static $cached = array();
  859.  
  860. 					$sha1 = sha1($value);
  861.  
  862. 					if(isset($cached[$sha1]))
  863. 					{
  864. 						$return .= $tabs . '// {@eval} cached code found: cache entry ';
  865. 					}
  866. 					else
  867. 					{
  868. 						$return .= $tabs . '// {@eval} no cached code found: creating entry ';
  869.  
  870. 						$compiler = new SimpleTemplate_Compiler($this->template, stripslashes(trim($value, '"')), $this->options);
  871.  
  872. 						$cached[$sha1] = self::format_code($compiler->getPHP() . '// {@eval} ended', $tabs);
  873.  
  874. 						unset($compiler);
  875. 					}
  876.  
  877. 					$return .= $sha1 . PHP_EOL . $cached[$sha1];
  878. 				}
  879. 				else
  880. 				{
  881. 					$options = self::format_code(var_export($this->options, true), $tabs . "\t\t", true);
  882.  
  883. 					$return = <<<PHP
  884. {$tabs}// ~ optimization DISABLED or unfeasable ~ compilation in runtime is required
  885. {$tabs}call_user_func_array(function()use(&\$DATA){
  886. {$tabs}	\$compiler = new SimpleTemplate_Compiler(\$this, {$value}, {$options});
  887. {$tabs}	\$fn = \$compiler->getFN();
  888. {$tabs}	return \$fn(\$DATA);
  889. {$tabs}}, array());
  890. PHP;
  891. 				}
  892.  
  893. 				return $return;
  894. 			}
  895. 		);
  896.  
  897. 		$trim_fn = $this->options['trim'] ? 'trim' : '';
  898.  
  899. 		$this->php .= "\r\necho {$trim_fn}(<<<'" . self::$var_name . "{$UUID}'\r\n"
  900. 			. preg_replace_callback(
  901. 				// http://stackoverflow.com/a/6464500
  902. 				'~{@(eval|echoj?l?|print|if|else|for|while|each|do|until|(?:un)?set|call|global|php|return|inc|fn|//?)(?:\\s*(.*?))?}(?=(?:[^"\\\\]*(?:\\\\.|"(?:[^"\\\\]*\\\\.)*[^"\\\\]*"))*[^"]*$)~',
  903. 				function($matches)use(&$replacement, &$brackets, &$tabs, &$UUID, &$trim_fn){
  904.  
  905. 					$tabs = $brackets
  906. 						? str_repeat("\t", $brackets - ($matches[1] === '/'))
  907. 						: '';
  908.  
  909. 					$var_name = self::$var_name;
  910.  
  911. 					$php = $replacement[$matches[1]](isset($matches[2]) ? $matches[2] : null);
  912.  
  913. 					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";
  914. 				},
  915. 				$str . ''
  916. 			)
  917. 			. "\r\n" . self::$var_name . "{$UUID}\r\n);\r\n";
  918.  
  919. 		$this->php = preg_replace(
  920. 			array(
  921. 				'@\r\n\t*echo\s*' . $trim_fn . '\(<<<\'' . self::$var_name . $UUID . '\'(?:\s*\r\n)?' . self::$var_name . $UUID . '\r\n\);@',
  922. 				'@\r\n' . self::$var_name . $UUID . '\r\n\);(\r\n)*\t*echo\s*' . $trim_fn . '\(<<<\'' . self::$var_name . $UUID . '\'@'
  923. 			),
  924. 			array(
  925. 				'', ''
  926. 			),
  927. 			$this->php
  928. 		);
  929.  
  930. 		if($brackets)
  931. 		{
  932. 			$this->php .=  "\r\n// AUTO-CLOSE\r\n" . str_repeat('};', $brackets);
  933. 		}
  934. 	}
  935.  
  936. 	function getPHP(){
  937. 		return $this->php;
  938. 	}
  939.  
  940. 	function getFN(){
  941. 		if(!$this->fn)
  942. 		{
  943. 			$this->fn = eval('return function(&$' . self::$var_name . '){'
  944. 					. PHP_EOL . $this->php . PHP_EOL
  945. 				. '};'
  946. 			);
  947.  
  948. 			$this->fn = $this->fn->bindTo($this->template);
  949. 		}
  950.  
  951. 		return $this->fn;
  952. 	}
  953.  
  954. 	function __construct(SimpleTemplate $template, $code, array $options = array()){
  955. 		$this->options = $options;
  956. 		$this->template = $template;
  957.  
  958. 		// ALMOST unguessable name, to avoid syntax errors
  959. 		$this->uuid = str_shuffle(mt_rand() . time() . sha1($code));
  960.  
  961. 		$this->compile($code);
  962. 	}
  963. }
  964.  
  965. // base class
  966. class SimpleTemplate {
  967. 	private static $version = '0.84';
  968.  
  969. 	private $data = array();
  970. 	private $settings = array(
  971. 		'optimize' => true,
  972. 		'trim' => false
  973. 	);
  974.  
  975. 	private $compiler = null;
  976.  
  977. 	function __construct($code, array $options = array()){
  978. 		if(!$code)
  979. 		{
  980. 			throw new Exception('No code was provided');
  981. 		}
  982.  
  983. 		if($options)
  984. 		{
  985. 			$this->settings = array_merge($this->settings, $options);
  986. 		}
  987.  
  988. 		$this->compiler = new SimpleTemplate_Compiler($this, $code, $this->settings);
  989. 	}
  990.  
  991. 	function setData($key, $value){
  992. 		$this->data[$key] = $value;
  993. 	}
  994.  
  995. 	function getData($key, $value){
  996. 		return isset($this->data[$key]) ? $this->data[$key] : null;
  997. 	}
  998.  
  999. 	function unsetData($key){
  1000. 		unset($this->data[$key]);
  1001. 	}
  1002.  
  1003. 	function loadData($data){
  1004. 		foreach($data as $k => $value)
  1005. 		{
  1006. 			$this->data[$k] = $value;
  1007. 		}
  1008. 	}
  1009.  
  1010. 	function clearData(){
  1011. 		$this->data = array();
  1012. 	}
  1013.  
  1014. 	function getPHP(){
  1015. 		return $this->compiler->getPHP();
  1016. 	}
  1017.  
  1018. 	function render(){
  1019. 		$this->data['argv'] = func_get_args();
  1020. 		$this->data['argc'] = func_num_args();
  1021.  
  1022. 		$this->data['VERSION'] = self::$version;
  1023. 		$this->data['EOL'] = PHP_EOL;
  1024.  
  1025. 		$fn = $this->compiler->getFN();
  1026.  
  1027. 		return $fn($this->data);
  1028. 	}
  1029.  
  1030. 	static function fromFile($path, array $options = array()){
  1031. 		return new self(file_get_contents($path), $options);
  1032. 	}
  1033.  
  1034. 	static function fromString($string, array $options = array()){
  1035. 		return new self($string, $options);
  1036. 	}
  1037.  
  1038. 	static function version(){
  1039. 		return self::$version;
  1040. 	}
  1041. }
  1042.  
  1043. $code = array(
  1044.     'golfed' => '{@setC 0}{@for_ from"	"to"m"}{@echolC}{@incC}',
  1045.     'ungolfed' => <<<'CODE'
  1046. {@set counter 0}
  1047. {@for i from "	" to "m"}
  1048.     {@echo counter, EOL}
  1049.     {@inc counter}
  1050. {@/}
  1051. CODE
  1052. );
  1053.  
  1054. $input = '';
  1055.  
  1056. $key = 'golfed'; // golfed - ungolfed
  1057.  
  1058. $x = new SimpleTemplate($c = $code[$key]);
  1059.  
  1060. echo $x->render($input), PHP_EOL, PHP_EOL, '----------------- v PHP v -----------------', PHP_EOL, $x->getPHP();
  1061. echo PHP_EOL, PHP_EOL, '----------------- v CODE (',  strlen($c), 'b - ', $key, ') v -----------------', PHP_EOL, $c;
Success #stdin #stdout 0.03s 25256KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100


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

// {@setC 0}
$DATA['C'] = 0;

// {@for_ from"	"to"m"}
// ~ optimization enabled ~ inlining the results
foreach(array (
	0 => '	',
	1 => '
	',
	2 => '',
	3 => '',
	4 => '
	',
	5 => '',
	6 => '',
	7 => '',
	8 => '',
	9 => '',
	10 => '',
	11 => '',
	12 => '',
	13 => '',
	14 => '',
	15 => '',
	16 => '',
	17 => '',
	18 => '',
	19 => '',
	20 => '',
	21 => '',
	22 => '',
	23 => ' ',
	24 => '!',
	25 => '"',
	26 => '#',
	27 => '$',
	28 => '%',
	29 => '&',
	30 => '\'',
	31 => '(',
	32 => ')',
	33 => '*',
	34 => '+',
	35 => ',',
	36 => '-',
	37 => '.',
	38 => '/',
	39 => '0',
	40 => '1',
	41 => '2',
	42 => '3',
	43 => '4',
	44 => '5',
	45 => '6',
	46 => '7',
	47 => '8',
	48 => '9',
	49 => ':',
	50 => ';',
	51 => '<',
	52 => '=',
	53 => '>',
	54 => '?',
	55 => '@',
	56 => 'A',
	57 => 'B',
	58 => 'C',
	59 => 'D',
	60 => 'E',
	61 => 'F',
	62 => 'G',
	63 => 'H',
	64 => 'I',
	65 => 'J',
	66 => 'K',
	67 => 'L',
	68 => 'M',
	69 => 'N',
	70 => 'O',
	71 => 'P',
	72 => 'Q',
	73 => 'R',
	74 => 'S',
	75 => 'T',
	76 => 'U',
	77 => 'V',
	78 => 'W',
	79 => 'X',
	80 => 'Y',
	81 => 'Z',
	82 => '[',
	83 => '\\',
	84 => ']',
	85 => '^',
	86 => '_',
	87 => '`',
	88 => 'a',
	89 => 'b',
	90 => 'c',
	91 => 'd',
	92 => 'e',
	93 => 'f',
	94 => 'g',
	95 => 'h',
	96 => 'i',
	97 => 'j',
	98 => 'k',
	99 => 'l',
	100 => 'm',
) as $DATA['_']){

	// {@echolC}
	echo implode('', SimpleTemplate_FN::call('array_flat', (isset($DATA['C'])?$DATA['C']:null)));echo PHP_EOL;

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



// AUTO-CLOSE
};

----------------- v CODE (45b - golfed) v -----------------
{@setC 0}{@for_ from"	"to"m"}{@echolC}{@incC}
https://ideone.com/tLsDFn
language:
PHP (php 7.3.5)
created:
3 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!