PageRenderTime 42ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 0ms

/PhPVersion/application/third_party/Smarty/sysplugins/smarty_internal_parsetree.php

https://gitlab.com/garabedian.kevin/web2TB
PHP | 393 lines | 182 code | 34 blank | 177 comment | 43 complexity | 636379d484ec68882b9a6142a5d259af MD5 | raw file
  1. <?php
  2. /**
  3. * Smarty Internal Plugin Templateparser Parsetrees
  4. *
  5. * These are classes to build parsetrees in the template parser
  6. *
  7. * @package Smarty
  8. * @subpackage Compiler
  9. * @author Thue Kristensen
  10. * @author Uwe Tews
  11. */
  12. /**
  13. * @package Smarty
  14. * @subpackage Compiler
  15. * @ignore
  16. */
  17. abstract class _smarty_parsetree
  18. {
  19. /**
  20. * Parser object
  21. * @var object
  22. */
  23. public $parser;
  24. /**
  25. * Buffer content
  26. * @var mixed
  27. */
  28. public $data;
  29. /**
  30. * Return buffer
  31. *
  32. * @return string buffer content
  33. */
  34. abstract public function to_smarty_php();
  35. }
  36. /**
  37. * A complete smarty tag.
  38. *
  39. * @package Smarty
  40. * @subpackage Compiler
  41. * @ignore
  42. */
  43. class _smarty_tag extends _smarty_parsetree
  44. {
  45. /**
  46. * Saved block nesting level
  47. * @var int
  48. */
  49. public $saved_block_nesting;
  50. /**
  51. * Create parse tree buffer for Smarty tag
  52. *
  53. * @param object $parser parser object
  54. * @param string $data content
  55. */
  56. public function __construct($parser, $data)
  57. {
  58. $this->parser = $parser;
  59. $this->data = $data;
  60. $this->saved_block_nesting = $parser->block_nesting_level;
  61. }
  62. /**
  63. * Return buffer content
  64. *
  65. * @return string content
  66. */
  67. public function to_smarty_php()
  68. {
  69. return $this->data;
  70. }
  71. /**
  72. * Return complied code that loads the evaluated outout of buffer content into a temporary variable
  73. *
  74. * @return string template code
  75. */
  76. public function assign_to_var()
  77. {
  78. $var = sprintf('$_tmp%d', ++Smarty_Internal_Templateparser::$prefix_number);
  79. $this->parser->compiler->prefix_code[] = sprintf('<?php ob_start();?>%s<?php %s=ob_get_clean();?>', $this->data, $var);
  80. return $var;
  81. }
  82. }
  83. /**
  84. * Code fragment inside a tag.
  85. *
  86. * @package Smarty
  87. * @subpackage Compiler
  88. * @ignore
  89. */
  90. class _smarty_code extends _smarty_parsetree
  91. {
  92. /**
  93. * Create parse tree buffer for code fragment
  94. *
  95. * @param object $parser parser object
  96. * @param string $data content
  97. */
  98. public function __construct($parser, $data)
  99. {
  100. $this->parser = $parser;
  101. $this->data = $data;
  102. }
  103. /**
  104. * Return buffer content in parentheses
  105. *
  106. * @return string content
  107. */
  108. public function to_smarty_php()
  109. {
  110. return sprintf("(%s)", $this->data);
  111. }
  112. }
  113. /**
  114. * Double quoted string inside a tag.
  115. *
  116. * @package Smarty
  117. * @subpackage Compiler
  118. * @ignore
  119. */
  120. class _smarty_doublequoted extends _smarty_parsetree
  121. {
  122. /**
  123. * Create parse tree buffer for double quoted string subtrees
  124. *
  125. * @param object $parser parser object
  126. * @param _smarty_parsetree $subtree parsetree buffer
  127. */
  128. public function __construct($parser, _smarty_parsetree $subtree)
  129. {
  130. $this->parser = $parser;
  131. $this->subtrees[] = $subtree;
  132. if ($subtree instanceof _smarty_tag) {
  133. $this->parser->block_nesting_level = count($this->parser->compiler->_tag_stack);
  134. }
  135. }
  136. /**
  137. * Append buffer to subtree
  138. *
  139. * @param _smarty_parsetree $subtree parsetree buffer
  140. */
  141. public function append_subtree(_smarty_parsetree $subtree)
  142. {
  143. $last_subtree = count($this->subtrees) - 1;
  144. if ($last_subtree >= 0 && $this->subtrees[$last_subtree] instanceof _smarty_tag && $this->subtrees[$last_subtree]->saved_block_nesting < $this->parser->block_nesting_level) {
  145. if ($subtree instanceof _smarty_code) {
  146. $this->subtrees[$last_subtree]->data .= '<?php echo ' . $subtree->data . ';?>';
  147. } elseif ($subtree instanceof _smarty_dq_content) {
  148. $this->subtrees[$last_subtree]->data .= '<?php echo "' . $subtree->data . '";?>';
  149. } else {
  150. $this->subtrees[$last_subtree]->data .= $subtree->data;
  151. }
  152. } else {
  153. $this->subtrees[] = $subtree;
  154. }
  155. if ($subtree instanceof _smarty_tag) {
  156. $this->parser->block_nesting_level = count($this->parser->compiler->_tag_stack);
  157. }
  158. }
  159. /**
  160. * Merge subtree buffer content together
  161. *
  162. * @return string compiled template code
  163. */
  164. public function to_smarty_php()
  165. {
  166. $code = '';
  167. foreach ($this->subtrees as $subtree) {
  168. if ($code !== "") {
  169. $code .= ".";
  170. }
  171. if ($subtree instanceof _smarty_tag) {
  172. $more_php = $subtree->assign_to_var();
  173. } else {
  174. $more_php = $subtree->to_smarty_php();
  175. }
  176. $code .= $more_php;
  177. if (!$subtree instanceof _smarty_dq_content) {
  178. $this->parser->compiler->has_variable_string = true;
  179. }
  180. }
  181. return $code;
  182. }
  183. }
  184. /**
  185. * Raw chars as part of a double quoted string.
  186. *
  187. * @package Smarty
  188. * @subpackage Compiler
  189. * @ignore
  190. */
  191. class _smarty_dq_content extends _smarty_parsetree
  192. {
  193. /**
  194. * Create parse tree buffer with string content
  195. *
  196. * @param object $parser parser object
  197. * @param string $data string section
  198. */
  199. public function __construct($parser, $data)
  200. {
  201. $this->parser = $parser;
  202. $this->data = $data;
  203. }
  204. /**
  205. * Return content as double quoted string
  206. *
  207. * @return string doubled quoted string
  208. */
  209. public function to_smarty_php()
  210. {
  211. return '"' . $this->data . '"';
  212. }
  213. }
  214. /**
  215. * Template element
  216. *
  217. * @package Smarty
  218. * @subpackage Compiler
  219. * @ignore
  220. */
  221. class _smarty_template_buffer extends _smarty_parsetree
  222. {
  223. /**
  224. * Array of template elements
  225. *
  226. * @var array
  227. */
  228. public $subtrees = Array();
  229. /**
  230. * Create root of parse tree for template elements
  231. *
  232. * @param object $parser parse object
  233. */
  234. public function __construct($parser)
  235. {
  236. $this->parser = $parser;
  237. }
  238. /**
  239. * Append buffer to subtree
  240. *
  241. * @param _smarty_parsetree $subtree
  242. */
  243. public function append_subtree(_smarty_parsetree $subtree)
  244. {
  245. $this->subtrees[] = $subtree;
  246. }
  247. /**
  248. * Sanitize and merge subtree buffers together
  249. *
  250. * @return string template code content
  251. */
  252. public function to_smarty_php()
  253. {
  254. $code = '';
  255. for ($key = 0, $cnt = count($this->subtrees); $key < $cnt; $key++) {
  256. if ($key + 2 < $cnt) {
  257. if ($this->subtrees[$key] instanceof _smarty_linebreak && $this->subtrees[$key + 1] instanceof _smarty_tag && $this->subtrees[$key + 1]->data == '' && $this->subtrees[$key + 2] instanceof _smarty_linebreak) {
  258. $key = $key + 1;
  259. continue;
  260. }
  261. if (substr($this->subtrees[$key]->data, -1) == '<' && $this->subtrees[$key + 1]->data == '' && substr($this->subtrees[$key + 2]->data, -1) == '?') {
  262. $key = $key + 2;
  263. continue;
  264. }
  265. }
  266. if (substr($code, -1) == '<') {
  267. $subtree = $this->subtrees[$key]->to_smarty_php();
  268. if (substr($subtree, 0, 1) == '?') {
  269. $code = substr($code, 0, strlen($code) - 1) . '<<?php ?>?' . substr($subtree, 1);
  270. } elseif ($this->parser->asp_tags && substr($subtree, 0, 1) == '%') {
  271. $code = substr($code, 0, strlen($code) - 1) . '<<?php ?>%' . substr($subtree, 1);
  272. } else {
  273. $code .= $subtree;
  274. }
  275. continue;
  276. }
  277. if ($this->parser->asp_tags && substr($code, -1) == '%') {
  278. $subtree = $this->subtrees[$key]->to_smarty_php();
  279. if (substr($subtree, 0, 1) == '>') {
  280. $code = substr($code, 0, strlen($code) - 1) . '%<?php ?>>' . substr($subtree, 1);
  281. } else {
  282. $code .= $subtree;
  283. }
  284. continue;
  285. }
  286. if (substr($code, -1) == '?') {
  287. $subtree = $this->subtrees[$key]->to_smarty_php();
  288. if (substr($subtree, 0, 1) == '>') {
  289. $code = substr($code, 0, strlen($code) - 1) . '?<?php ?>>' . substr($subtree, 1);
  290. } else {
  291. $code .= $subtree;
  292. }
  293. continue;
  294. }
  295. $code .= $this->subtrees[$key]->to_smarty_php();
  296. }
  297. return $code;
  298. }
  299. }
  300. /**
  301. * template text
  302. *
  303. * @package Smarty
  304. * @subpackage Compiler
  305. * @ignore
  306. */
  307. class _smarty_text extends _smarty_parsetree
  308. {
  309. /**
  310. * Create template text buffer
  311. *
  312. * @param object $parser parser object
  313. * @param string $data text
  314. */
  315. public function __construct($parser, $data)
  316. {
  317. $this->parser = $parser;
  318. $this->data = $data;
  319. }
  320. /**
  321. * Return buffer content
  322. *
  323. * @return strint text
  324. */
  325. public function to_smarty_php()
  326. {
  327. return $this->data;
  328. }
  329. }
  330. /**
  331. * template linebreaks
  332. *
  333. * @package Smarty
  334. * @subpackage Compiler
  335. * @ignore
  336. */
  337. class _smarty_linebreak extends _smarty_parsetree
  338. {
  339. /**
  340. * Create buffer with linebreak content
  341. *
  342. * @param object $parser parser object
  343. * @param string $data linebreak string
  344. */
  345. public function __construct($parser, $data)
  346. {
  347. $this->parser = $parser;
  348. $this->data = $data;
  349. }
  350. /**
  351. * Return linebrak
  352. *
  353. * @return string linebreak
  354. */
  355. public function to_smarty_php()
  356. {
  357. return $this->data;
  358. }
  359. }