last update: Mon, 05 Sep 2011 17:16:55 +0000
  1. <?
  3. function escape_string($s)
  4. {
  5. return str_replace('"', '\"', $s);
  6. }
  8. function unescape_string($s)
  9. {
  10. $r = $s;
  11. $r = str_replace('<', '<', $r);
  12. $r = str_replace('>', '>', $r);
  13. $r = str_replace('&', '&', $r);
  14. $r = str_replace('<', '<', $r);
  15. $r = str_replace('>', '>', $r);
  18. $r = str_replace('\\"', '"', $r);
  19. $r = str_replace("\\'", "'", $r);
  20. $r = str_replace('\\\\', '\\', $r);
  22. //$r = str_replace('\\"', '\\"', $r);
  24. return $r;
  25. }
  27. function fill_line_array($s)
  28. {
  29. return explode("\n",$s);
  30. }
  32. class linearraycomparer
  33. {
  34. var $L;
  35. var $A;
  36. var $B;
  37. var $diff;
  38. function linearraycomparer($A, $B)
  39. {
  40. $this->A = $A;
  41. $this->B = $B;
  42. }
  44. function lcs_length()
  45. {
  46. $L = $this->lcs_tree();
  47. if (isset($L[0][0]))
  48. return $L[0][0];
  49. else
  50. return 0;
  51. }
  53. function string_match_percent()
  54. {
  55. $A = $this->A;
  56. $B = $this->B;
  57. $n = max(sizeof($A),sizeof($B));
  58. if ($n > 0)
  59. return $this->lcs_length($A,$B) / $n;
  60. else
  61. return 1;
  62. }
  64. function remove_space($text)
  65. {
  66. $r = str_replace(" ","",$text);
  67. $r = str_replace(" ","",$r);
  68. return $r;
  69. }
  71. function lcs_tree()
  72. {
  73. if ($this->L)
  74. {
  75. return $this->L;
  76. }
  77. else
  78. {
  79. $A = $this->A;
  80. $B = $this->B;
  81. $L = array();
  82. for ($i = sizeof($A)-1; $i >= 0; $i--)
  83. {
  84. for ($j = sizeof($B)-1; $j >= 0; $j--)
  85. {
  86. if (!$A[$i] || !$B[$j])
  87. {
  88. $L[$i][$j] = 0;
  89. }
  90. elseif ($this->remove_space($A[$i]) == $this->remove_space($B[$j]))
  91. {
  92. if (!isset($L[$i+1][$j+1])) $L[$i+1][$j+1] = 0;
  93. $L[$i][$j] = 1 + $L[$i+1][$j+1];
  94. }
  95. else
  96. {
  97. if (!isset($L[$i+1][$j])) $L[$i+1][$j] = 0;
  98. if (!isset($L[$i][$j+1])) $L[$i][$j+1] = 0;
  99. $L[$i][$j] = max($L[$i+1][$j], $L[$i][$j+1]);
  100. }
  101. //echo "$i, $j = ".$L[$i][$j]."<br />";
  102. }
  103. }
  104. $this->L = $L;
  105. return $L;
  106. }
  107. }
  109. function get_string_difference()
  110. {
  111. if ($this->diff)
  112. {
  113. return $this->diff;
  114. }
  115. else
  116. {
  117. $A = $this->A;
  118. $B = $this->B;
  119. $L = $this->lcs_tree();
  120. $i = 0;
  121. $j = 0;
  122. $result = array();
  123. $result[0][0] = 0;
  124. $result[1][0] = 0;
  125. while ($i < sizeof($A) && $j < sizeof($B))
  126. {
  127. if ($this->remove_space($A[$i])==$this->remove_space($B[$j]))
  128. {
  129. $result[0][$i] = 1;
  130. $result[1][$j] = 1;
  131. $i++; $j++;
  132. }
  133. else
  134. {
  135. $result[0][$i] = 0;
  136. $result[1][$j] = 0;
  138. if (!isset($L[$i+1][$j])) $L[$i+1][$j] = 0;
  139. if (!isset($L[$i][$j+1])) $L[$i][$j+1] = 0;
  141. if ($L[$i+1][$j] >= $L[$i][$j+1]) $i++;
  142. else $j++;
  143. }
  144. }
  145. $this->diff = $result;
  146. return $result;
  147. }
  148. }
  150. function make_same_lines_same_height($whichtext)
  151. {
  152. $A = $this->A;
  153. $B = $this->B;
  154. if ($whichtext)
  155. {
  156. $A = $this->B;
  157. $B = $this->A;
  158. }
  159. $diff = $this->get_string_difference();
  160. $diff0 = $diff[$whichtext];
  161. $diff1 = $diff[1-$whichtext];
  163. $result = array();
  164. $j=0;
  165. $i=0;
  166. while ($i < sizeof($A)) //&& ($j < sizeof($B)))
  167. {
  169. if (!isset($diff0[$i])) $diff0[$i] = 0;
  170. if (!isset($diff1[$j])) $diff1[$j] = 1;
  174. if ($diff1[$j] == 0)
  175. {
  176. if ($diff0[$i] == 0)
  177. {
  178. $result [] = $A[$i];
  179. //$j++;
  180. $i++;
  181. }
  182. else
  183. {
  184. $result [] = "////////////////";
  185. $j++;
  186. }
  187. }
  188. else
  189. {
  190. if ($diff0[$i] == 0)
  191. {
  192. //$result [] = "C#".$debug."";
  193. $result [] = $A[$i];
  194. //$j++;
  195. $i++;
  196. }
  197. else
  198. {
  199. $result [] = $A[$i];
  200. $j++;
  201. $i++;
  202. }
  203. }
  204. }
  206. return $result;
  207. }
  208. }
  210. class linecomparer
  211. {
  212. var $L;
  213. var $A;
  214. var $B;
  215. var $diff;
  216. function linecomparer($A, $B)
  217. {
  218. $this->A = $A;
  219. $this->B = $B;
  220. }
  222. function lcs_length()
  223. {
  224. $L = $this->lcs_tree();
  225. if (isset($L[0][0]))
  226. return $L[0][0];
  227. else
  228. return 0;
  229. }
  231. function string_match_percent()
  232. {
  233. $A = $this->A;
  234. $B = $this->B;
  235. $n = max(strlen($A),strlen($B));
  236. if ($n > 0)
  237. return $this->lcs_length($A,$B) / $n;
  238. else
  239. return 1;
  240. }
  242. function lcs_tree()
  243. {
  244. if ($this->L)
  245. {
  246. return $this->L;
  247. }
  248. else
  249. {
  250. $A = $this->A;
  251. $B = $this->B;
  252. $L = array();
  253. for ($i = strlen($A)-1; $i >= 0; $i--)
  254. {
  255. for ($j = strlen($B)-1; $j >= 0; $j--)
  256. {
  257. if (!$A[$i] || !$B[$j])
  258. {
  259. $L[$i][$j] = 0;
  260. }
  261. elseif ($A[$i] == $B[$j])
  262. {
  263. if (!isset($L[$i+1][$j+1])) $L[$i+1][$j+1] = 0;
  264. $L[$i][$j] = 1 + $L[$i+1][$j+1];
  265. }
  266. else
  267. {
  268. if (!isset($L[$i+1][$j])) $L[$i+1][$j] = 0;
  269. if (!isset($L[$i][$j+1])) $L[$i][$j+1] = 0;
  270. $L[$i][$j] = max($L[$i+1][$j], $L[$i][$j+1]);
  271. }
  272. //echo "$i, $j = ".$L[$i][$j]."<br />";
  273. }
  274. }
  275. $this->L = $L;
  276. return $L;
  277. }
  278. }
  281. function get_lcs()
  282. {
  283. $A = $this->A;
  284. $B = $this->B;
  285. $L = $this->lcs_tree();
  286. $i = 0;
  287. $j = 0;
  288. $result = "";
  289. while ($i < strlen($A) && $j < strlen($B))
  290. {
  291. if ($A[$i]==$B[$j])
  292. {
  293. $result.=$A[$i]; //add A[i] to end of S;
  294. $i++; $j++;
  295. }
  296. else
  297. {
  298. if ($L[$i+1][$j] >= $L[$i][$j+1]) $i++;
  299. else $j++;
  300. }
  301. }
  302. return $result;
  303. }
  306. function get_string_difference()
  307. {
  308. if ($this->diff)
  309. {
  310. return $this->diff;
  311. }
  312. else
  313. {
  314. $A = $this->A;
  315. $B = $this->B;
  316. $L = $this->lcs_tree();
  317. $i = 0;
  318. $j = 0;
  319. $result = array();
  320. $result[0][0] = 0;
  321. $result[1][0] = 0;
  322. while ($i < strlen($A) && $j < strlen($B))
  323. {
  324. if ($A[$i]==$B[$j])
  325. {
  326. $result[0][$i] = 1;
  327. $result[1][$j] = 1;
  328. $i++; $j++;
  329. }
  330. else
  331. {
  332. $result[0][$i] = 0;
  333. $result[1][$j] = 0;
  334. if (!isset($L[$i+1][$j])) $L[$i+1][$j] = 0;
  335. if (!isset($L[$i][$j+1])) $L[$i][$j+1] = 0;
  337. if ($L[$i+1][$j] >= $L[$i][$j+1]) $i++;
  338. else $j++;
  339. }
  340. }
  341. $this->diff = $result;
  342. return $result;
  343. }
  344. }
  346. function markup_string_difference($whichstring,$start="<font color=\"red\">",$end="</font>")
  347. {
  348. $A = $this->A;
  349. if ($whichstring)
  350. {
  351. $A = $this->B;
  352. }
  353. $diff = $this->get_string_difference();
  354. $diff = $diff[$whichstring];
  356. $result = "";
  357. $d = 1;
  358. for ($i=0; $i < strlen($A); ++$i)
  359. {
  360. if (!isset($diff[$i])) $diff[$i] = 0;
  361. if ($diff[$i] != $d)
  362. {
  363. if ($d == 1)
  364. {
  365. $result.=$start;
  366. }
  367. else
  368. {
  369. $result.=$end;
  370. }
  371. $d = 1 - $d;
  372. }
  373. $result.=$A[$i];
  375. }
  376. if ($d == 0)
  377. {
  378. $result.=$end;
  379. }
  380. return $result;
  381. }
  382. } //end of class linecomparer
  387. ?>

goto line:
Compare with:
text copy window edit this code post new code