✏️ Editing: myanmar.php

<?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
?>

Advanced Web Server Manager