Add m-esr52 at 52.6.0

1 files changed, 689 insertions, 0 deletions

diff --git a/gfx/graphite2/src/inc/opcodes.h b/gfx/graphite2/src/inc/opcodes.h
new file mode 100644
index 000000000..3b6dd3fc3
--- /dev/null
+++ b/gfx/graphite2/src/inc/opcodes.h
@@ -0,0 +1,689 @@
+/*  GRAPHITE2 LICENSING
+
+    Copyright 2010, SIL International
+    All rights reserved.
+
+    This library is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published
+    by the Free Software Foundation; either version 2.1 of License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should also have received a copy of the GNU Lesser General Public
+    License along with this library in the file named "LICENSE".
+    If not, write to the Free Software Foundation, 51 Franklin Street, 
+    Suite 500, Boston, MA 02110-1335, USA or visit their web page on the 
+    internet at http://www.fsf.org/licenses/lgpl.html.
+
+Alternatively, the contents of this file may be used under the terms of the
+Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public
+License, as published by the Free Software Foundation, either version 2
+of the License or (at your option) any later version.
+*/
+#pragma once
+// This file will be pulled into and integrated into a machine implmentation
+// DO NOT build directly and under no circumstances every #include headers in 
+// here or you will break the direct_machine.
+//
+// Implementers' notes
+// ==================
+// You have access to a few primitives and the full C++ code:
+//    declare_params(n) Tells the interpreter how many bytes of parameter
+//                      space to claim for this instruction uses and 
+//                      initialises the param pointer.  You *must* before the 
+//                      first use of param.
+//    use_params(n)     Claim n extra bytes of param space beyond what was 
+//                      claimed using delcare_param.
+//    param             A const byte pointer for the parameter space claimed by
+//                      this instruction.
+//    binop(op)         Implement a binary operation on the stack using the 
+//                      specified C++ operator.
+//    NOT_IMPLEMENTED   Any instruction body containing this will exit the 
+//                      program with an assertion error.  Instructions that are
+//                      not implemented should also be marked NILOP in the
+//                      opcodes tables this will cause the code class to spot
+//                      them in a live code stream and throw a runtime_error 
+//                      instead.
+//    push(n)           Push the value n onto the stack.
+//    pop()             Pop the top most value and return it.
+//
+//    You have access to the following named fast 'registers':
+//        sp        = The pointer to the current top of stack, the last value
+//                    pushed.
+//        seg       = A reference to the Segment this code is running over.
+//        is        = The current slot index
+//        isb       = The original base slot index at the start of this rule
+//        isf       = The first positioned slot
+//        isl       = The last positioned slot
+//        ip        = The current instruction pointer
+//        endPos    = Position of advance of last cluster
+//        dir       = writing system directionality of the font
+     
+
+// #define NOT_IMPLEMENTED     assert(false)
+#define NOT_IMPLEMENTED
+
+#define binop(op)           const uint32 a = pop(); *sp = uint32(*sp) op a
+#define sbinop(op)          const int32 a = pop(); *sp = int32(*sp) op a
+#define use_params(n)       dp += n
+
+#define declare_params(n)   const byte * param = dp; \
+                            use_params(n);
+
+#define push(n)             { *++sp = n; }
+#define pop()               (*sp--)
+#define slotat(x)           (map[(x)])
+#define DIE                 { is=seg.last(); status = Machine::died_early; EXIT(1); }
+#define POSITIONED          1
+
+STARTOP(nop)
+    do {} while (0);
+ENDOP
+
+STARTOP(push_byte)
+    declare_params(1);
+    push(int8(*param));
+ENDOP
+
+STARTOP(push_byte_u)
+    declare_params(1);
+    push(uint8(*param));
+ENDOP
+
+STARTOP(push_short)
+    declare_params(2);
+    const int16 r   = int16(param[0]) << 8 
+                    | uint8(param[1]);
+    push(r);
+ENDOP
+
+STARTOP(push_short_u)
+    declare_params(2);
+    const uint16 r  = uint16(param[0]) << 8
+                    | uint8(param[1]);
+    push(r);
+ENDOP
+
+STARTOP(push_long)
+    declare_params(4);
+    const  int32 r  = int32(param[0]) << 24
+                    | uint32(param[1]) << 16
+                    | uint32(param[2]) << 8
+                    | uint8(param[3]);
+    push(r);
+ENDOP
+
+STARTOP(add)
+    binop(+);
+ENDOP
+
+STARTOP(sub)
+    binop(-);
+ENDOP
+
+STARTOP(mul)
+    binop(*);
+ENDOP
+
+STARTOP(div_)
+    if (*sp == 0) DIE;
+    sbinop(/);
+ENDOP
+
+STARTOP(min_)
+    const int32 a = pop(), b = *sp;
+    if (a < b) *sp = a;
+ENDOP
+
+STARTOP(max_)
+    const int32 a = pop(), b = *sp;
+    if (a > b) *sp = a;
+ENDOP
+
+STARTOP(neg)
+    *sp = uint32(-int32(*sp));
+ENDOP
+
+STARTOP(trunc8)
+    *sp = uint8(*sp);
+ENDOP
+
+STARTOP(trunc16)
+    *sp = uint16(*sp);
+ENDOP
+
+STARTOP(cond)
+    const uint32 f = pop(), t = pop(), c = pop();
+    push(c ? t : f);
+ENDOP
+
+STARTOP(and_)
+    binop(&&);
+ENDOP
+
+STARTOP(or_)
+    binop(||);
+ENDOP
+
+STARTOP(not_)
+    *sp = !*sp;
+ENDOP
+
+STARTOP(equal)
+    binop(==);
+ENDOP
+
+STARTOP(not_eq_)
+    binop(!=);
+ENDOP
+
+STARTOP(less)
+    sbinop(<);
+ENDOP
+
+STARTOP(gtr)
+    sbinop(>);
+ENDOP
+
+STARTOP(less_eq)
+    sbinop(<=);
+ENDOP
+
+STARTOP(gtr_eq)
+    sbinop(>=);
+ENDOP
+
+STARTOP(next)
+    if (map - &smap[0] >= int(smap.size())) DIE
+    if (is)
+    {
+        if (is == smap.highwater())
+            smap.highpassed(true);
+        is = is->next();
+    }
+    ++map;
+ENDOP
+
+STARTOP(next_n)
+    use_params(1);
+    NOT_IMPLEMENTED;
+    //declare_params(1);
+    //const size_t num = uint8(*param);
+ENDOP
+
+//STARTOP(copy_next)
+//     if (is) is = is->next();
+//     ++map;
+// ENDOP
+
+STARTOP(put_glyph_8bit_obs)
+    declare_params(1);
+    const unsigned int output_class = uint8(*param);
+    is->setGlyph(&seg, seg.getClassGlyph(output_class, 0));
+ENDOP
+
+STARTOP(put_subs_8bit_obs)
+    declare_params(3);
+    const int           slot_ref     = int8(param[0]);
+    const unsigned int  input_class  = uint8(param[1]),
+                        output_class = uint8(param[2]);
+    uint16 index;
+    slotref slot = slotat(slot_ref);
+    if (slot)
+    {
+        index = seg.findClassIndex(input_class, slot->gid());
+        is->setGlyph(&seg, seg.getClassGlyph(output_class, index));
+    }
+ENDOP
+
+STARTOP(put_copy)
+    declare_params(1);
+    const int  slot_ref = int8(*param);
+    if (is && !is->isDeleted())
+    {
+        slotref ref = slotat(slot_ref);
+        if (ref && ref != is)
+        {
+            int16 *tempUserAttrs = is->userAttrs();
+            if (is->attachedTo() || is->firstChild()) DIE
+            Slot *prev = is->prev();
+            Slot *next = is->next();
+            memcpy(tempUserAttrs, ref->userAttrs(), seg.numAttrs() * sizeof(uint16));
+            memcpy(is, ref, sizeof(Slot));
+            is->firstChild(NULL);
+            is->nextSibling(NULL);
+            is->userAttrs(tempUserAttrs);
+            is->next(next);
+            is->prev(prev);
+            if (is->attachedTo())
+                is->attachedTo()->child(is);
+        }
+        is->markCopied(false);
+        is->markDeleted(false);
+    }
+ENDOP
+
+STARTOP(insert)
+    if (smap.decMax() <= 0) DIE;
+    Slot *newSlot = seg.newSlot();
+    if (!newSlot) DIE;
+    Slot *iss = is;
+    while (iss && iss->isDeleted()) iss = iss->next();
+    if (!iss)
+    {
+        if (seg.last())
+        {
+            seg.last()->next(newSlot);
+            newSlot->prev(seg.last());
+            newSlot->before(seg.last()->before());
+            seg.last(newSlot);
+        }
+        else
+        {
+            seg.first(newSlot);
+            seg.last(newSlot);
+        }
+    }
+    else if (iss->prev())
+    {
+        iss->prev()->next(newSlot);
+        newSlot->prev(iss->prev());
+        newSlot->before(iss->prev()->after());
+    }
+    else
+    {
+        newSlot->prev(NULL);
+        newSlot->before(iss->before());
+        seg.first(newSlot);
+    }
+    newSlot->next(iss);
+    if (iss)
+    {
+        iss->prev(newSlot);
+        newSlot->originate(iss->original());
+        newSlot->after(iss->before());
+    }
+    else if (newSlot->prev())
+    {
+        newSlot->originate(newSlot->prev()->original());
+        newSlot->after(newSlot->prev()->after());
+    }
+    else
+    {
+        newSlot->originate(seg.defaultOriginal());
+    }
+    if (is == smap.highwater())
+        smap.highpassed(false);
+    is = newSlot;
+    seg.extendLength(1);
+    if (map != &smap[-1]) 
+        --map;
+ENDOP
+
+STARTOP(delete_)
+    if (!is || is->isDeleted()) DIE
+    is->markDeleted(true);
+    if (is->prev())
+        is->prev()->next(is->next());
+    else
+        seg.first(is->next());
+    
+    if (is->next())
+        is->next()->prev(is->prev());
+    else
+        seg.last(is->prev());
+    
+    if (is == smap.highwater())
+            smap.highwater(is->next());
+    if (is->prev())
+        is = is->prev();
+    seg.extendLength(-1);
+ENDOP
+
+STARTOP(assoc)
+    declare_params(1);
+    unsigned int  num = uint8(*param);
+    const int8 *  assocs = reinterpret_cast<const int8 *>(param+1);
+    use_params(num);
+    int max = -1;
+    int min = -1;
+
+    while (num-- > 0)
+    {
+        int sr = *assocs++;
+        slotref ts = slotat(sr);
+        if (ts && (min == -1 || ts->before() < min)) min = ts->before();
+        if (ts && ts->after() > max) max = ts->after();
+    }
+    if (min > -1)   // implies max > -1
+    {
+        is->before(min);
+        is->after(max);
+    }
+ENDOP
+
+STARTOP(cntxt_item)
+    // It turns out this is a cunningly disguised condition forward jump.
+    declare_params(3);    
+    const int       is_arg = int8(param[0]);
+    const size_t    iskip  = uint8(param[1]),
+                    dskip  = uint8(param[2]);
+
+    if (mapb + is_arg != map)
+    {
+        ip += iskip;
+        dp += dskip;
+        push(true);
+    }
+ENDOP
+
+STARTOP(attr_set)
+    declare_params(1);
+    const attrCode      slat = attrCode(uint8(*param));
+    const          int  val  = int(pop());
+    is->setAttr(&seg, slat, 0, val, smap);
+ENDOP
+
+STARTOP(attr_add)
+    declare_params(1);
+    const attrCode      slat = attrCode(uint8(*param));
+    const          int  val  = int(pop());
+    if ((slat == gr_slatPosX || slat == gr_slatPosY) && (flags & POSITIONED) == 0)
+    {
+        seg.positionSlots(0, *smap.begin(), *(smap.end()-1), seg.currdir());
+        flags |= POSITIONED;
+    }
+    int res = is->getAttr(&seg, slat, 0);
+    is->setAttr(&seg, slat, 0, val + res, smap);
+ENDOP
+
+STARTOP(attr_sub)
+    declare_params(1);
+    const attrCode      slat = attrCode(uint8(*param));
+    const          int  val  = int(pop());
+    if ((slat == gr_slatPosX || slat == gr_slatPosY) && (flags & POSITIONED) == 0)
+    {
+        seg.positionSlots(0, *smap.begin(), *(smap.end()-1), seg.currdir());
+        flags |= POSITIONED;
+    }
+    int res = is->getAttr(&seg, slat, 0);
+    is->setAttr(&seg, slat, 0, res - val, smap);
+ENDOP
+
+STARTOP(attr_set_slot)
+    declare_params(1);
+    const attrCode      slat = attrCode(uint8(*param));
+    const int offset = (map - smap.begin())*int(slat == gr_slatAttTo);
+    const          int  val  = int(pop())  + offset;
+    is->setAttr(&seg, slat, offset, val, smap);
+ENDOP
+
+STARTOP(iattr_set_slot)
+    declare_params(2);
+    const attrCode      slat = attrCode(uint8(param[0]));
+    const size_t        idx  = uint8(param[1]);
+    const          int  val  = int(pop())  + (map - smap.begin())*int(slat == gr_slatAttTo);
+    is->setAttr(&seg, slat, idx, val, smap);
+ENDOP
+
+STARTOP(push_slot_attr)
+    declare_params(2);
+    const attrCode      slat     = attrCode(uint8(param[0]));
+    const int           slot_ref = int8(param[1]);
+    if ((slat == gr_slatPosX || slat == gr_slatPosY) && (flags & POSITIONED) == 0)
+    {
+        seg.positionSlots(0, *smap.begin(), *(smap.end()-1), seg.currdir());
+        flags |= POSITIONED;
+    }
+    slotref slot = slotat(slot_ref);
+    if (slot)
+    {
+        int res = slot->getAttr(&seg, slat, 0);
+        push(res);
+    }
+ENDOP
+
+STARTOP(push_glyph_attr_obs)
+    declare_params(2);
+    const unsigned int  glyph_attr = uint8(param[0]);
+    const int           slot_ref   = int8(param[1]);
+    slotref slot = slotat(slot_ref);
+    if (slot)
+        push(int32(seg.glyphAttr(slot->gid(), glyph_attr)));
+ENDOP
+
+STARTOP(push_glyph_metric)
+    declare_params(3);
+    const unsigned int  glyph_attr  = uint8(param[0]);
+    const int           slot_ref    = int8(param[1]);
+    const signed int    attr_level  = uint8(param[2]);
+    slotref slot = slotat(slot_ref);
+    if (slot)
+        push(seg.getGlyphMetric(slot, glyph_attr, attr_level, dir));
+ENDOP
+
+STARTOP(push_feat)
+    declare_params(2);
+    const unsigned int  feat        = uint8(param[0]);
+    const int           slot_ref    = int8(param[1]);
+    slotref slot = slotat(slot_ref);
+    if (slot)
+    {
+        uint8 fid = seg.charinfo(slot->original())->fid();
+        push(seg.getFeature(fid, feat));
+    }
+ENDOP
+
+STARTOP(push_att_to_gattr_obs)
+    declare_params(2);
+    const unsigned int  glyph_attr  = uint8(param[0]);
+    const int           slot_ref    = int8(param[1]);
+    slotref slot = slotat(slot_ref);
+    if (slot)
+    {
+        slotref att = slot->attachedTo();
+        if (att) slot = att;
+        push(int32(seg.glyphAttr(slot->gid(), glyph_attr)));
+    }
+ENDOP
+
+STARTOP(push_att_to_glyph_metric)
+    declare_params(3);
+    const unsigned int  glyph_attr  = uint8(param[0]);
+    const int           slot_ref    = int8(param[1]);
+    const signed int    attr_level  = uint8(param[2]);
+    slotref slot = slotat(slot_ref);
+    if (slot)
+    {
+        slotref att = slot->attachedTo();
+        if (att) slot = att;
+        push(int32(seg.getGlyphMetric(slot, glyph_attr, attr_level, dir)));
+    }
+ENDOP
+
+STARTOP(push_islot_attr)
+    declare_params(3);
+    const attrCode  slat     = attrCode(uint8(param[0]));
+    const int           slot_ref = int8(param[1]),
+                        idx      = uint8(param[2]);
+    if ((slat == gr_slatPosX || slat == gr_slatPosY) && (flags & POSITIONED) == 0)
+    {
+        seg.positionSlots(0, *smap.begin(), *(smap.end()-1), seg.currdir());
+        flags |= POSITIONED;
+    }
+    slotref slot = slotat(slot_ref);
+    if (slot)
+    {
+        int res = slot->getAttr(&seg, slat, idx);
+        push(res);
+    }
+ENDOP
+
+#if 0
+STARTOP(push_iglyph_attr) // not implemented
+    NOT_IMPLEMENTED;
+ENDOP
+#endif
+      
+STARTOP(pop_ret)
+    const uint32 ret = pop();
+    EXIT(ret);
+ENDOP
+
+STARTOP(ret_zero)
+    EXIT(0);
+ENDOP
+
+STARTOP(ret_true)
+    EXIT(1);
+ENDOP
+
+STARTOP(iattr_set)
+    declare_params(2);
+    const attrCode      slat = attrCode(uint8(param[0]));
+    const size_t        idx  = uint8(param[1]);
+    const          int  val  = int(pop());
+    is->setAttr(&seg, slat, idx, val, smap);
+ENDOP
+
+STARTOP(iattr_add)
+    declare_params(2);
+    const attrCode      slat = attrCode(uint8(param[0]));
+    const size_t        idx  = uint8(param[1]);
+    const          int  val  = int(pop());
+    if ((slat == gr_slatPosX || slat == gr_slatPosY) && (flags & POSITIONED) == 0)
+    {
+        seg.positionSlots(0, *smap.begin(), *(smap.end()-1), seg.currdir());
+        flags |= POSITIONED;
+    }
+    int res = is->getAttr(&seg, slat, idx);
+    is->setAttr(&seg, slat, idx, val + res, smap);
+ENDOP
+
+STARTOP(iattr_sub)
+    declare_params(2);
+    const attrCode      slat = attrCode(uint8(param[0]));
+    const size_t        idx  = uint8(param[1]);
+    const          int  val  = int(pop());
+    if ((slat == gr_slatPosX || slat == gr_slatPosY) && (flags & POSITIONED) == 0)
+    {
+        seg.positionSlots(0, *smap.begin(), *(smap.end()-1), seg.currdir());
+        flags |= POSITIONED;
+    }
+    int res = is->getAttr(&seg, slat, idx);
+    is->setAttr(&seg, slat, idx, res - val, smap);
+ENDOP
+
+STARTOP(push_proc_state)
+    use_params(1);
+    push(1);
+ENDOP
+
+STARTOP(push_version)
+    push(0x00030000);
+ENDOP
+
+STARTOP(put_subs)
+    declare_params(5);
+    const int        slot_ref     = int8(param[0]);
+    const unsigned int  input_class  = uint8(param[1]) << 8
+                                     | uint8(param[2]);
+    const unsigned int  output_class = uint8(param[3]) << 8
+                                     | uint8(param[4]);
+    slotref slot = slotat(slot_ref);
+    if (slot)
+    {
+        int index = seg.findClassIndex(input_class, slot->gid());
+        is->setGlyph(&seg, seg.getClassGlyph(output_class, index));
+    }
+ENDOP
+
+#if 0
+STARTOP(put_subs2) // not implemented
+    NOT_IMPLEMENTED;
+ENDOP
+
+STARTOP(put_subs3) // not implemented
+    NOT_IMPLEMENTED;
+ENDOP
+#endif
+
+STARTOP(put_glyph)
+    declare_params(2);
+    const unsigned int output_class  = uint8(param[0]) << 8
+                                     | uint8(param[1]);
+    is->setGlyph(&seg, seg.getClassGlyph(output_class, 0));
+ENDOP
+
+STARTOP(push_glyph_attr)
+    declare_params(3);
+    const unsigned int  glyph_attr  = uint8(param[0]) << 8
+                                    | uint8(param[1]);
+    const int           slot_ref    = int8(param[2]);
+    slotref slot = slotat(slot_ref);
+    if (slot)
+        push(int32(seg.glyphAttr(slot->gid(), glyph_attr)));
+ENDOP
+
+STARTOP(push_att_to_glyph_attr)
+    declare_params(3);
+    const unsigned int  glyph_attr  = uint8(param[0]) << 8
+                                    | uint8(param[1]);
+    const int           slot_ref    = int8(param[2]);
+    slotref slot = slotat(slot_ref);
+    if (slot)
+    {
+        slotref att = slot->attachedTo();
+        if (att) slot = att;
+        push(int32(seg.glyphAttr(slot->gid(), glyph_attr)));
+    }
+ENDOP
+
+STARTOP(temp_copy)
+    slotref newSlot = seg.newSlot();
+    if (!newSlot || !is) DIE;
+    int16 *tempUserAttrs = newSlot->userAttrs();
+    memcpy(newSlot, is, sizeof(Slot));
+    memcpy(tempUserAttrs, is->userAttrs(), seg.numAttrs() * sizeof(uint16));
+    newSlot->userAttrs(tempUserAttrs);
+    newSlot->markCopied(true);
+    *map = newSlot;
+ENDOP
+
+STARTOP(band)
+    binop(&);
+ENDOP
+
+STARTOP(bor)
+    binop(|);
+ENDOP
+
+STARTOP(bnot)
+    *sp = ~*sp;
+ENDOP
+
+STARTOP(setbits)
+    declare_params(4);
+    const uint16 m  = uint16(param[0]) << 8
+                    | uint8(param[1]);
+    const uint16 v  = uint16(param[2]) << 8
+                    | uint8(param[3]);
+    *sp = ((*sp) & ~m) | v;
+ENDOP
+
+STARTOP(set_feat)
+    declare_params(2);
+    const unsigned int  feat        = uint8(param[0]);
+    const int           slot_ref    = int8(param[1]);
+    slotref slot = slotat(slot_ref);
+    if (slot)
+    {
+        uint8 fid = seg.charinfo(slot->original())->fid();
+        seg.setFeature(fid, feat, pop());
+    }
+ENDOP
+