Code Changes

* @param	string	$words	An array of words which should be contained in the result, has to be a valid part of a PCRE pattern (escape with preg_quote!)

* @param	array	$words	An array of words which should be contained in the result, has to be a valid part of a PCRE pattern (escape with preg_quote!)

function get_context($text, $words, $length = 400)

function get_context(string $text, array $words, int $length = 400): string

	// first replace all whitespaces with single spaces
	$text = preg_replace('/ +/', ' ', strtr($text, "\t\n\r\x0C ", '     '));

	if ($length <= 0)
	{
		return '...';
	}

	$entities = array('<', '>', '[', ']', '.', ':', ':');
	$characters = array('<', '>', '[', ']', '.', ':', ':');
	$text = str_replace($entities, $characters, $text);

	$text = html_entity_decode($text);

	// Replace all spaces/invisible characters with single spaces
	$text = preg_replace("/\s+/u", ' ', $text);

	$word_indizes = array();
	if (count($words))
	{
		$match = '';
		// find the starting indizes of all words

	$text_length = utf8_strlen($text);

	// Get first occurrence of each word
	$word_indexes = [];

			if ($word)
			{
				if (preg_match('#(?:[^\w]|^)(' . $word . ')(?:[^\w]|$)#i', $text, $match))
				{
					if (empty($match[1]))
					{
						continue;
					}

		$pos = utf8_stripos($text, $word);

						$word_indizes[] = $pos;

			$word_indexes[$pos] = $word;

		if (count($word_indizes))

	if (!empty($word_indexes))

			$word_indizes = array_unique($word_indizes);
			sort($word_indizes);

		ksort($word_indexes);

			$wordnum = count($word_indizes);
			// number of characters on the right and left side of each word
			$sequence_length = (int) ($length / (2 * $wordnum)) - 2;
			$final_text = '';
			$word = $j = 0;
			$final_text_index = -1;

		// Size of the fragment of text per word
		$num_indexes = count($word_indexes);
		$characters_per_word = (int) ($length / $num_indexes) + 2; // 2 to leave one character of margin at the sides to don't cut words

			// cycle through every character in the original text
			for ($i = $word_indizes[$word], $n = utf8_strlen($text); $i < $n; $i++)

		// Get text fragment indexes
		$fragments = [];
		foreach ($word_indexes as $index => $word)

				// if the current position is the start of one of the words then append $sequence_length characters to the final text
				if (isset($word_indizes[$word]) && ($i == $word_indizes[$word]))

			$word_length = utf8_strlen($word);
			$start = max(0, min($text_length - 1 - $characters_per_word, (int) ($index + ($word_length / 2) - ($characters_per_word / 2))));
			$end = $start + $characters_per_word;

			// Check if we can merge this fragment into the previous fragment
			if (!empty($fragments))

					if ($final_text_index < $i - $sequence_length - 1)

				[$prev_start, $prev_end] = end($fragments);

				if ($prev_end + $characters_per_word >= $index + $word_length)

						$final_text .= '... ' . preg_replace('#^([^ ]*)#', '', utf8_substr($text, $i - $sequence_length, $sequence_length));

					array_pop($fragments);
					$start = $prev_start;
					$end = $prev_end + $characters_per_word;
				}
			}

			$fragments[] = [$start, $end];
		}

						// if the final text is already nearer to the current word than $sequence_length we only append the text
						// from its current index on and distribute the unused length to all other sequenes
						$sequence_length += (int) (($final_text_index - $i + $sequence_length + 1) / (2 * $wordnum));
						$final_text .= utf8_substr($text, $final_text_index + 1, $i - $final_text_index - 1);
					}
					$final_text_index = $i - 1;

					// add the following characters to the final text (see below)
					$word++;
					$j = 1;

		// There is no coincidences, so we just create a fragment with the first $length characters
		$fragments[] = [0, $length];
		$end = $length;

				if ($j > 0)

	$output = [];
	foreach ($fragments as [$start, $end])

					// add the character to the final text and increment the sequence counter
					$final_text .= utf8_substr($text, $i, 1);
					$final_text_index++;
					$j++;

		$fragment = utf8_substr($text, $start, $end - $start + 1);

					// if this is a whitespace then check whether we are done with this sequence
					if (utf8_substr($text, $i, 1) == ' ')

		$fragment_start = 0;
		$fragment_end = $end - $start + 1;

		// Find the first valid alphanumeric character in the fragment to don't cut words
		if ($start > 0)

						// only check whether we have to exit the context generation completely if we haven't already reached the end anyway
						if ($i + 4 < $n)
						{
							if (($j > $sequence_length && $word >= $wordnum) || utf8_strlen($final_text) > $length)
							{
								$final_text .= ' ...';
								break;

			preg_match('/[^a-zA-Z0-9][a-zA-Z0-9]/u', $fragment, $matches, PREG_OFFSET_CAPTURE);
			$fragment_start = (int) $matches[0][1] + 1; // first valid alphanumeric character

						}
						else

		// Find the last valid alphanumeric character in the fragment to don't cut words
		if ($end < $text_length - 1)

							// make sure the text really reaches the end
							$j -= 4;

			preg_match_all('/[a-zA-Z0-9][^a-zA-Z0-9]/u', $fragment, $matches, PREG_OFFSET_CAPTURE);
			$fragment_end = end($matches[0])[1]; // last valid alphanumeric character

						// stop context generation and wait for the next word
						if ($j > $sequence_length)
						{
							$j = 0;
						}
					}
				}
			}
			return str_replace($characters, $entities, $final_text);
		}

		$output[] = utf8_substr($fragment, $fragment_start, $fragment_end - $fragment_start + 1);

	if (!count($words) || !count($word_indizes))
	{
		return str_replace($characters, $entities, ((utf8_strlen($text) >= $length + 3) ? utf8_substr($text, 0, $length) . '...' : $text));
	}

	return ($fragments[0][0] !== 0 ? '... ' : '') . htmlentities(implode(' ... ', $output)) . ($end < $text_length - 1 ? ' ...' : '');

		$root_path = (defined('PHPBB_USE_BOARD_URL_PATH') && PHPBB_USE_BOARD_URL_PATH) ? generate_board_url() . '/' : $phpbb_path_helper->get_web_root_path();

		$root_path = $phpbb_path_helper->get_web_root_path();