<?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--;
	}
}




}	// end Class

?>