PageRenderTime 26ms CodeModel.GetById 11ms RepoModel.GetById 0ms app.codeStats 0ms

/system/core/Template/class.VTE.php

https://gitlab.com/vanthanhhoh/devlovebook
PHP | 596 lines | 508 code | 49 blank | 39 comment | 99 complexity | f8575e1ee4225946628bee3f61e6be7b MD5 | raw file
    

  1. <?php
    2. 

  2. 

  3. //$ArrayElement = '(\w+(?:\.\${0,1}[A-Za-z0-9_]+)*(?:(?:\[\${0,1}[A-Za-z0-9_]+\])|(?:\-\>\${0,1}[A-Za-z0-9_]+))*)(.*?)';
    4. 

  4. 

  5. class VTE
    6. 

  6. {
    7. 

  7. 	private		$Tag = array('left' => '{', 'right' => '}');
    8. 

  8. 	protected	$SingleVar = '[a-zA-Z0-9\_]';
    9. 

  9. 	protected	$VarElement = '\w+(?:\.\${0,1}[A-Za-z0-9_]+)*(?:(?:\[\${0,1}[A-Za-z0-9_]+\])|(?:\-\>\${0,1}[A-Za-z0-9_]+))*(.*?)';
    10. 

  10. 

  11. 	private $CACHE_EXPIRE_TIME = 3600; // default cache expire time = hour
    12. 

  12. 	private $InputTPLString = '';
    13. 

  13. 	private $TPLFileName = '';
    14. 

  14. 	private $HtmlString = '';
    15. 

  15. 	private $CompiledPHPCode = '';
    16. 

  16. 	private $TPLFilePath = '';
    17. 

  17. 	private $CompiledFilePath = '';
    18. 

  18. 	private $CachedFilePath = '';
    19. 

  19. 	private $ReCompile = false;
    20. 

  20. 	private $IsCache = false;
    21. 

  21. 	private $VAR = array();
    22. 

  22. 

  23. 	static $TPLFileDir = '/';
    24. 

  24. 	static $CompiledDir = '/';
    25. 

  25. 	static $CacheDir = '/';
    26. 

  26. 	static	$MergedDir = '/';
    27. 

  27. 

  28. 	public $_TPLFileDir = '/';
    29. 

  29. 	public $_CompiledDir = '/';
    30. 

  30. 	public $_CacheDir = '/';
    31. 

  31. 	public $_MergedDir = '/';
    32. 

  32. 

  33. 	public $TPLFileExt = '.tpl';
    34. 

  34. 	static function TPLFileDir($TPLFileDir) {
    35. 

  35. 		self::$TPLFileDir = $TPLFileDir;
    36. 

  36. 	}
    37. 

  37. 

  38. 	public function __construct() {
    39. 

  39. 		$this->_TPLFileDir = self::$TPLFileDir;
    40. 

  40. 		$this->_CompiledDir = self::$CompiledDir;
    41. 

  41. 		$this->_CacheDir = self::$CacheDir;
    42. 

  42. 		$this->_MergedDir = self::$MergedDir;
    43. 

  43. 	}
    44. 

  44. 

  45. 	public function SetDir($Name, $Value) {
    46. 

  46. 		$Name = '_' . $Name;
    47. 

  47. 		$this->$Name = $Value;
    48. 

  48. 		return $this;
    49. 

  49. 	}
    50. 

  50. 

  51. 	public function String($HtmlString = '', $ReCompile = false, $IsCache = false) {
    52. 

  52. 		$this->ReCompile = $ReCompile;
    53. 

  53. 		$this->IsCache = $IsCache;
    54. 

  54. 		$this->HtmlString = $HtmlString;
    55. 

  55. 		return $this;
    56. 

  56. 	}
    57. 

  57. 

  58. 	public function Compiled($CompiledPHPCode, $ReCompile = false, $IsCache) {
    59. 

  59. 		$this->ReCompile = $ReCompile;
    60. 

  60. 		$this->IsCache = $IsCache;
    61. 

  61. 		$this->CompiledPHPCode = $CompiledPHPCode;
    62. 

  62. 		return $this;
    63. 

  63. 	}
    64. 

  64. 

  65. 	public function File($TPLFile = '', $ReCompile = false, $IsCache = false) {
    66. 

  66. 		$this->ReCompile = $ReCompile;
    67. 

  67. 		$this->IsCache = $IsCache;
    68. 

  68. 		if(file_exists($TPLFile)) {
    69. 

  69. 			$this->SetDir('TPLFileDir', dirname($TPLFile) . DIRECTORY_SEPARATOR);
    70. 

  70. 			$this->TPLFileName = rtrim(basename($TPLFile), '.tpl');
    71. 

  71. 		}
    72. 

  72. 		else $this->TPLFileName = $TPLFile;
    73. 

  73. 		return $this;
    74. 

  74. 	}
    75. 

  75. 

  76. 	public function Assign($Name, $Value = NULL) {
    77. 

  77. 		is_array($Name) ? $this->VAR += $Name : $this->VAR[$Name] = $Value;
    78. 

  78. 		return $this;
    79. 

  79. 	}
    80. 

  80. 

  81. 	public function Output($Return = true, $ReturnCompiled = false) {
    82. 

  82. 		if($this->TPLFileName != '') $this->InputTPLString = $this->ReadTPLFile();
    83. 

  83. 		$TPLFileName = rtrim(basename($this->TPLFilePath), $this->TPLFileExt);
    84. 

  84. 		$EncodedFileName = $TPLFileName . '_' . md5($this->TPLFilePath);
    85. 

  85. 		$this->CompiledFilePath = $this->_CompiledDir . $EncodedFileName . '.php';
    86. 

  86. 		$this->CachedFilePath = $this->_CacheDir . $EncodedFileName . '.html';
    87. 

  87. 		if(	$this->ReCompile ||
    88. 

  88. 			!file_exists($this->CompiledFilePath) ||
    89. 

  89. 			(file_exists($this->CompiledFilePath) && filemtime($this->CompiledFilePath) < filemtime($this->TPLFilePath))
    90. 

  90. 		) $ReCompile = true;
    91. 

  91. 		else $ReCompile = false;
    92. 

  92. 

  93. 		if($ReCompile) $this->CompileTPL();
    94. 

  94. 		if($ReturnCompiled) {
    95. 

  95. 			$CompiledContent = file_get_contents($this->CompiledFilePath);
    96. 

  96. 			return array('var' => $this->VAR, 'content' => $CompiledContent);
    97. 

  97. 		}
    98. 

  98. 		elseif($this->IsCache) {
    99. 

  99. 			$CacheLifeTime = time() - filemtime($this->CachedFilePath);
    100. 

  100. 			if(file_exists($this->CachedFilePath) && $CacheLifeTime < $this->CACHE_EXPIRE_TIME )
    101. 

  101. 				file_get_contents( $this->CachedFilePath );
    102. 

  102. 			else
    103. 

  103. 				file_put_contents($this->CachedFilePath, $OutputContent );
    104. 

  104. 		}
    105. 

  105. 		elseif(!$Return && !$this->IsCache) {
    106. 

  106. 			extract($this->VAR);
    107. 

  107. 			include $this->CompiledFilePath;
    108. 

  108. 		}
    109. 

  109. 		else {
    110. 

  110. 			ob_start();
    111. 

  111.             extract($this->VAR);
    112. 

  112.             include $this->CompiledFilePath;
    113. 

  113.             $OutputContent = ob_get_clean();
    114. 

  114.             // return or print the template
    115. 

  115.             if($Return) return $OutputContent; else echo $OutputContent;
    116. 

  116. 		}
    117. 

  117. 	}
    118. 

  118. 

  119. 	private function ReadTPLFile() {
    120. 

  120. 		$this->TPLFilePath = $this->_TPLFileDir . $this->TPLFileName . $this->TPLFileExt;
    121. 

  121. 		if(file_exists($this->TPLFilePath)) {
    122. 

  122. 			return file_get_contents($this->TPLFilePath);
    123. 

  123. 		}
    124. 

  124. 		else {
    125. 

  125. 			throw new VTE_Exception ('TPL file not found ' . $this->TPLFilePath);
    126. 

  126. 			trigger_error('TPL file not found ' . $this->TPLFilePath);
    127. 

  127. 		}
    128. 

  128. 	}
    129. 

  129. 

  130. 	private function DetectCodeTag() {
    131. 

  131. 		$SingleVar = $this->SingleVar;
    132. 

  132. 		$VarElement = $this->VarElement;
    133. 

  133. 

  134. 		$CodesCheck =
    135. 

  135. 			array(
    136. 

  136. 				'if'		=> 'if(:condition){0,1}\s*\(.*\)',
    137. 

  137. 				'elseif'	=> 'elseif(:condition){0,1}\s*\(.*\)',
    138. 

  138. 				'else'		=> 'else',
    139. 

  139. 				'end_if'	=> '\/if',
    140. 

  140. 				'for'		=> 'for\s+\$' . $SingleVar . '+\s+in\s+\$' . $VarElement . '*\s*(?: as\s+\$' . $SingleVar . '+)?',
    141. 

  141. 				'end_for'	=> '\/for',
    142. 

  142. 				'while'		=> 'while(:condition){0,1}\s*\(.*\)',
    143. 

  143. 				'end_while'	=> '\/while',
    144. 

  144. 				'skip'		=> 'skip',
    145. 

  145. 				'end_skip'	=> '\/skip',
    146. 

  146. 				'comment'	=> '\/\*\*',
    147. 

  147. 				'end_comment'	=> '\*\*\/',
    148. 

  148. 				'function'	=> 'function',
    149. 

  149. 				'end_function'	=> '\/function',
    150. 

  150. 				'do'		=> 'do',
    151. 

  151. 				'end_do'	=> '\/do',
    152. 

  152. 				'block'		=> '\{block(:block_name){0,1}\s*\:\:\s*.*\}',
    153. 

  153. 				'lang'		=> '\{lang\s*\:\:\s*(:pharse){0,1}\s*[a-zA-Z0-9\_\-\s]*(?:\:.*){0,1}\}'
    154. 

  154. 			);
    155. 

  155. 

  156. 		$_c = array();
    157. 

  157. 		foreach($CodesCheck as $key =>$code)
    158. 

  158. 			$_c[$key] = '(\\' . $this->Tag['left'] . $code . '\\' . $this->Tag['right'] . ')';
    159. 

  159. 

  160. 		$_c['area'] = '(\[\@.*\@\])';
    161. 

  161. 

  162. 		$CodesCheck = $_c; unset($_c);
    163. 

  163. 		$CodesCheck = '/' . join('|', $CodesCheck) . '/';
    164. 

  164. 		$return = preg_split ($CodesCheck, $this->InputTPLString, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
    165. 

  165. 		//n($return);
    166. 

  166. 		//die();
    167. 

  167. 		return $return;
    168. 

  168. 	}
    169. 

  169. 

  170. 	private function VariableTrueForm($Var) {
    171. 

  171. 		$_temp = preg_split( "/\.|\[|\-\>/", $Var );
    172. 

  172. 		$VarName = $_temp[0];
    173. 

  173. 		//variable path
    174. 

  174. 		$VariablePath = substr( $Var, strlen( $VarName ) );
    175. 

  175. 		//parentesis transform [ e ] in [" e in "]
    176. 

  176.         if(!empty($VariablePath)) {
    177. 

  177.             if(preg_match_all('/' . '(.*)\[\$(.*)\](.*)' . '/', $VariablePath, $matches)) {
    178. 

  178.                 if(isset($matches[2][0]) && !empty($matches[2][0])) {
    179. 

  179.                     $VariablePath = '[$' . $this->VariableTrueForm($matches[2][0]) . ']';
    180. 

  180.                 }
    181. 

  181.             }
    182. 

  182.             else {
    183. 

  183.                 if(!empty($VariablePath)) {
    184. 

  184.                     $VariablePath = str_replace( '[', '["', $VariablePath );
    185. 

  185.                     $VariablePath = str_replace( ']', '"]', $VariablePath );
    186. 

  186.                 }
    187. 

  187.             }
    188. 

  188.         }
    189. 

  189. 		//transform .$variable in ["$variable"] and .variable in ["variable"]
    190. 

  190.         if(!empty($VariablePath)) {
    191. 

  191. 			$VariablePath = preg_replace('/\.(\w+)/', "['\\1']", $VariablePath );
    192. 

  192. 			$VariablePath = preg_replace('/\.(\${1}\w+)/', '[\\1]', $VariablePath );
    193. 

  193. 		}
    194. 

  194. 		return $VarName . $VariablePath;
    195. 

  195. 	}
    196. 

  196. 

  197. 	private function CompileFunction($Code, $echo = false) {
    198. 

  198. 		//if(preg_match_all('/' . '\{\#{0,1}(\"{0,1}.*?\"{0,1})(\|\w.*?)\#{0,1}\}' . '/', $Code, $matches)) {
    199. 

  199. 		//if(preg_match_all('/' . '\{(\#{0,1}\${0,1}[a-zA-Z0-9\_]*?)(\|\${0,1}\w.*?)\}' . '/', $Code, $matches)) {
    200. 

  200. 		if(preg_match_all('/' . '\{(\#{0,1}\${0,1}\w+(?:\.\${0,1}[A-Za-z0-9_]+)*(?:(?:\[\${0,1}[A-Za-z0-9_]+\])|(?:\-\>\${0,1}[A-Za-z0-9_]+))*?)(\|\${0,1}\w.*?)\}' . '/', $Code, $matches)) {
    201. 

  201. 			$Parsed = array();
    202. 

  202.             //n($matches);
    203. 

  203. 			$TotalTags = count($matches[0]);
    204. 

  204. 			for($tagIndex = 0; $tagIndex < $TotalTags; $tagIndex++) {
    205. 

  205.                 $Tag = array();
    206. 

  206. 				$Tag['key']				= $matches[0][$tagIndex];
    207. 

  207. 				$Tag['VariableName']	= $matches[1][$tagIndex];
    208. 

  208. 				$Tag['ExtraFunction']	= $matches[2][$tagIndex];
    209. 

  209. 				$Tag['FunctionName']	= '';
    210. 

  210. 				$Tag['FunctionParams']	= '';
    211. 

  211. 

  212. 				if(preg_match_all('/\{(\$' . $this->VarElement . ')((?:\+\+|\-\-|\+=|\-=|\*=|=|\.=)([^=].*))\}/', $Tag['key'], $m)){
    213. 

  213. 					$VarKey = $m[1][0];
    214. 

  214. 					$IsInitializeVar = true;
    215. 

  215. 					$InitializeVar = $m[1][0];
    216. 

  216. 					$FunctionVar = trim($m[3][0]);
    217. 

  217. 					$VarOnly = trim($m[4][0]);
    218. 

  218. 					$subLength = strlen($FunctionVar) - strlen($VarOnly);
    219. 

  219. 					$Math = trim(substr($FunctionVar, 0, $subLength));
    220. 

  220. 					$VarOnly = substr($VarOnly, 0, -strlen($Tag['ExtraFunction']));
    221. 

  221. 

  222. 					if($Tag['ExtraFunction'] && $Tag['ExtraFunction'][0] == '|') {
    223. 

  223. 						$Tag['ExtraFunction'] = ltrim($Tag['ExtraFunction'], '|');
    224. 

  224. 						//Check Static Class method
    225. 

  225. 						if(strpos($Tag['ExtraFunction'], '::') != NULL)
    226. 

  226. 							$Tag['ExtraFunction'] = str_replace('::', '@@StaticClassMethodSignal@@', $Tag['ExtraFunction']);
    227. 

  227. 						if(strpos($Tag['ExtraFunction'], ':') != NULL) {
    228. 

  228. 							$_f = explode(':', $Tag['ExtraFunction']);
    229. 

  229. 							$Tag['FunctionName']	= $_f[0];
    230. 

  230. 							$Tag['FunctionParams']	= $_f[1];
    231. 

  231. 						}
    232. 

  232. 						else $Tag['FunctionName'] = $Tag['ExtraFunction'];
    233. 

  233. 

  234. 						$Tag['FunctionName'] = str_replace('@@StaticClassMethodSignal@@', '::', $Tag['FunctionName']);
    235. 

  235. 						$FunctionName	= trim($Tag['FunctionName']);
    236. 

  236. 						$InitializeVar	= $this->VariableTrueForm(trim($InitializeVar));
    237. 

  237. 						$VarOnly	= $this->VariableTrueForm(trim($VarOnly));
    238. 

  238. 						$ExtraParams	= $Tag['FunctionParams'];
    239. 

  239. 						$PhpCompiled = !empty($ExtraParams) ? "$InitializeVar $Math $FunctionName($VarOnly,$ExtraParams)" : "$InitializeVar $Math $FunctionName($VarOnly)";
    240. 

  240. 						$PhpCompiled = '<?php ' . $PhpCompiled . ' ?>';
    241. 

  241. 						$Code = str_replace($Tag['key'], $PhpCompiled, $Code);
    242. 

  242. 					}
    243. 

  243. 				}
    244. 

  244. 				else {
    245. 

  245. 					if($Tag['ExtraFunction'] && $Tag['ExtraFunction'][0] == '|') {
    246. 

  246. 						$ExtraFunctions = array_filter(explode('|', $Tag['ExtraFunction']));
    247. 

  247. 						$PhpCompiled = '';
    248. 

  248. 						$i = 0;
    249. 

  249. 						foreach($ExtraFunctions as $ExtraFunction) {
    250. 

  250. 							if($i == 0) $VariableName	= $this->VariableTrueForm(trim($Tag['VariableName']));
    251. 

  251. 							else $VariableName = $PhpCompiled;
    252. 

  252. 							$Tag['ExtraFunction'] = $ExtraFunction;
    253. 

  253. 							//Check Static Class method
    254. 

  254. 							if(strpos($Tag['ExtraFunction'], '::') != NULL)
    255. 

  255. 								$Tag['ExtraFunction'] = str_replace('::', '@@StaticClassMethodSignal@@', $Tag['ExtraFunction']);
    256. 

  256. 							if(strpos($Tag['ExtraFunction'], ':') != NULL) {
    257. 

  257. 								$_f = explode(':', $Tag['ExtraFunction']);
    258. 

  258. 								$Tag['FunctionName']	= $_f[0];
    259. 

  259. 								$Tag['FunctionParams']	= $_f[1];
    260. 

  260. 							}
    261. 

  261. 							else $Tag['FunctionName'] = $Tag['ExtraFunction'];
    262. 

  262. 

  263. 							$Tag['FunctionName'] = str_replace('@@StaticClassMethodSignal@@', '::', $Tag['FunctionName']);
    264. 

  264. 							$FunctionName	= trim($Tag['FunctionName']);
    265. 

  265. 

  266. 							$ExtraParams	= $Tag['FunctionParams'];
    267. 

  267. 							$PhpCompiled	= (!empty($ExtraParams) ? "$FunctionName($VariableName,$ExtraParams)" : "$FunctionName($VariableName)");
    268. 

  268. 							$i++;
    269. 

  269. 						}
    270. 

  270. 						$PhpCompiled = ($echo ? 'echo ' : NULL) . $PhpCompiled;
    271. 

  271. 						$PhpCompiled = '<?php ' . $PhpCompiled . ' ?>';
    272. 

  272. 						$Code = str_replace($Tag['key'], $PhpCompiled, $Code);
    273. 

  273. 					}
    274. 

  274. 				}
    275. 

  275. 			}
    276. 

  276. 

  277. 		}
    278. 

  278. 		return $Code;
    279. 

  279. 	}
    280. 

  280. 

  281. 	private function CompileVariable($Code, $echo = true) {
    282. 

  282. 		if(preg_match_all('/\{\$(' . $this->VarElement . ')\}/', $Code, $matches)) {
    283. 

  283. 			$n = count($matches[0]);
    284. 

  284. 			$Parsed = array();
    285. 

  285. 			for($i = 0; $i < $n; $i++ )
    286. 

  286. 				$Parsed[$matches[0][$i]] = array('Var' => $matches[1][$i],'ExtraVar'=>$matches[2][$i]);
    287. 

  287. 			foreach($Parsed as $Key => $Value) {
    288. 

  288. 				$IsInitializeVar = false;
    289. 

  289. 				$VarKey = '';
    290. 

  290. 				if(preg_match_all('/\{(\$' . $this->VarElement . ')((?:\+\+|\-\-|\+=|\-=|\*=|=)([^=].*))\}/', $Key, $m)) {
    291. 

  291. 					$VarKey = trim($m[1][0]);
    292. 

  292. 					$IsInitializeVar = true;
    293. 

  293. 				}
    294. 

  294. 				if($IsInitializeVar) {
    295. 

  295. 					$PhpCompiled = '<?php ' . $this->VariableTrueForm($VarKey) . $Value['ExtraVar'] . ' ?>';
    296. 

  296. 				}
    297. 

  297. 				elseif($echo) {
    298. 

  298. 					$PhpCompiled = '<?php ' . ($echo ? 'echo ' : NULL) . $this->VariableTrueForm('$' . $Value['Var']) . ' ?>';
    299. 

  299. 				}
    300. 

  300. 				else
    301. 

  301. 					$PhpCompiled = $this->VariableTrueForm('$' . $Value['Var']);
    302. 

  302. 				$Code = str_replace($Key, $PhpCompiled, $Code);
    303. 

  303. 			}
    304. 

  304. 		}
    305. 

  305. 		return $Code;
    306. 

  306. 	}
    307. 

  307. 

  308. 	private function CompileConstant($Code, $echo = true) {
    309. 

  309. 		if(preg_match_all('/\{\#(' . $this->VarElement . ')\}/', $Code, $matches)) {
    310. 

  310. 			$n = count($matches[0]);
    311. 

  311. 			$Parsed = array();
    312. 

  312. 			for($i = 0; $i < $n; $i++ )
    313. 

  313. 				$Parsed[$matches[0][$i]] = array('Var' => $matches[1][$i],'ExtraVar'=>$matches[2][$i]);
    314. 

  314. 			foreach($Parsed as $Key => $Value) {
    315. 

  315. 				$IsInitializeVar = false;
    316. 

  316. 				$VarKey = '';
    317. 

  317. 				if($echo) {
    318. 

  318. 					$PhpCompiled = '<?php ' . ($echo ? 'echo ' : NULL) . $Value['Var'] . ' ?>';
    319. 

  319. 				}
    320. 

  320. 				else
    321. 

  321. 					$PhpCompiled = $Value['Var'];
    322. 

  322. 				$Code = str_replace($Key, $PhpCompiled, $Code);
    323. 

  323. 			}
    324. 

  324. 		}
    325. 

  325. 		return $Code;
    326. 

  326. 	}
    327. 

  327. 

  328. 	private function CompileCondition($Code, $echo = false) {
    329. 

  329. 		if(preg_match_all('/\$(' . $this->VarElement . ')/', $Code, $matches)) {
    330. 

  330. 			$n = count($matches[0]);
    331. 

  331. 			$Parsed = array();
    332. 

  332. 			for($i = 0; $i < $n; $i++ )
    333. 

  333. 				$Parsed[$matches[0][$i]] = array('Var' => $matches[1][$i],'ExtraVar'=>$matches[2][$i]);
    334. 

  334. 			foreach($Parsed as $Key => $Value) {
    335. 

  335. 				if($echo)
    336. 

  336. 					$PhpCompiled = '<?php ' . ($echo ? 'echo ' : NULL) . $this->VariableTrueForm('$' . $Value['Var']) . ' ?>';
    337. 

  337. 				else
    338. 

  338. 					$PhpCompiled = $this->VariableTrueForm('$' . $Value['Var']);
    339. 

  339. 				$Code = str_replace($Key, $PhpCompiled, $Code);
    340. 

  340. 			}
    341. 

  341. 		}
    342. 

  342. 		return $Code;
    343. 

  343. 	}
    344. 

  344. 

  345. 	private function CompileTPL() {
    346. 

  346. 		$TPLCodes = $this->DetectCodeTag();
    347. 

  347. 		$CompiledCode = array();
    348. 

  348. 		$IfOpen = $ForOpen = $WhileOpen = $CommentOpen = $SkipOpen = 0;
    349. 

  349. 		$CheckCommand['if'] = '/\\' . $this->Tag['left'] . 'if\s*\(\s*(.*)\s*\)\s*\\' . $this->Tag['right'] . '/';
    350. 

  350. 		$CheckCommand['elseif'] = '/\\' . $this->Tag['left'] . 'elseif(?: condition){0,1}\s*\(\s*(.*)\s*\)\s*\\' . $this->Tag['right'] . '/';
    351. 

  351. 		$CheckCommand['for'] = '/\\' . $this->Tag['left'] . 'for\s+\$(?P<ArrayElement>' . $this->VarElement . ')\s+in\s+\$(?P<Array>' . $this->VarElement . ')\s*(?: as\s+\$(?P<ArrayKey>' . $this->VarElement . '))?\\' . $this->Tag['right'] . '/';
    352. 

  352. 		$CheckCommand['while'] = '/\\' . $this->Tag['left'] . 'while\s*\(\s*(.*)\s*\)\s*\\' . $this->Tag['right'] . '/';
    353. 

  353. 

  354. 		$CheckCommand['block'] = '/\\' . $this->Tag['left'] . '\{block\:\:([^0-9][a-zA-Z0-9\_]+)\s*\:{0,1}([a-zA-Z0-9\,\s]*)\}\\' . $this->Tag['right'] . '/';
    355. 

  355. 

  356. 		$CheckCommand['area'] = '/\[\@([^0-9][a-zA-Z0-9\_]*)\@\]/';
    357. 

  357. 

  358. 		$CheckCommand['lang'] = '/\\' . $this->Tag['left'] . '\{lang\s*\:\:\s*([a-zA-Z0-9\_\-\s]+)\s*\:{0,1}(.*)\}\\' . $this->Tag['right'] . '/';
    359. 

  359. 

  360. 		while($Html = array_shift($TPLCodes)) {
    361. 

  361. 			// Remove all comment tag
    362. 

  362. 			if($Html == '{**/}') {
    363. 

  363. 				if($CommentOpen < 1) continue;
    364. 

  364. 				else $CommentOpen--;
    365. 

  365. 			}
    366. 

  366. 			elseif($Html == '{/**}') {
    367. 

  367. 				$CommentOpen++;
    368. 

  368. 			}
    369. 

  369. 			elseif($CommentOpen > 0 ) continue;
    370. 

  370. 

  371. 			// Skip all betwen Skip tag
    372. 

  372. 			elseif($Html == '{skip}') {
    373. 

  373. 				$SkipOpen++;
    374. 

  374. 				if($SkipOpen == 1) continue;
    375. 

  375. 				else $CompiledCode[] = $Html;
    376. 

  376. 			}
    377. 

  377. 			elseif($Html == '{/skip}') {
    378. 

  378. 				if($SkipOpen == 1) {
    379. 

  379. 					$SkipOpen = 0;
    380. 

  380. 					continue;
    381. 

  381. 				}
    382. 

  382. 				else {
    383. 

  383. 					$SkipOpen--;
    384. 

  384. 					$CompiledCode[] = $Html;
    385. 

  385. 				}
    386. 

  386. 			}
    387. 

  387. 			elseif($SkipOpen > 0) $CompiledCode[] = $Html;
    388. 

  388. 

  389. 			// Compile If command
    390. 

  390. 			elseif(preg_match($CheckCommand['if'], $Html, $Code)) {
    391. 

  391. 				$IfOpen++;
    392. 

  392. 				$IfCondition = $Code[1];
    393. 

  393. 				$parsed_condition = $this->CompileCondition($IfCondition, false);
    394. 

  394. 				$CompiledCode[] =   "<?php if($parsed_condition) { ?>";
    395. 

  395. 			}
    396. 

  396. 			//elseif
    397. 

  397. 			elseif( preg_match($CheckCommand['elseif'], $Html, $Code ) ){
    398. 

  398. 				$tag = $Code[0];
    399. 

  399. 				$condition = $Code[1];
    400. 

  400. 				$parsed_condition = $this->CompileCondition($condition, false);
    401. 

  401. 				$CompiledCode[] =   "<?php } elseif($parsed_condition) { ?>";
    402. 

  402. 			}
    403. 

  403. 			//else
    404. 

  404. 			elseif( strpos( $Html, '{else}' ) !== FALSE )
    405. 

  405. 				$CompiledCode[] =   '<?php }else{ ?>';
    406. 

  406. 			//close if tag
    407. 

  407. 			elseif( strpos( $Html, '{/if}' ) !== FALSE ) {
    408. 

  408. 				$IfOpen--;
    409. 

  409. 				$CompiledCode[] =   '<?php } ?>';
    410. 

  410. 			}
    411. 

  411. 			// Compile For command
    412. 

  412. 			elseif(preg_match($CheckCommand['for'], $Html, $Code)) {
    413. 

  413. 				$ForOpen++;
    414. 

  414. 				$Array = $this->VariableTrueForm('$' . $Code['Array']);
    415. 

  415. 				$ArrayElement = $this->VariableTrueForm('$' . $Code['ArrayElement']);
    416. 

  416. 				if(isset($Code['ArrayKey'])) {
    417. 

  417. 					$ArrayKey = $this->VariableTrueForm('$' . $Code['ArrayKey']);
    418. 

  418. 					$CompiledCode[] = "<?php foreach($Array as $ArrayKey => $ArrayElement) { ?>";
    419. 

  419. 				}
    420. 

  420. 				else
    421. 

  421. 					$CompiledCode[] = "<?php foreach($Array as $ArrayElement) { ?>";
    422. 

  422. 			}
    423. 

  423. 			//close For tag
    424. 

  424. 			elseif( strpos( $Html, '{/for}' ) !== FALSE ) {
    425. 

  425. 				$ForOpen--;
    426. 

  426. 				$CompiledCode[] =   '<?php } ?>';
    427. 

  427. 			}
    428. 

  428. 			// Compile While command
    429. 

  429. 			elseif(preg_match($CheckCommand['while'], $Html, $Code)) {
    430. 

  430. 				$WhileOpen++;
    431. 

  431. 				$While = $Code[1];
    432. 

  432. 				$parsed_while = $this->CompileCondition($While, false);
    433. 

  433. 				$CompiledCode[] =   "<?php while($parsed_while) { ?>";
    434. 

  434. 			}
    435. 

  435. 			//close For tag
    436. 

  436. 			elseif( strpos( $Html, '{/while}' ) !== FALSE ) {
    437. 

  437. 				$WhileOpen--;
    438. 

  438. 				$CompiledCode[] =   '<?php } ?>';
    439. 

  439. 			}
    440. 

  440. 			// Compile function
    441. 

  441. 			elseif($Html == '{function}') {
    442. 

  442. 				$CompiledCode[] = '<?php ';
    443. 

  443. 			}
    444. 

  444. 			elseif($Html == '{/function}') {
    445. 

  445. 				$CompiledCode[] = ' ?>';
    446. 

  446. 			}
    447. 

  447. 			elseif($Html == '{do}') {
    448. 

  448. 				$CompiledCode[] = '<?php ';
    449. 

  449. 			}
    450. 

  450. 			elseif($Html == '{/do}') {
    451. 

  451. 				$CompiledCode[] = ' ?>';
    452. 

  452. 			}
    453. 

  453. 			// Compile block command
    454. 

  454. 			elseif(preg_match($CheckCommand['block'], $Html, $Code)) {
    455. 

  455. 				$CompiledCode[] =   "<?php echo Theme::useBlock('" . $Code[1] . ":" . $Code[2] . "') ?>";
    456. 

  456. 			}
    457. 

  457. 			// Compile area command
    458. 

  458. 			elseif(preg_match($CheckCommand['area'], $Html, $Code)) {
    459. 

  459. 				$CompiledCode[] =   "<?php echo Theme::getArea('" . $Code[1] . "') ?>";
    460. 

  460. 			}
    461. 

  461. 			// Compile lang command
    462. 

  462. 			elseif(preg_match($CheckCommand['lang'], $Html, $Code)) {
    463. 

  463. 				//n($Code);
    464. 

  464. 				$Code[2] = trim($Code[2], ',');
    465. 

  465. 				$Code[2] = $this->CompileCondition($Code[2], false);
    466. 

  466. 				if($Code[2] != '')
    467. 

  467. 					$CompiledCode[] =   "<?php echo Lang::get_string('" . $Code[1] . "', " . $Code[2] . ") ?>";
    468. 

  468. 				else
    469. 

  469. 					$CompiledCode[] =   "<?php echo Lang::get_string('" . $Code[1] . "') ?>";
    470. 

  470. 			}
    471. 

  471. 			else {
    472. 

  472. 				$Html = $this->CompileFunction($Html, true);
    473. 

  473. 				$Html = $this->CompileConstant($Html, true);
    474. 

  474. 				$CompiledCode[] = $this->CompileVariable($Html, true);
    475. 

  475. 			}
    476. 

  476. 

  477. 			//else $CompiledCode[] = '<font color="red">' . $Html . '</font>';
    478. 

  478. 		}
    479. 

  479. 		//die();
    480. 

  480. 		file_put_contents($this->CompiledFilePath, $CompiledCode);
    481. 

  481. 	}
    482. 

  482. 

  483. 	static function MergeCompiledFile($CompiledData,$MergedFileName) {
    484. 

  484. 		$MergedContent = array();
    485. 

  485. 		foreach($CompiledData as $D) {
    486. 

  486. 			$_Var = var_export($D['var'], true);
    487. 

  487. 			$_Content = $D['content'];
    488. 

  488. 			$MergedContent[] = '<?php $_Var = ' . $_Var . '; extract($_Var); ?>' . $_Content;
    489. 

  489. 		}
    490. 

  490. 		file_put_contents(VTE::$MergedDir . $MergedFileName, implode(PHP_EOL, $MergedContent));
    491. 

  491. 	}
    492. 

  492. 

  493. 	static function DeleteMergedFiles($Path = '') {
    494. 

  494. 		if($Path == '') $Path = VTE::$MergedDir;
    495. 

  495. 		$ListFiles = glob($Path . '*');
    496. 

  496. 		foreach($ListFiles as $File)
    497. 

  497. 			if(is_file($File)) unlink($File);
    498. 

  498. 

  499. 		/*
    500. 

  500. 		foreach (new DirectoryIterator($Path) as $fileInfo) {
    501. 

  501. 			if(!$fileInfo->isDot()) {
    502. 

  502. 				unlink($fileInfo->getPathname());
    503. 

  503. 				//unlink($Path . $fileInfo->getPathname());
    504. 

  504. 			}
    505. 

  505. 		}
    506. 

  506. 		*/
    507. 

  507. 	}
    508. 

  508. 	static function DeleteCompiledFiles($Path = '') {
    509. 

  509. 		if($Path == '') $Path = VTE::$CompiledDir;
    510. 

  510. 		$ListFiles = glob($Path . '*');
    511. 

  511. 		foreach($ListFiles as $File)
    512. 

  512. 			if(is_file($File)) unlink($File);
    513. 

  513. 	}
    514. 

  514. 	static function DeleteCachedFiles($Path = '') {
    515. 

  515. 		if($Path == '') $Path = VTE::$CacheDir;
    516. 

  516. 		$ListFiles = glob($Path . '*');
    517. 

  517. 		foreach($ListFiles as $File)
    518. 

  518. 			if(is_file($File)) unlink($File);
    519. 

  519. 	}
    520. 

  520. }
    521. 

  521. 

  522. class MergedTPL
    523. 

  523. {
    524. 

  524. 	private	$MergedFileList = array();
    525. 

  525. 	private	$MergedData = array();
    526. 

  526. 	private $TotalFile = 0;
    527. 

  527. 	private $CurrentFile = 0;
    528. 

  528. 

  529. 	static	$TPLFileDir = '/';
    530. 

  530. 	static	$CacheDir = '/';
    531. 

  531. 	static	$MergedDir = '/';
    532. 

  532. 	private $TPLFileExt = '.tpl';
    533. 

  533. 

  534. 	private function Init() {
    535. 

  535. 		MergedTPL::$TPLFileDir	= VTE::$TPLFileDir;
    536. 

  536. 		MergedTPL::$CacheDir	= VTE::$CacheDir;
    537. 

  537. 		MergedTPL::$MergedDir	= VTE::$MergedDir;
    538. 

  538. 	}
    539. 

  539. 	public function Merge($TPLFileList) {
    540. 

  540. 		$this->Init();
    541. 

  541. 		$this->TotalFile = count($TPLFileList);
    542. 

  542. 		$this->MergedFileList = $TPLFileList;
    543. 

  543. 		return $this;
    544. 

  544. 	}
    545. 

  545. 	public function SavePath($Path = '') {
    546. 

  546. 		if($Path != '') MergedTPL::$MergedDir = $Path;
    547. 

  547. 		return $this;
    548. 

  548. 	}
    549. 

  549. 	public function AddFile($TPLFileName, $Vars = array(), $TPLFileDir = '') {
    550. 

  550. 		$this->CurrentFile++;
    551. 

  551. 		$TPLFileDir = ($TPLFileDir == '') ? MergedTPL::$TPLFileDir : $TPLFileDir;
    552. 

  552. 		//$TPLFileName = rtrim($TPLFileName, '.tpl');
    553. 

  553. 		$this->MergedData[$this->CurrentFile] = array('file' => $TPLFileName, 'dir' => $TPLFileDir, 'var' . $this->CurrentFile => $Vars);
    554. 

  554. 		return $this;
    555. 

  555. 	}
    556. 

  556. 	public function OutputMerged($Return = false, $ReCompiled = false) {
    557. 

  557. 		$MergedVars = array();
    558. 

  558. 		$FileName = implode('_', $this->MergedFileList);
    559. 

  559. 		$MergedFilePath = MergedTPL::$MergedDir . $FileName . '_' . md5($FileName) . '.php';
    560. 

  560. 

  561. 		$DetectTPLChanged = 0;
    562. 

  562. 		$MergedFileTime = filemtime($MergedFilePath);
    563. 

  563. 		foreach($this->MergedData as $i => $Data) {
    564. 

  564. 			$MergedVars['var' . $i] = $Data['var' . $i];
    565. 

  565. 			$_TPLFile = $Data['dir'] .  $Data['file'] . $this->TPLFileExt;
    566. 

  566. 			if(filemtime($_TPLFile) > $MergedFileTime)
    567. 

  567. 				$DetectTPLChanged++;
    568. 

  568. 		}
    569. 

  569. 

  570. 		if(file_exists($MergedFilePath) && !$ReCompiled && $DetectTPLChanged == 0) {
    571. 

  571. 

  572. 		}
    573. 

  573. 		else {
    574. 

  574. 			$MergedContent = '';
    575. 

  575. 			foreach($this->MergedData as $i => $Data) {
    576. 

  576. 				$MergedVars['var' . $i] = $Data['var' . $i];
    577. 

  577. 				$MergedContent .= '<?php extract($MergedVars[\'var' . $i . '\']); ?>';
    578. 

  578. 				$_CompiledFile = TPL::File($Data['file'], true)
    579. 

  579. 										->SetDir('TPLFileDir', $Data['dir'])
    580. 

  580. 										//->Assign('var' . $i, $Data['var' . $i])
    581. 

  581. 										->Output(false, true);
    582. 

  582. 				$MergedContent .= $_CompiledFile['content'];
    583. 

  583. 			}
    584. 

  584. 			file_put_contents($MergedFilePath, '<?php if(!class_exists(\'MergedTPL\')) die(\'Invalid action!\') ?>' . $MergedContent);
    585. 

  585. 		}
    586. 

  586. 		if($Return) {
    587. 

  587. 			ob_start();
    588. 

  588. 			include $MergedFilePath;
    589. 

  589. 			$OutputContent = ob_get_clean();
    590. 

  590. 			return array('var' => $MergedVars, 'content' => $OutputContent);
    591. 

  591. 		}
    592. 

  592. 		else include $MergedFilePath;
    593. 

  593. 	}
    594. 

  594. }
    595. 

  595. 

  596. ?>
    597.