3.0.7-PL1 won't install

[AdamR]

Please post the contents of your includes/diff/diff.php file.

- Adam

[edgar davids]

Code: Select all

<?php
/**
*
* @package diff
* @version $Id: diff.php 10168 2009-09-20 16:20:20Z acydburn $
* @copyright (c) 2006 phpBB Group
* @license http://opensource.org/licenses/gpl-license.php GNU Public License
*
*/

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

/**
* Code from pear.php.net, Text_Diff-1.0.0 package
* http://pear.php.net/package/Text_Diff/
*
* Modified by phpBB Group to meet our coding standards
* and being able to integrate into phpBB
*
* General API for generating and formatting diffs - the differences between
* two sequences of strings.
*
* Copyright 2004 Geoffrey T. Dairiki <[email protected]>
* Copyright 2004-2008 The Horde Project (http://www.horde.org/)
*
* @package diff
* @author  Geoffrey T. Dairiki <[email protected]>
*/
class diff
{
	/**
	* Array of changes.
	* @var array
	*/
	var $_edits;

	/**
	* Computes diffs between sequences of strings.
	*
	* @param array $from_lines  An array of strings. Typically these are lines from a file.
	* @param array $to_lines    An array of strings.
	*/
	function diff(&$from_content, &$to_content, $preserve_cr = true)
	{
		$diff_engine = new diff_engine();
		$this->_edits = $diff_engine->diff($from_content, $to_content, $preserve_cr);
	}

	/**
	* Returns the array of differences.
	*/
	function get_diff()
	{
		return $this->_edits;
	}

	/**
	* returns the number of new (added) lines in a given diff.
	*
	* @since Text_Diff 1.1.0
	*
	* @return integer The number of new lines
	*/
	function count_added_lines()
	{
		$count = 0;

		for ($i = 0, $size = sizeof($this->_edits); $i < $size; $i++)
		{
			$edit = $this->_edits[$i];

			if (is_a($edit, 'diff_op_add') || is_a($edit, 'diff_op_change'))
			{
				$count += $edit->nfinal();
			}
		}
		return $count;
	}

	/**
	* Returns the number of deleted (removed) lines in a given diff.
	*
	* @since Text_Diff 1.1.0
	*
	* @return integer The number of deleted lines
	*/
	function count_deleted_lines()
	{
		$count = 0;

		for ($i = 0, $size = sizeof($this->_edits); $i < $size; $i++)
		{
			$edit = $this->_edits[$i];

			if (is_a($edit, 'diff_op_delete') || is_a($edit, 'diff_op_change'))
			{
				$count += $edit->norig();
			}
		}
		return $count;
	}

	/**
	* Computes a reversed diff.
	*
	* Example:
	* <code>
	* $diff = new diff($lines1, $lines2);
	* $rev = $diff->reverse();
	* </code>
	*
	* @return diff  A Diff object representing the inverse of the original diff.
	*               Note that we purposely don't return a reference here, since
	*               this essentially is a clone() method.
	*/
	function reverse()
	{
		if (version_compare(zend_version(), '2', '>'))
		{
			$rev = clone($this);
		}
		else
		{
			$rev = $this;
		}

		$rev->_edits = array();

		for ($i = 0, $size = sizeof($this->_edits); $i < $size; $i++)
		{
			$edit = $this->_edits[$i];
			$rev->_edits[] = $edit->reverse();
		}

		return $rev;
	}

	/**
	* Checks for an empty diff.
	*
	* @return boolean  True if two sequences were identical.
	*/
	function is_empty()
	{
		for ($i = 0, $size = sizeof($this->_edits); $i < $size; $i++)
		{
			$edit = $this->_edits[$i];

			// skip diff_op_copy
			if (is_a($edit, 'diff_op_copy'))
			{
				continue;
			}

			if (is_a($edit, 'diff_op_delete') || is_a($edit, 'diff_op_add'))
			{
				$orig = $edit->orig;
				$final = $edit->final;

				// We can simplify one case where the array is usually supposed to be empty...
				if (sizeof($orig) == 1 && trim($orig[0]) === '') $orig = array();
				if (sizeof($final) == 1 && trim($final[0]) === '') $final = array();

				if (!$orig && !$final)
				{
					continue;
				}

				return false;
			}

			return false;
		}
		return true;
	}

	/**
	* Computes the length of the Longest Common Subsequence (LCS).
	*
	* This is mostly for diagnostic purposes.
	*
	* @return integer  The length of the LCS.
	*/
	function lcs()
	{
		$lcs = 0;

		for ($i = 0, $size = sizeof($this->_edits); $i < $size; $i++)
		{
			$edit = $this->_edits[$i];

			if (is_a($edit, 'diff_op_copy'))
			{
				$lcs += sizeof($edit->orig);
			}
		}
		return $lcs;
	}

	/**
	* Gets the original set of lines.
	*
	* This reconstructs the $from_lines parameter passed to the constructor.
	*
	* @return array  The original sequence of strings.
	*/
	function get_original()
	{
		$lines = array();

		for ($i = 0, $size = sizeof($this->_edits); $i < $size; $i++)
		{
			$edit = $this->_edits[$i];

			if ($edit->orig)
			{
				array_splice($lines, sizeof($lines), 0, $edit->orig);
			}
		}
		return $lines;
	}

	/**
	* Gets the final set of lines.
	*
	* This reconstructs the $to_lines parameter passed to the constructor.
	*
	* @return array  The sequence of strings.
	*/
	function get_final()
	{
		$lines = array();

		for ($i = 0, $size = sizeof($this->_edits); $i < $size; $i++)
		{
			$edit = $this->_edits[$i];

			if ($edit->final)
			{
				array_splice($lines, sizeof($lines), 0, $edit->final);
			}
		}
		return $lines;
	}

	/**
	* Removes trailing newlines from a line of text. This is meant to be used with array_walk().
	*
	* @param string &$line  The line to trim.
	* @param integer $key  The index of the line in the array. Not used.
	*/
	function trim_newlines(&$line, $key)
	{
		$line = str_replace(array("\n", "\r"), '', $line);
	}

	/**
	* Checks a diff for validity.
	*
	* This is here only for debugging purposes.
	*/
	function _check($from_lines, $to_lines)
	{
		if (serialize($from_lines) != serialize($this->get_original()))
		{
			trigger_error("[diff] Reconstructed original doesn't match", E_USER_ERROR);
		}

		if (serialize($to_lines) != serialize($this->get_final()))
		{
			trigger_error("[diff] Reconstructed final doesn't match", E_USER_ERROR);
		}

		$rev = $this->reverse();

		if (serialize($to_lines) != serialize($rev->get_original()))
		{
			trigger_error("[diff] Reversed original doesn't match", E_USER_ERROR);
		}

		if (serialize($from_lines) != serialize($rev->get_final()))
		{
			trigger_error("[diff] Reversed final doesn't match", E_USER_ERROR);
		}

		$prevtype = null;

		for ($i = 0, $size = sizeof($this->_edits); $i < $size; $i++)
		{
			$edit = $this->_edits[$i];

			if ($prevtype == get_class($edit))
			{
				trigger_error("[diff] Edit sequence is non-optimal", E_USER_ERROR);
			}
			$prevtype = get_class($edit);
		}

		return true;
	}
}

/**
* @package diff
* @author  Geoffrey T. Dairiki <[email protected]>
*/
class mapped_diff extends diff
{
	/**
	* Computes a diff between sequences of strings.
	*
	* This can be used to compute things like case-insensitve diffs, or diffs
	* which ignore changes in white-space.
	*
	* @param array $from_lines         An array of strings.
	* @param array $to_lines           An array of strings.
	* @param array $mapped_from_lines  This array should have the same size number of elements as $from_lines.
	*                                  The elements in $mapped_from_lines and $mapped_to_lines are what is actually
	*                                  compared when computing the diff.
	* @param array $mapped_to_lines    This array should have the same number of elements as $to_lines.
	*/
	function mapped_diff(&$from_lines, &$to_lines, &$mapped_from_lines, &$mapped_to_lines)
	{
		if (sizeof($from_lines) != sizeof($mapped_from_lines) || sizeof($to_lines) != sizeof($mapped_to_lines))
		{
			return false;
		}

		parent::diff($mapped_from_lines, $mapped_to_lines);

		$xi = $yi = 0;
		for ($i = 0; $i < sizeof($this->_edits); $i++)
		{
			$orig = &$this->_edits[$i]->orig;
			if (is_array($orig))
			{
				$orig = array_slice($from_lines, $xi, sizeof($orig));
				$xi += sizeof($orig);
			}

			$final = &$this->_edits[$i]->final;
			if (is_array($final))
			{
				$final = array_slice($to_lines, $yi, sizeof($final));
				$yi += sizeof($final);
			}
		}
	}
}

/**
* @package diff
* @author  Geoffrey T. Dairiki <[email protected]>
*
* @access private
*/
class diff_op
{
	var $orig;
	var $final;

	function &reverse()
	{
		trigger_error('[diff] Abstract method', E_USER_ERROR);
	}

	function norig()
	{
		return ($this->orig) ? sizeof($this->orig) : 0;
	}

	function nfinal()
	{
		return ($this->final) ? sizeof($this->final) : 0;
	}
}

/**
* @package diff
* @author  Geoffrey T. Dairiki <[email protected]>
*
* @access private
*/
class diff_op_copy extends diff_op
{
	function diff_op_copy($orig, $final = false)
	{
		if (!is_array($final))
		{
			$final = $orig;
		}
		$this->orig = $orig;
		$this->final = $final;
	}

	function &reverse()
	{
		$reverse = new diff_op_copy($this->final, $this->orig);
		return $reverse;
	}
}

/**
* @package diff
* @author  Geoffrey T. Dairiki <[email protected]>
*
* @access private
*/
class diff_op_delete extends diff_op
{
	function diff_op_delete($lines)
	{
		$this->orig = $lines;
		$this->final = false;
	}

	function &reverse()
	{
		$reverse = new diff_op_add($this->orig);
		return $reverse;
	}
}

/**
* @package diff
* @author  Geoffrey T. Dairiki <[email protected]>
*
* @access private
*/
class diff_op_add extends diff_op
{
	function diff_op_add($lines)
	{
		$this->final = $lines;
		$this->orig = false;
	}

	function &reverse()
	{
		$reverse = new diff_op_delete($this->final);
		return $reverse;
	}
}

/**
* @package diff
* @author  Geoffrey T. Dairiki <[email protected]>
*
* @access private
*/
class diff_op_change extends diff_op
{
	function diff_op_change($orig, $final)
	{
		$this->orig = $orig;
		$this->final = $final;
	}

	function &reverse()
	{
		$reverse = new diff_op_change($this->final, $this->orig);
		return $reverse;
	}
}


/**
* A class for computing three way diffs.
*
* @package diff
* @author  Geoffrey T. Dairiki <[email protected]>
*/
class diff3 extends diff
{
	/**
	* Conflict counter.
	* @var integer
	*/
	var $_conflicting_blocks = 0;

	/**
	* Computes diff between 3 sequences of strings.
	*
	* @param array $orig    The original lines to use.
	* @param array $final1  The first version to compare to.
	* @param array $final2  The second version to compare to.
	*/
	function diff3(&$orig, &$final1, &$final2, $preserve_cr = true)
	{
		$diff_engine = new diff_engine();

		$diff_1 = $diff_engine->diff($orig, $final1, $preserve_cr);
		$diff_2 = $diff_engine->diff($orig, $final2, $preserve_cr);

		unset($diff_engine);

		$this->_edits = $this->_diff3($diff_1, $diff_2);
	}

	/**
	* Return merged output
	*
	* @param string $label1 the cvs file version/label from the original set of lines
	* @param string $label2 the cvs file version/label from the new set of lines
	* @param string $label_sep the explanation between label1 and label2 - more of a helper for the user
	* @param bool $get_conflicts if set to true only the number of conflicts is returned
	* @param bool $merge_new if set to true the merged output will have the new file contents on a conflicting merge
	*
	* @return mixed the merged output
	*/
	function merged_output($label1 = 'CURRENT_FILE', $label2 = 'NEW_FILE', $label_sep = 'DIFF_SEP_EXPLAIN', $get_conflicts = false, $merge_new = false)
	{
		global $user;

		if ($get_conflicts)
		{
		for ($i = 0, $size = sizeof($this->_edits); $i < $size; $i++)
		{
			$edit = $this->_edits[$i];

			if ($edit->is_conflict())
			{
					$this->_conflicting_blocks++;
			}
		}

			return $this->_conflicting_blocks;
	}

		$label1 = (!empty($user->lang[$label1])) ? $user->lang[$label1] : $label1;
		$label2 = (!empty($user->lang[$label2])) ? $user->lang[$label2] : $label2;
		$label_sep = (!empty($user->lang[$label_sep])) ? $user->lang[$label_sep] : $label_sep;

		$lines = array();

		for ($i = 0, $size = sizeof($this->_edits); $i < $size; $i++)
		{
			$edit = $this->_edits[$i];

			if ($edit->is_conflict())
			{
				if (!$merge_new)
				{
					$lines = array_merge($lines, array('<<<<<<<' . ($label1 ? ' ' . $label1 : '')), $edit->final1, array('=======' . ($label_sep ? ' ' . $label_sep : '')), $edit->final2, array('>>>>>>>' . ($label2 ? ' ' . $label2 : '')));
				}
				else
				{
					$lines = array_merge($lines, $edit->final1);
				}
				$this->_conflicting_blocks++;
			}
			else
			{
				$lines = array_merge($lines, $edit->merged());
			}
		}

		return $lines;
	}

	/**
	* Merge the output and use the new file code for conflicts
	*/
	function merged_new_output()
	{
		$lines = array();

		for ($i = 0, $size = sizeof($this->_edits); $i < $size; $i++)
		{
			$edit = $this->_edits[$i];

			if ($edit->is_conflict())
			{
				$lines = array_merge($lines, $edit->final2);
			}
			else
			{
				$lines = array_merge($lines, $edit->merged());
			}
		}

		return $lines;
	}

	/**
	* Merge the output and use the original file code for conflicts
	*/
	function merged_orig_output()
	{
		$lines = array();

		for ($i = 0, $size = sizeof($this->_edits); $i < $size; $i++)
		{
			$edit = $this->_edits[$i];

			if ($edit->is_conflict())
			{
				$lines = array_merge($lines, $edit->final1);
			}
			else
			{
				$lines = array_merge($lines, $edit->merged());
			}
		}

		return $lines;
	}

	/**
	* Get conflicting block(s)
	*/
	function get_conflicts()
	{
		$conflicts = array();

		for ($i = 0, $size = sizeof($this->_edits); $i < $size; $i++)
		{
			$edit = $this->_edits[$i];

			if ($edit->is_conflict())
			{
				$conflicts[] = array($edit->final1, $edit->final2);
			}
		}

		return $conflicts;
	}

	/**
	* @access private
	*/
	function _diff3(&$edits1, &$edits2)
	{
		$edits = array();
		$bb = new diff3_block_builder();

		$e1 = current($edits1);
		$e2 = current($edits2);

		while ($e1 || $e2)
		{
			if ($e1 && $e2 && is_a($e1, 'diff_op_copy') && is_a($e2, 'diff_op_copy'))
			{
				// We have copy blocks from both diffs. This is the (only) time we want to emit a diff3 copy block.
				// Flush current diff3 diff block, if any.
				if ($edit = $bb->finish())
				{
					$edits[] = $edit;
				}

				$ncopy = min($e1->norig(), $e2->norig());
				$edits[] = new diff3_op_copy(array_slice($e1->orig, 0, $ncopy));

				if ($e1->norig() > $ncopy)
				{
					array_splice($e1->orig, 0, $ncopy);
					array_splice($e1->final, 0, $ncopy);
				}
				else
				{
					$e1 = next($edits1);
				}

				if ($e2->norig() > $ncopy)
				{
					array_splice($e2->orig, 0, $ncopy);
					array_splice($e2->final, 0, $ncopy);
				}
				else
				{
					$e2 = next($edits2);
				}
			}
			else
			{
				if ($e1 && $e2)
				{
					if ($e1->orig && $e2->orig)
					{
						$norig = min($e1->norig(), $e2->norig());
						$orig = array_splice($e1->orig, 0, $norig);
						array_splice($e2->orig, 0, $norig);
						$bb->input($orig);
					}
					else
					{
						$norig = 0;
					}

					if (is_a($e1, 'diff_op_copy'))
					{
						$bb->out1(array_splice($e1->final, 0, $norig));
					}

					if (is_a($e2, 'diff_op_copy'))
					{
						$bb->out2(array_splice($e2->final, 0, $norig));
					}
				}

				if ($e1 && ! $e1->orig)
				{
					$bb->out1($e1->final);
					$e1 = next($edits1);
				}

				if ($e2 && ! $e2->orig)
				{
					$bb->out2($e2->final);
					$e2 = next($edits2);
				}
			}
		}

		if ($edit = $bb->finish())
		{
			$edits[] = $edit;
		}

		return $edits;
	}
}

/**
* @package diff
* @author  Geoffrey T. Dairiki <[email protected]>
*
* @access private
*/
class diff3_op
{
	function diff3_op($orig = false, $final1 = false, $final2 = false)
	{
		$this->orig = $orig ? $orig : array();
		$this->final1 = $final1 ? $final1 : array();
		$this->final2 = $final2 ? $final2 : array();
	}

	function merged()
	{
		if (!isset($this->_merged))
		{
			// Prepare the arrays before we compare them. ;)
			$this->solve_prepare();

			if ($this->final1 === $this->final2)
			{
				$this->_merged = &$this->final1;
			}
			else if ($this->final1 === $this->orig)
			{
				$this->_merged = &$this->final2;
			}
			else if ($this->final2 === $this->orig)
			{
				$this->_merged = &$this->final1;
			}
			else
			{
				// The following tries to aggressively solve conflicts...
				$this->_merged = false;
				$this->solve_conflict();
			}
		}

		return $this->_merged;
	}

	function is_conflict()
	{
		return ($this->merged() === false) ? true : false;
	}

	/**
	* Function to prepare the arrays for comparing - we want to skip over newline changes
	* @author acydburn
	*/
	function solve_prepare()
	{
		// We can simplify one case where the array is usually supposed to be empty...
		if (sizeof($this->orig) == 1 && trim($this->orig[0]) === '') $this->orig = array();
		if (sizeof($this->final1) == 1 && trim($this->final1[0]) === '') $this->final1 = array();
		if (sizeof($this->final2) == 1 && trim($this->final2[0]) === '') $this->final2 = array();

		// Now we only can have the case where the only difference between arrays are newlines, so compare all cases

		// First, some strings we can compare...
		$orig = $final1 = $final2 = '';

		foreach ($this->orig as $null => $line) $orig .= trim($line);
		foreach ($this->final1 as $null => $line) $final1 .= trim($line);
		foreach ($this->final2 as $null => $line) $final2 .= trim($line);

		// final1 === final2
		if ($final1 === $final2)
		{
			// We preserve the part which will be used in the merge later
			$this->final2 = $this->final1;
		}
		// final1 === orig
		else if ($final1 === $orig)
		{
			// Here it does not really matter what we choose, but we will use the new code
			$this->orig = $this->final1;
		}
		// final2 === orig
		else if ($final2 === $orig)
		{
			// Here it does not really matter too (final1 will be used), but we will use the new code
			$this->orig = $this->final2;
		}
	}

	/**
	* Find code portions from $orig in $final1 and use $final2 as merged instance if provided
	* @author acydburn
	*/
	function _compare_conflict_seq($orig, $final1, $final2 = false)
	{
		$result = array('merge_found' => false, 'merge' => array());

		$_orig = &$this->$orig;
		$_final1 = &$this->$final1;

		// Ok, we basically search for $orig in $final1
		$compare_seq = sizeof($_orig);

		// Go through the conflict code
		for ($i = 0, $j = 0, $size = sizeof($_final1); $i < $size; $i++, $j = $i)
		{
			$line = $_final1[$i];
			$skip = 0;

			for ($x = 0; $x < $compare_seq; $x++)
			{
				// Try to skip all matching lines
				if (trim($line) === trim($_orig[$x]))
				{
					$line = (++$j < $size) ? $_final1[$j] : $line;
					$skip++;
				}
			}

			if ($skip === $compare_seq)
			{
				$result['merge_found'] = true;

				if ($final2 !== false)
				{
					$result['merge'] = array_merge($result['merge'], $this->$final2);
				}
				$i += ($skip - 1);
			}
			else if ($final2 !== false)
			{
				$result['merge'][] = $line;
			}
		}

		return $result;
	}

	/**
	* Tries to solve conflicts aggressively based on typical "assumptions"
	* @author acydburn
	*/
	function solve_conflict()
	{
		$this->_merged = false;

		// CASE ONE: orig changed into final2, but modified/unknown code in final1.
		// IF orig is found "as is" in final1 we replace the code directly in final1 and populate this as final2/merge
		if (sizeof($this->orig) && sizeof($this->final2))
		{
			$result = $this->_compare_conflict_seq('orig', 'final1', 'final2');

			if ($result['merge_found'])
			{
				$this->final2 = $result['merge'];
				$this->_merged = &$this->final2;
				return;
			}

			$result = $this->_compare_conflict_seq('final2', 'final1');

			if ($result['merge_found'])
			{
				$this->_merged = &$this->final1;
				return;
			}

			// Try to solve $Id: diff.php 10168 2009-09-20 16:20:20Z acydburn $ issues. ;)
			if (sizeof($this->orig) == 1 && sizeof($this->final1) == 1 && sizeof($this->final2) == 1)
			{
				$match = '#^' . preg_quote('* @version $Id: ', '#') . '[a-z\._\- ]+[0-9]+ [0-9]{4}-[0-9]{2}-[0-9]{2} [0-9\:Z]+ [a-z0-9_\- ]+\$$#';

				if (preg_match($match, $this->orig[0]) && preg_match($match, $this->final1[0]) && preg_match($match, $this->final2[0]))
				{
					$this->_merged = &$this->final2;
					return;
				}
			}

			$second_run = false;

			// Try to solve issues where the only reason why the above did not work is a newline being removed in the final1 code but exist in the orig/final2 code
			if (trim($this->orig[0]) === '' && trim($this->final2[0]) === '')
			{
				unset($this->orig[0], $this->final2[0]);
				$this->orig = array_values($this->orig);
				$this->final2 = array_values($this->final2);

				$second_run = true;
			}

			// The same is true for a line at the end. ;)
			if (sizeof($this->orig) && sizeof($this->final2) && sizeof($this->orig) === sizeof($this->final2) && trim($this->orig[sizeof($this->orig)-1]) === '' && trim($this->final2[sizeof($this->final2)-1]) === '')
			{
				unset($this->orig[sizeof($this->orig)-1], $this->final2[sizeof($this->final2)-1]);
				$this->orig = array_values($this->orig);
				$this->final2 = array_values($this->final2);

				$second_run = true;
			}

			if ($second_run)
			{
				$result = $this->_compare_conflict_seq('orig', 'final1', 'final2');

				if ($result['merge_found'])
				{
					$this->final2 = $result['merge'];
					$this->_merged = &$this->final2;
					return;
				}

				$result = $this->_compare_conflict_seq('final2', 'final1');

				if ($result['merge_found'])
				{
					$this->_merged = &$this->final1;
					return;
				}
			}

			return;
		}

		// CASE TWO: Added lines from orig to final2 but final1 had added lines too. Just merge them.
		if (!sizeof($this->orig) && $this->final1 !== $this->final2 && sizeof($this->final1) && sizeof($this->final2))
		{
			$result = $this->_compare_conflict_seq('final2', 'final1');

			if ($result['merge_found'])
			{
				$this->final2 = $this->final1;
				$this->_merged = &$this->final1;
			}
			else
			{
				$result = $this->_compare_conflict_seq('final1', 'final2');

				if (!$result['merge_found'])
				{
					$this->final2 = array_merge($this->final1, $this->final2);
					$this->_merged = &$this->final2;
				}
				else
				{
					$this->final2 = $this->final1;
					$this->_merged = &$this->final1;
				}
			}

			return;
		}

		// CASE THREE: Removed lines (orig has the to-remove line(s), but final1 has additional lines which does not need to be removed). Just remove orig from final1 and then use final1 as final2/merge
		if (!sizeof($this->final2) && sizeof($this->orig) && sizeof($this->final1) && $this->orig !== $this->final1)
		{
			$result = $this->_compare_conflict_seq('orig', 'final1');

			if (!$result['merge_found'])
			{
				return;
			}

			// First of all, try to find the code in orig in final1. ;)
			$compare_seq = sizeof($this->orig);
			$begin = $end = -1;
			$j = 0;

			for ($i = 0, $size = sizeof($this->final1); $i < $size; $i++)
			{
				$line = $this->final1[$i];

				if (trim($line) === trim($this->orig[$j]))
				{
					// Mark begin
					if ($begin === -1)
					{
						$begin = $i;
					}

					// End is always $i, the last found line
					$end = $i;

					if (isset($this->orig[$j+1]))
					{
						$j++;
					}
				}
			}

			if ($begin !== -1 && $begin + ($compare_seq - 1) == $end)
			{
				foreach ($this->final1 as $i => $line)
				{
					if ($i < $begin || $i > $end)
					{
						$merged[] = $line;
					}
				}

				$this->final2 = $merged;
				$this->_merged = &$this->final2;
			}

			return;
		}

		return;
	}
}

/**
* @package diff
* @author  Geoffrey T. Dairiki <[email protected]>
*
* @access private
*/
class diff3_op_copy extends diff3_op
{
	function diff3_op_copy($lines = false)
	{
		$this->orig = $lines ? $lines : array();
		$this->final1 = &$this->orig;
		$this->final2 = &$this->orig;
	}

	function merged()
	{
		return $this->orig;
	}

	function is_conflict()
	{
		return false;
	}
}

/**
* @package diff
* @author  Geoffrey T. Dairiki <[email protected]>
*
* @access private
*/
class diff3_block_builder
{
	function diff3_block_builder()
	{
		$this->_init();
	}

	function input($lines)
	{
		if ($lines)
		{
			$this->_append($this->orig, $lines);
		}
	}

	function out1($lines)
	{
		if ($lines)
		{
			$this->_append($this->final1, $lines);
		}
	}

	function out2($lines)
	{
		if ($lines)
		{
			$this->_append($this->final2, $lines);
		}
	}

	function is_empty()
	{
		return !$this->orig && !$this->final1 && !$this->final2;
	}

	function finish()
	{
		if ($this->is_empty())
		{
			return false;
		}
		else
		{
			$edit = new diff3_op($this->orig, $this->final1, $this->final2);
			$this->_init();
			return $edit;
		}
	}

	function _init()
	{
		$this->orig = $this->final1 = $this->final2 = array();
	}

	function _append(&$array, $lines)
	{
		array_splice($array, sizeof($array), 0, $lines);
	}
}

?>

[AdamR]

Save a backup of that file (you should have a full backup of your database and files before attempting an upgrade, anyway ) and try replacing it with a copy from this package.

Purge your board's cache from the main page of the ACP and try again.

- Adam

[edgar davids]

Save a backup of that file (you should have a full backup of your database and files before attempting an upgrade, anyway ) and try replacing it with a copy from this package.

Purge your board's cache from the main page of the ACP and try again.

- Adam

I done as above, got a little further but eventually times out at the following;

Code: Select all

Collecting file differences
Currently differences from 30 of 127 files have been checked.
Please wait until all files are checked.

I've tried both Mozilla's Firefox and IE8.

[edgar davids]

I found this post but I don't have this MOD installed;

Re: Checking Files while updating from 3.0.2 to 3.0.3

I fixed it now ...

I installed primes Disable Chache mod... If I deactivate it it works ...

[edgar davids]

anyone?

[edgar davids]

Anyone guys? I don't want to run an un-patched product for too long!

[edgar davids]

bump.

[edgar davids]

no one?

[ric323]

Are you prepared to re-install ALL your MODs?
If yes, then you can simply over-write all your files with clean copies from the latest install package.

[edgar davids]

Re-installing all MODs is not an option.

[edgar davids]

Re-attempted, just hangs at;

Code: Select all

Currently differences from 30 of 127 files have been checked.

then times out.

[narqelion]

If you have verified that your /cache & /store folder are writable by the script and you don't want to redo your MOD's you are probably going to have to do an offline update.

[edgar davids]

If you have verified that your /cache & /store folder are writable by the script

Both cache and store have 0777 permissions.

and you don't want to redo your MOD's you are probably going to have to do an offline update.

How many files need to be patched manually?

[narqelion]

How many files need to be patched manually?

I have no idea, it depends on what files your MOD's affect out of the 126 files that were changed from 3.0.6 -> 3.0.7pl1. Unless you kept a changelog/VCS of which phpBB files you modded you won't know either.