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