myanmar.php | searchcode

/vendor/mpdf/mpdf/classes/myanmar.php

https://gitlab.com/0sajib0/NECI
PHP | 484 lines | 385 code | 61 blank | 38 comment | 92 complexity | 9d6ec6f00847157a58996fe17a0d6ce4 MD5 | raw file

<?php

class MYANMAR
{
	/* FROM hb-ot-shape-complex-indic-private.hh */

	// indic_category
	const OT_X = 0;
	const OT_C = 1;
	const OT_V = 2;
	const OT_N = 3;
	const OT_H = 4;
	const OT_ZWNJ = 5;
	const OT_ZWJ = 6;
	const OT_M = 7;  /* Matra or Dependent Vowel */
	const OT_SM = 8;
	const OT_VD = 9;
	const OT_A = 10;
	const OT_NBSP = 11;
	const OT_DOTTEDCIRCLE = 12; /* Not in the spec, but special in Uniscribe. /Very very/ special! */
	const OT_RS = 13;   /* Register Shifter, used in Khmer OT spec */
	const OT_Coeng = 14;
	const OT_Repha = 15;
	const OT_Ra = 16;   /* Not explicitly listed in the OT spec, but used in the grammar. */
	const OT_CM = 17;

	/* FROM hb-ot-shape-complex-myanmar.hh */

	// myanmar_category
	const OT_DB = 3;  // same as INDIC::OT_N; /* Dot below */
	const OT_GB = 12;  // same as INDIC::OT_DOTTEDCIRCLE;
	const OT_As = 18; /* Asat */
	const OT_D = 19; /* Digits except zero */
	const OT_D0 = 20; /* Digit zero */
	const OT_MH = 21; /* Various consonant medial types */
	const OT_MR = 22; /* Various consonant medial types */
	const OT_MW = 23; /* Various consonant medial types */
	const OT_MY = 24; /* Various consonant medial types */
	const OT_PT = 25; /* Pwo and other tones */

	const OT_VAbv = 26;
	const OT_VBlw = 27;
	const OT_VPre = 28;
	const OT_VPst = 29;
	const OT_VS = 30; /* Variation selectors */

	// Based on myanmar_category used to make string to find syllables
	// OT_ to string character (using e.g. OT_C from MYANMAR) hb-ot-shape-complex-myanmar-private.hh
	public static $myanmar_category_char = array(
		'x',
		'C',
		'V',
		'N',
		'H',
		'Z',
		'J',
		'x',
		'S',
		'x',
		'A',
		'x',
		'D',
		'x',
		'x',
		'x',
		'R',
		'x',
		'a', /* As Asat */
		'd', /* Digits except zero */
		'o', /* Digit zero */
		'k', /* Medial types */
		'l', /* Medial types */
		'm', /* Medial types */
		'n', /* Medial types */
		'p', /* Pwo and other tones */
		'v', /* Vowel aboVe */
		'b', /* Vowel Below */
		'e', /* Vowel prE */
		't', /* Vowel posT */
		's', /* variation Selector */
	);

	/* Visual positions in a syllable from left to right. */
	/* FROM hb-ot-shape-complex-myanmar-private.hh */

	// myanmar_position
	const POS_START = 0;

	const POS_RA_TO_BECOME_REPH = 1;
	const POS_PRE_M = 2;
	const POS_PRE_C = 3;

	const POS_BASE_C = 4;
	const POS_AFTER_MAIN = 5;

	const POS_ABOVE_C = 6;

	const POS_BEFORE_SUB = 7;
	const POS_BELOW_C = 8;
	const POS_AFTER_SUB = 9;

	const POS_BEFORE_POST = 10;
	const POS_POST_C = 11;
	const POS_AFTER_POST = 12;

	const POS_FINAL_C = 13;
	const POS_SMVD = 14;

	const POS_END = 15;

	public static function set_myanmar_properties(&$info)
	{
		$u = $info['uni'];
		$type = self::myanmar_get_categories($u);
		$cat = ($type & 0x7F);
		$pos = ($type >> 8);
		/*
		 * Re-assign category
		 * http://www.microsoft.com/typography/OpenTypeDev/myanmar/intro.htm#analyze
		 */
		if (self::in_range($u, 0xFE00, 0xFE0F))
			$cat = self::OT_VS;
		else if ($u == 0x200C)
			$cat = self::OT_ZWNJ;
		else if ($u == 0x200D)
			$cat = self::OT_ZWJ;

		switch ($u) {
			case 0x002D: case 0x00A0: case 0x00D7: case 0x2012:
			case 0x2013: case 0x2014: case 0x2015: case 0x2022:
			case 0x25CC: case 0x25FB: case 0x25FC: case 0x25FD:
			case 0x25FE:
				$cat = self::OT_GB;
				break;

			case 0x1004: case 0x101B: case 0x105A:
				$cat = self::OT_Ra;
				break;

			case 0x1032: case 0x1036:
				$cat = self::OT_A;
				break;

			case 0x103A:
				$cat = self::OT_As;
				break;

			case 0x1041: case 0x1042: case 0x1043: case 0x1044:
			case 0x1045: case 0x1046: case 0x1047: case 0x1048:
			case 0x1049: case 0x1090: case 0x1091: case 0x1092:
			case 0x1093: case 0x1094: case 0x1095: case 0x1096:
			case 0x1097: case 0x1098: case 0x1099:
				$cat = self::OT_D;
				break;

			case 0x1040:
				$cat = self::OT_D; /* XXX The spec says D0, but Uniscribe doesn't seem to do. */
				break;

			case 0x103E: case 0x1060:
				$cat = self::OT_MH;
				break;

			case 0x103C:
				$cat = self::OT_MR;
				break;

			case 0x103D: case 0x1082:
				$cat = self::OT_MW;
				break;

			case 0x103B: case 0x105E: case 0x105F:
				$cat = self::OT_MY;
				break;

			case 0x1063: case 0x1064: case 0x1069: case 0x106A:
			case 0x106B: case 0x106C: case 0x106D: case 0xAA7B:
				$cat = self::OT_PT;
				break;

			case 0x1038: case 0x1087: case 0x1088: case 0x1089:
			case 0x108A: case 0x108B: case 0x108C: case 0x108D:
			case 0x108F: case 0x109A: case 0x109B: case 0x109C:
				$cat = self::OT_SM;
				break;
		}

		if ($cat == self::OT_M) {
			switch ($pos) {
				case self::POS_PRE_C:
					$cat = self::OT_VPre;
					$pos = self::POS_PRE_M;
					break;
				case self::POS_ABOVE_C: $cat = self::OT_VAbv;
					break;
				case self::POS_BELOW_C: $cat = self::OT_VBlw;
					break;
				case self::POS_POST_C: $cat = self::OT_VPst;
					break;
			}
		}
		$info['myanmar_category'] = $cat;
		$info['myanmar_position'] = $pos;
	}

	// syllable_type
	const CONSONANT_SYLLABLE = 0;
	const BROKEN_CLUSTER = 3;
	const NON_MYANMAR_CLUSTER = 4;

	public static function set_syllables(&$o, $s, &$broken_syllables)
	{
		$ptr = 0;
		$syllable_serial = 1;
		$broken_syllables = false;

		while ($ptr < strlen($s)) {
			$match = '';
			$syllable_length = 1;
			$syllable_type = self::NON_MYANMAR_CLUSTER;
			// CONSONANT_SYLLABLE Consonant syllable
			// From OT spec:
			if (preg_match('/^(RaH)?([C|R]|V|d|D)[s]?(H([C|R|V])[s]?)*(H|[a]*[n]?[l]?((m[k]?|k)[a]?)?[e]*[v]*[b]*[A]*(N[a]?)?(t[k]?[a]*[v]*[A]*(N[a]?)?)*(p[A]*(N[a]?)?)*S*[J|Z]?)/', substr($s, $ptr), $ma)) {
				$syllable_length = strlen($ma[0]);
				$syllable_type = self::CONSONANT_SYLLABLE;
			}

			// BROKEN_CLUSTER syllable
			else if (preg_match('/^(RaH)?s?(H|[a]*[n]?[l]?((m[k]?|k)[a]?)?[e]*[v]*[b]*[A]*(N[a]?)?(t[k]?[a]*[v]*[A]*(N[a]?)?)*(p[A]*(N[a]?)?)*S*[J|Z]?)/', substr($s, $ptr), $ma)) {
				if (strlen($ma[0])) { // May match blank
					$syllable_length = strlen($ma[0]);
					$syllable_type = self::BROKEN_CLUSTER;
					$broken_syllables = true;
				}
			}
			for ($i = $ptr; $i < $ptr + $syllable_length; $i++) {
				$o[$i]['syllable'] = ($syllable_serial << 4) | $syllable_type;
			}
			$ptr += $syllable_length;
			$syllable_serial++;
			if ($syllable_serial == 16)
				$syllable_serial = 1;
		}
	}

	public static function reordering(&$info, $GSUBdata, $broken_syllables, $dottedcircle)
	{
		if ($broken_syllables && $dottedcircle) {
			self::insert_dotted_circles($info, $dottedcircle);
		}
		$count = count($info);
		if (!$count)
			return;
		$last = 0;
		$last_syllable = $info[0]['syllable'];
		for ($i = 1; $i < $count; $i++) {
			if ($last_syllable != $info[$i]['syllable']) {
				self::reordering_syllable($info, $GSUBdata, $last, $i);
				$last = $i;
				$last_syllable = $info[$last]['syllable'];
			}
		}
		self::reordering_syllable($info, $GSUBdata, $last, $count);
	}

	public static function insert_dotted_circles(&$info, $dottedcircle)
	{
		$idx = 0;
		$last_syllable = 0;
		while ($idx < count($info)) {
			$syllable = $info[$idx]['syllable'];
			$syllable_type = ($syllable & 0x0F);
			if ($last_syllable != $syllable && $syllable_type == self::BROKEN_CLUSTER) {
				$last_syllable = $syllable;
				$dottedcircle[0]['syllable'] = $info[$idx]['syllable'];
				array_splice($info, $idx, 0, $dottedcircle);
			} else
				$idx++;
		}
		// In case of final bloken cluster...
		$syllable = $info[$idx]['syllable'];
		$syllable_type = ($syllable & 0x0F);
		if ($last_syllable != $syllable && $syllable_type == self::BROKEN_CLUSTER) {
			$dottedcircle[0]['syllable'] = $info[$idx]['syllable'];
			array_splice($info, $idx, 0, $dottedcircle);
		}
	}

	/* Rules from:
	 * https://www.microsoft.com/typography/otfntdev/devanot/shaping.aspx */

	public static function reordering_syllable(&$info, $GSUBdata, $start, $end)
	{
		/* vowel_syllable: We made the vowels look like consonants. So uses the consonant logic! */
		/* broken_cluster: We already inserted dotted-circles, so just call the standalone_cluster. */

		$syllable_type = ($info[$start]['syllable'] & 0x0F);
		if ($syllable_type == self::NON_MYANMAR_CLUSTER) {
			return;
		}
		if ($syllable_type == self::BROKEN_CLUSTER) {
			//if ($uniscribe_bug_compatible) {
			/* For dotted-circle, this is what Uniscribe does:
			 * If dotted-circle is the last glyph, it just does nothing.
			 * i.e. It doesn't form Reph. */
			if ($info[$end - 1]['myanmar_category'] == self::OT_DOTTEDCIRCLE) {
				return;
			}
		}

		$base = $end;
		$has_reph = false;
		$limit = $start;

		if (($start + 3 <= $end) &&
			$info[$start]['myanmar_category'] == self::OT_Ra &&
			$info[$start + 1]['myanmar_category'] == self::OT_As &&
			$info[$start + 2]['myanmar_category'] == self::OT_H) {
			$limit += 3;
			$base = $start;
			$has_reph = true;
		}

		if (!$has_reph)
			$base = $limit;

		for ($i = $limit; $i < $end; $i++) {
			if (self::is_consonant($info[$i])) {
				$base = $i;
				break;
			}
		}


		/* Reorder! */
		$i = $start;
		for (; $i < $start + ($has_reph ? 3 : 0); $i++)
			$info[$i]['myanmar_position'] = self::POS_AFTER_MAIN;
		for (; $i < $base; $i++)
			$info[$i]['myanmar_position'] = self::POS_PRE_C;
		if ($i < $end) {
			$info[$i]['myanmar_position'] = self::POS_BASE_C;
			$i++;
		}
		$pos = self::POS_AFTER_MAIN;
		/* The following loop may be ugly, but it implements all of
		 * Myanmar reordering! */
		for (; $i < $end; $i++) {
			if ($info[$i]['myanmar_category'] == self::OT_MR) /* Pre-base reordering */ {
				$info[$i]['myanmar_position'] = self::POS_PRE_C;
				continue;
			}
			if ($info[$i]['myanmar_position'] < self::POS_BASE_C) /* Left matra */ {
				continue;
			}

			if ($pos == self::POS_AFTER_MAIN && $info[$i]['myanmar_category'] == self::OT_VBlw) {
				$pos = self::POS_BELOW_C;
				$info[$i]['myanmar_position'] = $pos;
				continue;
			}

			if ($pos == self::POS_BELOW_C && $info[$i]['myanmar_category'] == self::OT_A) {
				$info[$i]['myanmar_position'] = self::POS_BEFORE_SUB;
				continue;
			}
			if ($pos == self::POS_BELOW_C && $info[$i]['myanmar_category'] == self::OT_VBlw) {
				$info[$i]['myanmar_position'] = $pos;
				continue;
			}
			if ($pos == self::POS_BELOW_C && $info[$i]['myanmar_category'] != self::OT_A) {
				$pos = self::POS_AFTER_SUB;
				$info[$i]['myanmar_position'] = $pos;
				continue;
			}
			$info[$i]['myanmar_position'] = $pos;
		}


		/* Sit tight, rock 'n roll! */
		self::bubble_sort($info, $start, $end - $start);
	}

	public static function is_one_of($info, $flags)
	{
		if (isset($info['is_ligature']) && $info['is_ligature'])
			return false; /* If it ligated, all bets are off. */
		return !!(self::FLAG($info['myanmar_category']) & $flags);
	}

	/* Vowels and placeholders treated as if they were consonants. */

	public static function is_consonant($info)
	{
		return self::is_one_of($info, (self::FLAG(self::OT_C) | self::FLAG(self::OT_CM) | self::FLAG(self::OT_Ra) | self::FLAG(self::OT_V) | self::FLAG(self::OT_NBSP) | self::FLAG(self::OT_GB)));
	}

// From hb-private.hh
	public static function in_range($u, $lo, $hi)
	{
		if ((($lo ^ $hi) & $lo) == 0 && (($lo ^ $hi) & $hi) == ($lo ^ $hi) && (($lo ^ $hi) & (($lo ^ $hi) + 1)) == 0)
			return ($u & ~($lo ^ $hi)) == $lo;
		else
			return $lo <= $u && $u <= $hi;
	}

// From hb-private.hh
	public static function FLAG($x)
	{
		return (1 << ($x));
	}

	public static function FLAG_RANGE($x, $y)
	{
		self::FLAG(y + 1) - self::FLAG(x);
	}

// BELOW from hb-ot-shape-complex-indic.cc
// see INDIC for details

	public static $myanmar_table = array(
		/* Myanmar  (1000..109F) */

		/* 1000 */ 3841, 3841, 3841, 3841, 3841, 3841, 3841, 3841,
		/* 1008 */ 3841, 3841, 3841, 3841, 3841, 3841, 3841, 3841,
		/* 1010 */ 3841, 3841, 3841, 3841, 3841, 3841, 3841, 3841,
		/* 1018 */ 3841, 3841, 3841, 3841, 3841, 3841, 3841, 3841,
		/* 1020 */ 3841, 3842, 3842, 3842, 3842, 3842, 3842, 3842,
		/* 1028 */ 3842, 3842, 3842, 2823, 2823, 1543, 1543, 2055,
		/* 1030 */ 2055, 775, 1543, 1543, 1543, 1543, 3848, 3843,
		/* 1038 */ 3848, 3844, 1540, 3857, 3857, 3857, 3857, 3841,
		/* 1040 */ 3840, 3840, 3840, 3840, 3840, 3840, 3840, 3840,
		/* 1048 */ 3840, 3840, 3840, 3840, 3840, 3840, 3840, 3840,
		/* 1050 */ 3841, 3841, 3842, 3842, 3842, 3842, 2823, 2823,
		/* 1058 */ 2055, 2055, 3841, 3841, 3841, 3841, 3857, 3857,
		/* 1060 */ 3857, 3841, 2823, 3843, 3843, 3841, 3841, 2823,
		/* 1068 */ 2823, 3843, 3843, 3843, 3843, 3843, 3841, 3841,
		/* 1070 */ 3841, 1543, 1543, 1543, 1543, 3841, 3841, 3841,
		/* 1078 */ 3841, 3841, 3841, 3841, 3841, 3841, 3841, 3841,
		/* 1080 */ 3841, 3841, 3857, 2823, 775, 1543, 1543, 3843,
		/* 1088 */ 3843, 3843, 3843, 3843, 3843, 3843, 3841, 3843,
		/* 1090 */ 3840, 3840, 3840, 3840, 3840, 3840, 3840, 3840,
		/* 1098 */ 3840, 3840, 3843, 3843, 2823, 1543, 3840, 3840,
		/* Myanmar Extended-A  (AA60..AA7F) */

		/* AA60 */ 3841, 3841, 3841, 3841, 3841, 3841, 3841, 3841,
		/* AA68 */ 3841, 3841, 3841, 3841, 3841, 3841, 3841, 3841,
		/* AA70 */ 3840, 3841, 3841, 3841, 3840, 3840, 3840, 3840,
		/* AA78 */ 3840, 3840, 3841, 3843, 3840, 3840, 3840, 3840,
	);

// from "hb-ot-shape-complex-indic-table.cc"
	public static function myanmar_get_categories($u)
	{
		if (0x1000 <= $u && $u <= 0x109F)
			return self::$myanmar_table[$u - 0x1000 + 0]; // offset 0 for Most "myanmar"
		if (0xAA60 <= $u && $u <= 0xAA7F)
			return self::$myanmar_table[$u - 0xAA60 + 160]; // offset for extensions
		if ($u == 0x00A0)
			return 3851; // (ISC_CP | (IMC_x << 8))
		if ($u == 0x25CC)
			return 3851; // (ISC_CP | (IMC_x << 8))
		return 3840; // (ISC_x | (IMC_x << 8))
	}

	public static function bubble_sort(&$arr, $start, $len)
	{
		if ($len < 2) {
			return;
		}
		$k = $start + $len - 2;
		while ($k >= $start) {
			for ($j = $start; $j <= $k; $j++) {
				if ($arr[$j]['myanmar_position'] > $arr[$j + 1]['myanmar_position']) {
					$t = $arr[$j];
					$arr[$j] = $arr[$j + 1];
					$arr[$j + 1] = $t;
				}
			}
			$k--;
		}
	}

}