Back to index

im-sdk  12.3.91
Defines | Functions
EIMILTextUtil.c File Reference
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <EIMIL.h>
#include "EIMILint.h"

Go to the source code of this file.

Defines

#define MIN(x, y)   ((x) < (y) ? (x) : (y))
#define MAX(x, y)   ((x) > (y) ? (x) : (y))
#define EIMIL_INTERVAL_OVERLAP_P(s1, e1, s2, e2)   (MIN(e1, e2) > MAX(s1, s2))
#define UTF16_S_P(v)   ((v & 0xF800) == 0xD800)
#define UTF16_HS_P(v)   ((v & 0xFC00) == 0xD800)
#define UTF16_LS_P(v)   ((v & 0xFC00) == 0xDC00)

Functions

int EIMIL_UTF32_string_len (const UTF32 *pstr)
int EIMIL_UTF32_strcmp (const UTF32 *pstr1, const UTF32 *pstr2)
int EIMIL_convert_UTF32char_to_UTF8 (UTF32 ch, UTF8 *p)
UTF8EIMIL_convert_UTF32_to_UTF8 (const UTF32 *putf32)
int EIMIL_convert_UTF8_to_UTF32char (const UTF8 *p, UTF32 *pch)
UTF32EIMIL_convert_UTF8_to_UTF32 (const UTF8 *putf8)
int EIMIL_adjust_UTF16_pos_to_UTF32 (int pos, const UTF32 *pbase, const UTF32 *pbaseend)
int EIMIL_adjust_UTF32_pos_to_UTF16 (int pos, const UTF32 *pbase, const UTF32 *pbaseend)
int EIMIL_convert_UTF32_to_UTF16 (const UTF32 *pu32, int u32len, UTF16 **ppu16, int *pu16len)
int EIMIL_convert_UTF16_to_UTF32 (const UTF16 *pu16, int u16len, UTF32 **ppu32, int *pu32len)
void EIMIL_destruct_mtext (EIMIL_mtext *pmt)
EIMIL_valueEIMIL_construct_mtext_from_UTF8 (const UTF8 *in)
EIMIL_valueEIMIL_construct_mtext_from_UTF16 (int len, const UTF16 *in)
EIMIL_valueEIMIL_construct_mtext_from_UTF32 (int len, const UTF32 *in)
EIMIL_valueEIMIL_construct_mtext_from_UTF32_char (UTF32 in)
int EIMIL_mtext_equal (EIMIL_mtext *pm1, EIMIL_mtext *pm2)
static EIMIL_mtext_propsEIMIL_find_mtext_props (EIMIL_mtext *pm, EIMIL_symbol *property_sym)
static EIMIL_mtext_propsEIMIL_prepare_mtext_props_slot (EIMIL_mtext *pm, EIMIL_symbol *property_sym)
EIMIL_valueEIMIL_find_prop_from_mtext (EIMIL_mtext *pm, EIMIL_symbol *property_sym, int pos)
EIMIL_valueEIMIL_get_prop_from_mtext (EIMIL_mtext *pm, EIMIL_symbol *property_sym, int pos)
void EIMIL_detach_prop_from_mtext (EIMIL_value *pv)
EIMIL_mtextEIMIL_add_prop_on_mtext (EIMIL_mtext *pm, EIMIL_value *pv, int st, int end)
EIMIL_mtextEIMIL_set_prop_on_mtext (EIMIL_mtext *pm, EIMIL_value *pv, int st, int end)
static EIMIL_valueEIMIL_move_prop (EIMIL_mtext *pm_target, EIMIL_value *pv, int dif, int last)
EIMIL_valueEIMIL_mtext_concat (int num, EIMIL_value **pvs)
EIMIL_valueEIMIL_mtext_substr (EIMIL_value *pv_mtext, int st, int end)
static IMPropEIMIL_prop_convert_to_IMProp (EIMIL_prop *pprop)
static EIMIL_valueEIMIL_prop_convert_IMProp (IMProp *pim)
static IMFeedbackListcreate_feedback (int size)
static void set_feedback (UTF32 *basestr, UTF32 *strend, EIMIL_prop *pprop, IMFeedbackList *pfbl)
int EIMIL_convert_mtext_to_IMText (IMText *pim, EIMIL_mtext *psrc)
static int EIMIL_add_props_of_IMText (EIMIL_mtext *pm, IMText *pim)
EIMIL_valueEIMIL_construct_mtext_from_IMText (IMText *pim)
int EIMIL_sync_mtext (EIMIL_mtext *pm, IMDifferential *pdiff)
int EIMIL_mtext_diff (EIMIL_mtext *porig, EIMIL_mtext *pnew, IMDifferential *pdiff)

Define Documentation

#define EIMIL_INTERVAL_OVERLAP_P (   s1,
  e1,
  s2,
  e2 
)    (MIN(e1, e2) > MAX(s1, s2))

Definition at line 31 of file EIMILTextUtil.c.

#define MAX (   x,
 
)    ((x) > (y) ? (x) : (y))

Definition at line 28 of file EIMILTextUtil.c.

#define MIN (   x,
 
)    ((x) < (y) ? (x) : (y))

Definition at line 25 of file EIMILTextUtil.c.

#define UTF16_HS_P (   v)    ((v & 0xFC00) == 0xD800)

Definition at line 34 of file EIMILTextUtil.c.

#define UTF16_LS_P (   v)    ((v & 0xFC00) == 0xDC00)

Definition at line 35 of file EIMILTextUtil.c.

#define UTF16_S_P (   v)    ((v & 0xF800) == 0xD800)

Definition at line 33 of file EIMILTextUtil.c.


Function Documentation

static IMFeedbackList* create_feedback ( int  size) [static]

Definition at line 1211 of file EIMILTextUtil.c.

{
    int i;
    IMFeedbackList *feedback;
    IMFeedback *fb;
    
    feedback = (IMFeedbackList *) malloc(sizeof(IMFeedbackList) * size);
    for (i = 0; i < size; i++) {
        IMFeedbackList *fbl = &feedback[i];
        fbl->count_feedbacks = 1;
       fb = (IMFeedback *) malloc(sizeof(IMFeedback) * 4);
       fbl->feedbacks = fb;
        memset(fbl->feedbacks, 0, sizeof(IMFeedback) * 4);
    }
    return feedback;
}
EIMIL_mtext* EIMIL_add_prop_on_mtext ( EIMIL_mtext pm,
EIMIL_value pv,
int  st,
int  end 
)

Definition at line 721 of file EIMILTextUtil.c.

{
    int i, n;
    EIMIL_mtext_props *pmp;
    EIMIL_value **ppv, *pv2;
    EIMIL_prop *pprop;

    ASSERT(pv->type == EIMIL_TYPE_PROP);

    pmp = EIMIL_prepare_mtext_props_slot(pm, pv->v.prop.property_sym);
    if (!pmp) return NULL;
    n = pmp->num;

    for (ppv = pmp->pprops, i = 0; i < n; ppv++, i++) {
       pv2 = *ppv;
       ASSERT(pv2->type == EIMIL_TYPE_PROP);
       pprop = &pv2->v.prop;
       ASSERT(pprop->property_sym == pmp->property_sym);
       if (EIMIL_INTERVAL_OVERLAP_P(st, end, pprop->st, pprop->end)) break;
    }
    pmp->pprops = (EIMIL_value**) realloc(pmp->pprops,
                                     sizeof(EIMIL_value*) * n + 1);
    if (!pmp->pprops) return NULL;
    ppv = pmp->pprops + i;
    if (n > i) {
       memmove(ppv + 1, ppv, sizeof(EIMIL_value*) * (n - i));
    }
    *ppv = pv;
    pmp->num++;
    pv->v.prop.st = st;
    pv->v.prop.end = end;
    pv->v.prop.target = pm;
    EIMIL_ADDREF(*pv);

    return pm;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int EIMIL_add_props_of_IMText ( EIMIL_mtext pm,
IMText pim 
) [static]

Definition at line 1356 of file EIMILTextUtil.c.

{
    int i, j;
    int mst, mend;
    EIMIL_value *pv;
    IMAnnotation *pima;
    IMAnnotationValue *pimav;

    for (pima = pim->annotations, i = 0;
        i < pim->count_annotations;
        pima++, i++) {
       for (pimav = pima->values, j = 0;
            j < pima->num_values;
            pimav++, j++) {
           pv = EIMIL_prop_convert_IMProp((IMProp*)pimav->value);
           mst = EIMIL_adjust_UTF16_pos_to_UTF32(pimav->start_pos,
                                            pm->ustr,
                                            pm->ustr + pm->len);
           if (mst < 0) return 0;
           mend = EIMIL_adjust_UTF16_pos_to_UTF32(pimav->end_pos,
                                             pm->ustr,
                                             pm->ustr + pm->len);
           if (mend < 0) return 0;
           if (!EIMIL_add_prop_on_mtext(pm, pv, mst, mend)) return 0;
       }
    }

    return 1;
       
}

Here is the call graph for this function:

Here is the caller graph for this function:

int EIMIL_adjust_UTF16_pos_to_UTF32 ( int  pos,
const UTF32 pbase,
const UTF32 pbaseend 
)

Definition at line 269 of file EIMILTextUtil.c.

{
    int i, npos;

    for (i = 0, npos = 0;i < pos;npos++, pbase++) {
       if (pbase >= pbaseend) return -1;
       if (*pbase < 0x10000) {
           i++;
       }else{
           i += 2;
       }
    }
    return npos;
}

Here is the caller graph for this function:

int EIMIL_adjust_UTF32_pos_to_UTF16 ( int  pos,
const UTF32 pbase,
const UTF32 pbaseend 
)

Definition at line 289 of file EIMILTextUtil.c.

{
    const UTF32 *pe;
    int npos;

    pe = pbase + pos;
    for (npos = 0;pbase < pe;pbase++) {
       if (pbase >= pbaseend) return -1;
       if (*pbase < 0x10000) {
           npos++;
       }else{
           npos += 2;
       }
    }
    return npos;
}

Here is the caller graph for this function:

Definition at line 1391 of file EIMILTextUtil.c.

{
    EIMIL_value *pv;

    pv = EIMIL_construct_mtext_from_UTF16(pim->char_length, pim->text.utf_chars);
    if (!pv) return NULL;
    if (!EIMIL_add_props_of_IMText(&pv->v.mtext, pim)) return NULL;

    return pv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

EIMIL_value* EIMIL_construct_mtext_from_UTF16 ( int  len,
const UTF16 in 
)

Definition at line 463 of file EIMILTextUtil.c.

{
    EIMIL_value *pv;
    EIMIL_mtext *pm;

    pv = (EIMIL_value*) malloc(sizeof(EIMIL_value));
    if (!pv) return NULL;
    memset(pv, 0, sizeof(EIMIL_value));
    pv->type = EIMIL_TYPE_MTEXT;
    pm = &pv->v.mtext;
    if (!EIMIL_convert_UTF16_to_UTF32(in, len, &pm->ustr, &pm->len))
       return NULL;
    pm->slotsnum = 0;
    pm->pslots = NULL;
    pm->UIdatap = 0;

    return pv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

EIMIL_value* EIMIL_construct_mtext_from_UTF32 ( int  len,
const UTF32 in 
)

Definition at line 486 of file EIMILTextUtil.c.

{
    int i;
    UTF32 *pu;
    EIMIL_value *pv;
    EIMIL_mtext *pm;

    pv = (EIMIL_value*) malloc(sizeof(EIMIL_value));
    if (!pv) return NULL;
    memset(pv, 0, sizeof(EIMIL_value));
    pv->type = EIMIL_TYPE_MTEXT;
    pm = &pv->v.mtext;
    pu = (UTF32*) malloc(sizeof(UTF32) * (len + 1));
    if (!pu) {
       free(pm);
       return NULL;
    }
    pm->len = len;
    pm->slotsnum = 0;
    pm->pslots = NULL;
    pm->UIdatap = 0;
    pm->ustr = pu;

    for (i = 0; i < len; i++) *pu++ = *in++;
    *pu = 0;

    return pv;
}

Here is the caller graph for this function:

Definition at line 519 of file EIMILTextUtil.c.

{
    UTF32 *pu;
    EIMIL_value *pv;
    EIMIL_mtext *pm;

    pv = (EIMIL_value*) malloc(sizeof(EIMIL_value));
    if (!pv) return NULL;
    memset(pv, 0, sizeof(EIMIL_value));
    pv->type = EIMIL_TYPE_MTEXT;
    pm = &pv->v.mtext;
    pu = (UTF32*) malloc(sizeof(UTF32) * 2);
    if (!pu) {
       free(pm);
       return NULL;
    }
    pm->len = 1;
    pm->slotsnum = 0;
    pm->pslots = NULL;
    pm->UIdatap = 0;
    pm->ustr = pu;
    *pu = in;
    pu[1] = 0;

    return pv;
}

Definition at line 436 of file EIMILTextUtil.c.

{
    UTF32 *pu;
    EIMIL_value *pv;
    EIMIL_mtext *pm;

    pv = (EIMIL_value*) malloc(sizeof(EIMIL_value));
    if (!pv) return NULL;
    memset(pv, 0, sizeof(EIMIL_value));
    pv->type = EIMIL_TYPE_MTEXT;
    pm = &pv->v.mtext;
    if (!(pu = EIMIL_convert_UTF8_to_UTF32(in))) {
       free(pm);
       return NULL;
    }
    pm->len = EIMIL_UTF32_string_len(pu);
    pm->slotsnum = 0;
    pm->pslots = NULL;
    pm->UIdatap = 0;
    pm->ustr = pu;

    return pv;
}

Here is the call graph for this function:

int EIMIL_convert_mtext_to_IMText ( IMText pim,
EIMIL_mtext psrc 
)

Definition at line 1260 of file EIMILTextUtil.c.

{
    int i, j;
    EIMIL_value **ppv, *pv;
    EIMIL_mtext_props *pmp;
    EIMIL_prop *pprop;

    IMAnnotation *pima;
    IMAnnotationValue *pimav;
    IMProp *pimp;

    memset(pim, 0, sizeof(IMText));
    pim->encoding = UTF16_CODESET;
    pim->count_annotations = psrc->slotsnum;
    pima = (IMAnnotation*) malloc(sizeof(IMAnnotation)
                              * pim->count_annotations);
    pim->annotations = pima;
    if (!pima) {
       free(pim);
       return 0;
    }
    /* UTF16 string */
    if (!EIMIL_convert_UTF32_to_UTF16(psrc->ustr, psrc->len,
                                  &pim->text.utf_chars,
                                  &pim->char_length)) {
       free(pim->annotations);
       free(pim);
       return 0;
    }

    pim->feedback = create_feedback(pim->char_length);
    if (!pim->feedback) {
       free(pim->text.utf_chars);
       free(pim->annotations);
       free(pim);
       return 0;
    }
    /* feedback & annotation */
    for (pmp = psrc->pslots, i = 0;
        i < psrc->slotsnum;
        pmp++, pima++, i++) {
       pima->type = pmp->property_sym->symbolid;

       if (pima->type == EIMIL_SYMBOL_ID_FEEDBACK) {
           for (ppv = pmp->pprops, j = 0;
               j < pmp->num;
               ppv++, pimav++, j++) {
              pv = *ppv;
              ASSERT(pv->type == EIMIL_TYPE_PROP);
              pprop = &pv->v.prop;
              set_feedback(psrc->ustr, psrc->ustr + psrc->len,
                          pprop, pim->feedback);
           }
       }

       pima->num_values = pmp->num;
       pimav = (IMAnnotationValue*) malloc(sizeof(IMAnnotationValue) * pmp->num);
       if (!pimav) {
           free(pim->annotations);
           free(pim);
           return 0;
       }
       pima->values = pimav;
       for (ppv = pmp->pprops, j = 0;
            j < pmp->num;
            ppv++, pimav++, j++) {
           pv = *ppv;
           ASSERT(pv->type == EIMIL_TYPE_PROP);
           pprop = &pv->v.prop;
           pimav->start_pos = EIMIL_adjust_UTF32_pos_to_UTF16(pprop->st,
                                                        psrc->ustr,
                                                        psrc->ustr
                                                        + psrc->len);
           ASSERT(pimav->start_pos >= 0);
           pimav->end_pos = EIMIL_adjust_UTF32_pos_to_UTF16(pprop->end,
                                                      psrc->ustr,
                                                      psrc->ustr
                                                      + psrc->len);
           ASSERT(pimav->end_pos >= 0);
           pimav->len = -1;
           pimp = EIMIL_prop_convert_to_IMProp(pprop);
           if (!pimp) {
              free(pim->annotations);
              free(pim);
              return 0;
           }
       }
    }

    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int EIMIL_convert_UTF16_to_UTF32 ( const UTF16 pu16,
int  u16len,
UTF32 **  ppu32,
int *  pu32len 
)

Definition at line 352 of file EIMILTextUtil.c.

{
    int i, rlen;
    UTF16 hs1, hs2;
    UTF32 *pr, *prh;

    prh = (UTF32*) malloc(sizeof(UTF32) * (u16len + 1));
    if (!prh) return 0;
    pr = prh;

    for (i = 0; i < u16len;) {
       hs1 = *pu16++;
       i++;
       if (UTF16_HS_P(hs1)) {
           hs2 = *pu16++;
           i++;
           if (i > u16len) {
              /* Invalid code.
                 TODO:We should output error.  */
              break;
           }
           if (UTF16_LS_P(hs2)) {
              *pr++ = (((hs1 & 0x3FF) << 10) | (hs2 & 0x3FF)) + 0x10000;
           }else{
              /* Invalid code.
                 TODO:We should output error.  */
              *pr++ = hs2;
           }
       }else{
           *pr++ = hs1;
       }
    }
    rlen = pr - prh;
    if (rlen != u16len)
       prh = (UTF32*) realloc(prh, sizeof(UTF32) * (rlen + 1));
    *pr = 0;
    *pu32len = rlen;
    *ppu32 = prh;
       
    return 1;
}

Here is the caller graph for this function:

int EIMIL_convert_UTF32_to_UTF16 ( const UTF32 pu32,
int  u32len,
UTF16 **  ppu16,
int *  pu16len 
)

Definition at line 311 of file EIMILTextUtil.c.

{
    int i, rlen;
    UTF32 u32;
    UTF16 *pr, *prh;

    prh = (UTF16*) malloc(sizeof(UTF16) * (u32len * 2 + 1));
    if (!prh) return 0;
    pr = prh;

    for (i = 0; i < u32len; i++) {
       u32 = *pu32++;
       if (UTF16_S_P(u32)) {
           /* invalid code.
              TODO:We should output error.  */
       }else if (u32 < 0x10000) {
           *pr++ = (UTF16) u32;
       }else if (u32 < 0x110000) {
           u32 -= 0x10000;
           *pr++ = ((u32 >> 10) | 0xD800);
           *pr++ = ((u32 & 0x3FF) | 0xDC00);
       }else{
           /* invalid code.
              TODO:We should output error.  */
       }
    }
    *pr = 0;
    rlen = pr - prh;
    prh = (UTF16*) realloc(prh, sizeof(UTF16) * (rlen + 1));
    *pu16len = rlen;
    *ppu16 = prh;

    return 1;
}

Here is the caller graph for this function:

UTF8* EIMIL_convert_UTF32_to_UTF8 ( const UTF32 putf32)

Definition at line 107 of file EIMILTextUtil.c.

{
    int n;
    const UTF32 *pu32;
    UTF8 *ps, *p;

    for (n = 0, pu32 = putf32; *pu32; pu32++) {
       if (*pu32 < 0x80) n++;
       else if (*pu32 < 0x800) n += 2;
       else if (*pu32 < 0x10000) n += 3;
       else if (*pu32 < 0x200000) n += 4;
       else if (*pu32 < 0x4000000) n += 5;
       else n += 6;
    }

    ps = p = (UTF8*) malloc(sizeof(UTF8) * (n + 1));
    if (!ps) return NULL;

    for (; *putf32; putf32++) {
       if (*putf32 < 0x80) {
           *p++ = *putf32;
       } else if (*putf32 < 0x800) {
           *p++ = (*putf32 >> 6) | 0xC0;
           *p++ = (*putf32 & 0x3F) | 0x80;
       } else if (*putf32 < 0x10000) {
           *p++ = (*putf32 >> 12) | 0xE0;
           *p++ = ((*putf32 >> 6) & 0x3F) | 0x80;
           *p++ = (*putf32 & 0x3F) | 0x80;
       } else if (*putf32 < 0x200000) {
           *p++ = (*putf32 >> 18) | 0xF0;
           *p++ = ((*putf32 >> 12) & 0x3F) | 0x80;
           *p++ = ((*putf32 >> 6) & 0x3F) | 0x80;
           *p++ = (*putf32 & 0x3F) | 0x80;
       } else if (*putf32 < 0x4000000) {
           /* actually, UTF-32 forbids the area over 0x10FFFF. */
           *p++ = (*putf32 >> 24) | 0xF8;
           *p++ = ((*putf32 >> 18) & 0x3F) | 0x80;
           *p++ = ((*putf32 >> 12) & 0x3F) | 0x80;
           *p++ = ((*putf32 >> 6) & 0x3F) | 0x80;
           *p++ = (*putf32 & 0x3F) | 0x80;
       } else {
           /* actually, UTF-32 forbids the area over 0x10FFFF. */
           *p++ = ((*putf32 >> 30) & 0x1) | 0xFC;
           *p++ = ((*putf32 >> 24) & 0x3F) | 0x80;
           *p++ = ((*putf32 >> 18) & 0x3F) | 0x80;
           *p++ = ((*putf32 >> 12) & 0x3F) | 0x80;
           *p++ = ((*putf32 >> 6) & 0x3F) | 0x80;
           *p++ = (*putf32 & 0x3F) | 0x80;
       }
    }
    *p = 0;
    return ps;
}

Here is the caller graph for this function:

Definition at line 62 of file EIMILTextUtil.c.

{
    if (ch < 0x80) {
       *p++ = ch;
       return 1;
    } else if (ch < 0x800) {
       *p++ = (ch >> 6) | 0xC0;
       *p++ = (ch & 0x3F) | 0x80;
       return 2;
    } else if (ch < 0x10000) {
       *p++ = (ch >> 12) | 0xE0;
       *p++ = ((ch >> 6) & 0x3F) | 0x80;
       *p++ = (ch & 0x3F) | 0x80;
       return 3;
    } else if (ch < 0x200000) {
       *p++ = (ch >> 18) | 0xF0;
       *p++ = ((ch >> 12) & 0x3F) | 0x80;
       *p++ = ((ch >> 6) & 0x3F) | 0x80;
       *p++ = (ch & 0x3F) | 0x80;
       return 4;
    } else if (ch < 0x4000000) {
       /* actually, UTF-32 forbids the area over 0x10FFFF. */
       *p++ = (ch >> 24) | 0xF8;
       *p++ = ((ch >> 18) & 0x3F) | 0x80;
       *p++ = ((ch >> 12) & 0x3F) | 0x80;
       *p++ = ((ch >> 6) & 0x3F) | 0x80;
       *p++ = (ch & 0x3F) | 0x80;
       return 5;
    } else {
       /* actually, UTF-32 forbids the area over 0x10FFFF. */
       *p++ = ((ch >> 30) & 0x1) | 0xFC;
       *p++ = ((ch >> 24) & 0x3F) | 0x80;
       *p++ = ((ch >> 18) & 0x3F) | 0x80;
       *p++ = ((ch >> 12) & 0x3F) | 0x80;
       *p++ = ((ch >> 6) & 0x3F) | 0x80;
       *p++ = (ch & 0x3F) | 0x80;
       return 6;
    }
    return 0;
}

Here is the caller graph for this function:

UTF32* EIMIL_convert_UTF8_to_UTF32 ( const UTF8 putf8)

Definition at line 209 of file EIMILTextUtil.c.

{
    int n;
    const UTF8 *pu8;
    UTF32 *ps, *p;

    for (n = 0, pu8 = putf8; *pu8; n++) {
       if (*pu8 < 0x80) pu8++;
       else if (*pu8 < 0xE0) pu8 += 2;
       else if (*pu8 < 0xF0) pu8 += 3;
       else if (*pu8 < 0xF8) pu8 += 4;
       else if (*pu8 < 0xFC) pu8 += 5;
       else pu8 += 6;
    }

    ps = p = (UTF32*) malloc(sizeof(UTF32) * (n + 1));
    if (!ps) return NULL;

    while (*putf8) {
       if (*putf8 < 0x80) {
           *p++ = *putf8++;
       } else if (*putf8 < 0xE0) {
           *p++ = (((putf8[0] & 0x1F) << 6)
                  | (putf8[1] & 0x3F));
           putf8 += 2;
       } else if (*putf8 < 0xF0) {
           *p++ = (((putf8[0] & 0x0F) << 12)
                  | ((putf8[1] & 0x3F) << 6)
                  | (putf8[2] & 0x3F));
           putf8 += 3;
       } else if (*putf8 < 0xF8) {
           *p++ = (((putf8[0] & 0x07) << 18)
                  | ((putf8[1] & 0x3F) << 12)
                  | ((putf8[2] & 0x3F) << 6)
                  | (putf8[3] & 0x3F));
           putf8 += 4;
       } else if (*putf8 < 0xFC) {
           *p++ = (((putf8[0] & 0x03) << 24)
                  | ((putf8[1] & 0x3F) << 18)
                  | ((putf8[2] & 0x3F) << 12)
                  | ((putf8[3] & 0x3F) << 6)
                  | (putf8[4] & 0x3F));
           putf8 += 5;
       } else {
           *p++ = (((putf8[0] & 0x01) << 30)
                  | ((putf8[1] & 0x3F) << 24)
                  | ((putf8[2] & 0x3F) << 18)
                  | ((putf8[3] & 0x3F) << 12)
                  | ((putf8[4] & 0x3F) << 6)
                  | (putf8[5] & 0x3F));
           putf8 += 6;
       }
    }
    *p = 0;
    return ps;
}

Here is the caller graph for this function:

int EIMIL_convert_UTF8_to_UTF32char ( const UTF8 p,
UTF32 pch 
)

Definition at line 164 of file EIMILTextUtil.c.

{
    if (!p) return 0;

    if (*p < 0x80) {
       if (pch) *pch = *p;
       return 1;
    } else if (*p < 0xE0) {
       if (pch) *pch = (((p[0] & 0x1F) << 6)
              | (p[1] & 0x3F));
       return 2;
    } else if (*p < 0xF0) {
       if (pch) *pch = (((p[0] & 0x0F) << 12)
              | ((p[1] & 0x3F) << 6)
              | (p[2] & 0x3F));
       return 3;
    } else if (*p < 0xF8) {
       if (pch) *pch = (((p[0] & 0x07) << 18)
              | ((p[1] & 0x3F) << 12)
              | ((p[2] & 0x3F) << 6)
              | (p[3] & 0x3F));
       return 4;
    } else if (*p < 0xFC) {
       if (pch) *pch = (((p[0] & 0x03) << 24)
              | ((p[1] & 0x3F) << 18)
              | ((p[2] & 0x3F) << 12)
              | ((p[3] & 0x3F) << 6)
              | (p[4] & 0x3F));
       return 5;
    } else {
       if (pch) *pch = (((p[0] & 0x01) << 30)
              | ((p[1] & 0x3F) << 24)
              | ((p[2] & 0x3F) << 18)
              | ((p[3] & 0x3F) << 12)
              | ((p[4] & 0x3F) << 6)
              | (p[5] & 0x3F));
       return 6;
    }
    return 0;
}

Here is the caller graph for this function:

Definition at line 400 of file EIMILTextUtil.c.

{
    int i, j;
    EIMIL_mtext_props *pmp;
    EIMIL_value **ppv;
    EIMIL_prop *pprop;


    if (pmt->pslots) {
       for (pmp = pmt->pslots, i = 0;
            i < pmt->slotsnum;
            i++, pmp++) {
           if (pmp->pprops) {
              for (ppv = pmp->pprops, j = 0;
                   j < pmp->num;
                   j++, ppv++) {
                  ASSERT((*ppv)->type == EIMIL_TYPE_PROP);
                  pprop = &(*ppv)->v.prop;
                  ASSERT(pprop->target == pmt);
                  pprop->st = pprop->end = -1;
                  pprop->target = NULL;
                  EIMIL_RMREF(**ppv);
              }
              free(pmp->pprops);
           }
       }
       free(pmt->pslots);
    }
    if (pmt->ustr) free(pmt->ustr);

    return;
}

Here is the caller graph for this function:

Definition at line 667 of file EIMILTextUtil.c.

{
    int i, n;
    EIMIL_mtext *pmt;
    EIMIL_mtext_props *pmp;
    EIMIL_value **ppv;
    EIMIL_prop *pprop;

    ASSERT(pv->type == EIMIL_TYPE_PROP);

    pprop = &pv->v.prop;
    pmt = pprop->target;
       
    if (!pmt) return;

    pmp = EIMIL_find_mtext_props(pmt, pprop->property_sym);
    ASSERT(pmp);
    n = pmp->num;

    for (ppv = pmp->pprops, i = 0; i < pmp->num; ppv++, i++) {
       if (*ppv == pv) {
           pmp->num--;
           if ((n - i - 1) > 0) {
              memmove(ppv, ppv + 1, sizeof(EIMIL_value*) * (n - i - 1));
           }
           pprop->st = pprop->end = -1;
           pprop->target = NULL;
           EIMIL_RMREF(*pv);
           return;
       }
    }
    /* not reached */
    abort();

    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static EIMIL_mtext_props* EIMIL_find_mtext_props ( EIMIL_mtext pm,
EIMIL_symbol property_sym 
) [static]

Definition at line 559 of file EIMILTextUtil.c.

{
    int i, n;
    EIMIL_mtext_props *pmp;

    n = pm->slotsnum;
    for (pmp = pm->pslots, i = 0; i < n; i++, pmp++) {
       if (pmp->property_sym == property_sym) break;
    }
    if (i == n) return NULL;

    return pmp;
}

Here is the caller graph for this function:

EIMIL_value* EIMIL_find_prop_from_mtext ( EIMIL_mtext pm,
EIMIL_symbol property_sym,
int  pos 
)

Definition at line 600 of file EIMILTextUtil.c.

{
    int i, n;
    int minpos, minpos_idx;
    EIMIL_mtext_props *pmp;
    EIMIL_value **ppv, *pv;
    EIMIL_prop *pprop;

    minpos_idx = -1;

    pmp = EIMIL_find_mtext_props(pm, property_sym);
    if (!pmp) return NULL;

    n = pmp->num;
    for (ppv = pmp->pprops, i = 0; i < n; ppv++, i++) {
       pv = *ppv;
       ASSERT(pv->type == EIMIL_TYPE_PROP);
       pprop = &pv->v.prop;
       ASSERT(pprop->property_sym == property_sym);
       if ((pprop->st <= pos)
           && (pprop->end > pos))
           return pv;
       if ((pprop->st > pos)
           && ((minpos_idx < 0) || (minpos > pprop->st))) {
           minpos_idx = i;
           minpos = pprop->st;
       }
    }
    if (minpos_idx > 0)
       return pmp->pprops[minpos_idx];

    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

EIMIL_value* EIMIL_get_prop_from_mtext ( EIMIL_mtext pm,
EIMIL_symbol property_sym,
int  pos 
)

Definition at line 638 of file EIMILTextUtil.c.

{
    int i, n;
    EIMIL_mtext_props *pmp;
    EIMIL_value **ppv, *pv;
    EIMIL_prop *pprop;

    pmp = EIMIL_find_mtext_props(pm, property_sym);
    if (!pmp) return NULL;

    n = pmp->num;
    for (ppv = pmp->pprops, i = 0; i < n; ppv++, i++) {
       pv = *ppv;
       ASSERT(pv->type == EIMIL_TYPE_PROP);
       pprop = &pv->v.prop;
       ASSERT(pprop->property_sym == property_sym);
       if ((pprop->st <= pos)
           && (pprop->end > pos))
           return pv;
    }

    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static EIMIL_value* EIMIL_move_prop ( EIMIL_mtext pm_target,
EIMIL_value pv,
int  dif,
int  last 
) [static]

Definition at line 885 of file EIMILTextUtil.c.

{
    int st, end;
    EIMIL_value *pv2;
    ASSERT(pv->type == EIMIL_TYPE_PROP);

    pv2 = EIMIL_copy_value(pv);
    if (!pv2) return NULL;
    st = pv->v.prop.st;
    end = pv->v.prop.end;
    st += dif;
    end += dif;
    if (st < 0) st = 0;
    if (end > last) end = last;

    ASSERT((st < end) && (st >= 0) && (end <= last));

    pv2->v.prop.st = st;
    pv2->v.prop.end = end;

    pv2->v.prop.target = pm_target;
    EIMIL_ADDREF(*pv2);

    return pv2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

EIMIL_value* EIMIL_mtext_concat ( int  num,
EIMIL_value **  pvs 
)

Definition at line 917 of file EIMILTextUtil.c.

{
    int i, j, k;
    int clen, pos;
    EIMIL_mtext *pm, *pmr;
    EIMIL_value **pvs2, *pvr;

    EIMIL_value **ppv;
    EIMIL_mtext_props *pmp, *pmp2;
    UTF32 *pu;

    pvr = (EIMIL_value*) malloc(sizeof(EIMIL_value));
    if (!pvr) return NULL;
    memset(pvr, 0, sizeof(EIMIL_value));
    pvr->type = EIMIL_TYPE_MTEXT;
    pmr = &pvr->v.mtext;

    pmp2 = NULL;
    pos = 0;
    for (pvs2 = pvs, i = 0; i < num; pvs2++, i++) {
       if ((*pvs2)->type == EIMIL_TYPE_MTEXT) {
           pm = &((*pvs2)->v.mtext);
           clen = pm->len;
           for (pmp = pm->pslots, j = 0; j < pm->slotsnum; pmp++, j++) {
              pmp2 = EIMIL_prepare_mtext_props_slot(pmr, pmp->property_sym);
              if (!pmp2) goto error;
              pmp2->pprops = realloc(pmp2->pprops,
                                   sizeof(EIMIL_value*)
                                   * (pmp2->num + pmp->num));
              if (!pmp2->pprops) goto error;
              ppv = pmp2->pprops + pmp2->num;
              for (k = 0; k < pmp->num; k++) {
                  *ppv = EIMIL_move_prop(pmr, pmp->pprops[k],
                                      pos, pos + clen);
                  if (!*ppv) goto error;
                  ppv++;
              }
              pmp2->num += pmp->num;
           }
           pos += pm->len;
       } else if ((*pvs2)->type == EIMIL_TYPE_CHAR) {
           pos++;
       } else {
           ERROR_INTERNAL("Invalid type(must be mtext or char).");
       }
    }
    pmr->len = pos;
    pu = (UTF32*) malloc(sizeof(UTF32) * (pos + 1));
    if (!pu) goto error;
    pmr->ustr = pu;

    for (pvs2 = pvs, i = 0; i < num; pvs2++, i++) {
       if ((*pvs2)->type == EIMIL_TYPE_MTEXT) {
           pm = &((*pvs2)->v.mtext);
           memcpy(pu, pm->ustr, sizeof(UTF32) * pm->len);
           pu += pm->len;
       } else {
           /* EIMIL_TYPE_CHAR */
           *pu++ = (*pvs2)->v.ch;
       }
    }
    *pu = 0;

    return pvr;

error:
    EIMIL_destruct_value(pvr);
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int EIMIL_mtext_diff ( EIMIL_mtext porig,
EIMIL_mtext pnew,
IMDifferential pdiff 
)

Definition at line 1533 of file EIMILTextUtil.c.

{
    /* TODO: make it more efficient!!! */
    if (!EIMIL_convert_mtext_to_IMText(&pdiff->text, pnew)) return 0;
    pdiff->chg_first = 0;
    pdiff->chg_len = 0;

    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int EIMIL_mtext_equal ( EIMIL_mtext pm1,
EIMIL_mtext pm2 
)

Definition at line 549 of file EIMILTextUtil.c.

{
    /* TODO!! */
    return 0;
}
EIMIL_value* EIMIL_mtext_substr ( EIMIL_value pv_mtext,
int  st,
int  end 
)

Definition at line 991 of file EIMILTextUtil.c.

{
    int i, j, len, num_props;
    int mst, mend;
    EIMIL_mtext *pm, *pmr;
    EIMIL_mtext_props *pmp, *pmp2;
    EIMIL_value **ppv, **ppv2, *pv, *pvr;
    UTF32 *pu;


    ASSERT(end > st);

    pm = &pv_mtext->v.mtext;

    if (st >= pm->len) return NULL;
    if (end > pm->len) end = pm->len;

    pvr = (EIMIL_value*) malloc(sizeof(EIMIL_value));
    if (!pvr) return NULL;
    memset(pvr, 0, sizeof(EIMIL_value));
    pvr->type = EIMIL_TYPE_MTEXT;
    pmr = &pvr->v.mtext;

    len = end - st;
    pmr->len = len;

    pu = (UTF32*) malloc(sizeof(UTF32) * (len + 1));
    if (!pu) {
       free(pmr);
       return NULL;
    }
    pmr->ustr = pu;
    memcpy(pu, pm->ustr + st, sizeof(UTF32) * len);
    pu[len] = 0;

    for (pmp = pm->pslots, i = 0; i < pm->slotsnum; pmp++, i++) {
       pmp2 = EIMIL_prepare_mtext_props_slot(pmr, pmp->property_sym);
       if (!pmp2) goto error;
       num_props = 0;
       ppv2 = (EIMIL_value**) malloc(sizeof(EIMIL_value*) * pmp->num);
       pmp2->pprops = ppv2;
       for (ppv = pmp->pprops, j = 0; j < pmp->num; ppv++, j++) {
           pv = *ppv;
           mst = pv->v.prop.st;
           mend = pv->v.prop.end;
           if (EIMIL_INTERVAL_OVERLAP_P(st, end, mst, mend)) {
              *ppv2 = EIMIL_move_prop(pmr, pv, -st, len);
              if (!*ppv2) goto error;
              ppv2++;
              num_props++;
           }
       }
       if (num_props > 0) {
           pmp2->pprops = (EIMIL_value**) realloc(pmp2->pprops,
                                             sizeof(EIMIL_value*) * num_props);
           if (!pmp2->pprops) goto error;
       } else {
           free(pmp2->pprops);
           pmp2->pprops = NULL;
       }
       pmp2->num = num_props;
    }

    return pvr;

error:
    EIMIL_destruct_mtext(pmr);
    free(pmr);
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static EIMIL_mtext_props* EIMIL_prepare_mtext_props_slot ( EIMIL_mtext pm,
EIMIL_symbol property_sym 
) [static]

Definition at line 577 of file EIMILTextUtil.c.

{
    int n;
    EIMIL_mtext_props *pmp;

    pmp = EIMIL_find_mtext_props(pm, property_sym);
    if (pmp) return pmp;
    n = pm->slotsnum;
    pm->slotsnum++;
    pm->pslots = realloc(pm->pslots, sizeof(EIMIL_mtext_props) * pm->slotsnum);
    if (!pm->pslots) return NULL;
    pmp = pm->pslots + n;
    pmp->num = 0;
    pmp->property_sym = property_sym;
    pmp->pprops = NULL;

    return pmp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static EIMIL_value* EIMIL_prop_convert_IMProp ( IMProp pim) [static]

Definition at line 1155 of file EIMILTextUtil.c.

{
    int i;
    EIMIL_value *pv, *pv2;
    EIMIL_prop *pprop;

    switch(pim->type) {
      case IM_SYMBOL_PROPERTY_NUMBER:
       pv = EIMIL_construct_prop2(EIMIL_TYPE_NUMBER);
       if (!pv) return NULL;
       pprop = &pv->v.prop;
       for (i = 0; i < pim->count; i++) {
          pv2 = EIMIL_construct_number(pim->vals.numbers[i]);
          if (!pv2) return NULL;
          if (!EIMIL_add_prop(pprop, pv2)) return NULL;
       }
       break;
      case IM_SYMBOL_PROPERTY_BOOL:
       pv = EIMIL_construct_prop2(EIMIL_TYPE_BOOL);
       if (!pv) return NULL;
       pprop = &pv->v.prop;
       for (i = 0; i < pim->count; i++) {
          pv2 = EIMIL_construct_bool(pim->vals.bools[i]);
          if (!pv2) return NULL;
          if (!EIMIL_add_prop(pprop, pv2)) return NULL;
       }
       break;
      case IM_SYMBOL_PROPERTY_CHAR:
       pv = EIMIL_construct_prop2(EIMIL_TYPE_CHAR);
       if (!pv) return NULL;
       pprop = &pv->v.prop;
       for (i = 0; i < pim->count; i++) {
          pv2 = EIMIL_construct_char(pim->vals.chars[i]);
          if (!pv2) return NULL;
          if (!EIMIL_add_prop(pprop, pv2)) return NULL;
       }
       break;
      case IM_SYMBOL_PROPERTY_MTEXT:
       pv = EIMIL_construct_prop2(EIMIL_TYPE_MTEXT);
       if (!pv) return NULL;
       pprop = &pv->v.prop;
       for (i = 0; i < pim->count; i++) {
          pv2 = EIMIL_construct_mtext_from_IMText(&pim->vals.mtexts[i]);
          if (!pv2) return NULL;
          if (!EIMIL_add_prop(pprop, pv2)) return NULL;
       }
      default:
       abort();
    }

    return pv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static IMProp* EIMIL_prop_convert_to_IMProp ( EIMIL_prop pprop) [static]

Definition at line 1071 of file EIMILTextUtil.c.

{
    int i;
    IMProp *pim;
    EIMIL_value **ppv, *pv;

    pim = (IMProp*) malloc(sizeof(IMProp));
       
    pim->count = pprop->size;
    switch(pprop->type) {
      case EIMIL_TYPE_NUMBER:
      {
         int *pnums;

         pim->type = IM_SYMBOL_PROPERTY_NUMBER;
         pnums = (int*) malloc(sizeof(int) * pim->count);
         pim->vals.numbers = pnums;
         if (!pnums) return NULL;
         for (ppv = pprop->pvals, i = 0; i < pim->count; ppv++, i++) {
             pv = *ppv;
             ASSERT(pv->type == EIMIL_TYPE_NUMBER);
             pnums[i] = pv->v.number;
         }
         break;
      }

      case EIMIL_TYPE_BOOL:
      {
         int *pbools;

         pim->type = IM_SYMBOL_PROPERTY_BOOL;
         pbools = (int*) malloc(sizeof(int) * pim->count);
         pim->vals.bools = pbools;
         if (!pbools) return NULL;
         for (ppv = pprop->pvals, i = 0; i < pim->count; ppv++, i++) {
             pv = *ppv;
             ASSERT(pv->type == EIMIL_TYPE_BOOL);
             pbools[i] = pv->v.bool_val;
         }
         break;
      }
      case EIMIL_TYPE_CHAR:
      {
         CARD32BIT *pchars;

         pim->type = IM_SYMBOL_PROPERTY_CHAR;
         pchars = (CARD32BIT*) malloc(sizeof(CARD32BIT) * pim->count);
         pim->vals.chars = pchars;
         if (!pchars) return NULL;
         for (ppv = pprop->pvals, i = 0; i < pim->count; ppv++, i++) {
             pv = *ppv;
             ASSERT(pv->type == EIMIL_TYPE_CHAR);
             pchars[i] = pv->v.ch;
         }
         break;
      }
      case EIMIL_TYPE_MTEXT:
      {
         IMText *ptexts;

         pim->type = IM_SYMBOL_PROPERTY_MTEXT;
         ptexts = (IMText*) malloc(sizeof(IMText) * pim->count);
         pim->vals.mtexts = ptexts;
         if (!ptexts) return NULL;
         for (ppv = pprop->pvals, i = 0; i < pim->count; ppv++, i++) {
             pv = *ppv;
             ASSERT(pv->type == EIMIL_TYPE_MTEXT);
             if (!EIMIL_convert_mtext_to_IMText(&ptexts[i], &pv->v.mtext)) {
                return NULL;
             }
         }
         break;
      }
              
      default:
       abort();
    }

    return pim;
}

Here is the call graph for this function:

Here is the caller graph for this function:

EIMIL_mtext* EIMIL_set_prop_on_mtext ( EIMIL_mtext pm,
EIMIL_value pv,
int  st,
int  end 
)

Definition at line 783 of file EIMILTextUtil.c.

{
    int i, n, idx;
    int mst, mend;
    EIMIL_mtext_props *pmp;
    EIMIL_value **ppv, *pv2, *pv3;
    EIMIL_prop *pprop;

    ASSERT(pv->type == EIMIL_TYPE_PROP);
       
    pmp = EIMIL_prepare_mtext_props_slot(pm, pv->v.prop.property_sym);
    if (!pmp) return NULL;
    n = pmp->num;

    idx = -1;
    ppv = pmp->pprops;
    for (i = 0; i < n;) {
       pv2 = ppv[i];
       ASSERT(pv2->type == EIMIL_TYPE_PROP);
       pprop = &pv2->v.prop;
       ASSERT(pprop->target == pm);
       ASSERT(pprop->property_sym == pmp->property_sym);
       mst = pprop->st;
       mend = pprop->end;
       if ((mend >= st) && (mst < st)) {
           /* <--->         */
           /*   <===>       */
           pprop->end = st;
           i++;
       }else if ((mend <= end) && (mst >= st)) {
           /*   <--->       */
           /*  <======>     */
           pprop->st = -1;
           pprop->end = -1;
           pprop->target = NULL;
           n--;
           if (n > i) {
              memmove(ppv + i, ppv + i + 1,
                     sizeof(EIMIL_value*) * (n - i));
           }
           EIMIL_RMREF(*pv2);
       }else if ((mst <= end) && (mend > end)) {
           /*       <--->   */
           /*  <======>     */
           pprop->st = end;
           i++;
       }else if ((mst < st) && (mend > end)) {
           /* <-------->    */
           /*    <===>      */
           /*     |         */
           /*     V         */
           /* <-><===><>    */
           /*  i      i+1   */
           pv3 = EIMIL_copy_value(pv2);
           if (!pv3) return NULL;
           pv3->v.prop.st = end;
           EIMIL_ADDREF(*pv3);
           pprop->end = st;
           ppv = (EIMIL_value**) realloc(ppv, sizeof(EIMIL_value*) * (n + 1));
           pmp->pprops = ppv;
           if (n > (i + 1)) {
              memmove(ppv + i + 2, ppv + i + 1,
                     sizeof(EIMIL_value*) * (n - i));
           }
           ppv[i + 1] = pv3;
           n++;
           if (idx < 0) idx = i + 1;
           i += 2;
       }else if (mst < st) {
           /* <---->        */
           /*       <====>  */
           if (idx < 0) idx = i;
           i++;
       }else{
           /*        <----> */
           /* <====>        */
           i++;
       }
    }
    pmp->pprops = (EIMIL_value**) realloc(pmp->pprops,
                                     sizeof(EIMIL_value*) * (n + 1));
    if (!pmp->pprops) return NULL;
    ppv = pmp->pprops + i;
    if (n > i) {
       memmove(ppv + 1, ppv, sizeof(EIMIL_value*) * (n - i));
    }
    *ppv = pv;
    pmp->num = n + 1;
    pv->v.prop.st = st;
    pv->v.prop.end = end;
    pv->v.prop.target = pm;
    EIMIL_ADDREF(*pv);

    return pm;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int EIMIL_sync_mtext ( EIMIL_mtext pm,
IMDifferential pdiff 
)

Definition at line 1419 of file EIMILTextUtil.c.

{
    int i, j, n;
    int st, end, nend, mst, mend, nlen, dlen;
    UTF32 *pustr, ulen;
    EIMIL_mtext_props *pmp;
    EIMIL_value **ppv, *pv, *pv2;
    EIMIL_prop *pprop;
    IMText *ptx;

    ptx = &pdiff->text;

    /* STEP1: replace the interval with the text.  */
    st = EIMIL_adjust_UTF16_pos_to_UTF32(pdiff->chg_first, pm->ustr,
                                    pm->ustr + pm->len);
    if (st < 0) return 0;
    end = EIMIL_adjust_UTF16_pos_to_UTF32(pdiff->chg_len, pm->ustr + st,
                                     pm->ustr + pm->len);
    if (end < 0) return 0;
    end += st;
    if (!EIMIL_convert_UTF16_to_UTF32(ptx->text.utf_chars, ptx->char_length,
                                  &pustr, &ulen))
       return 0;
    dlen = ulen - (end - st);
    nlen = pm->len + dlen;
    if ((end - st) > ulen) {
       memmove(pm->ustr + st + ulen, pm->ustr + end,
              sizeof(UTF32) * (pm->len - end));
       pm->ustr = (UTF32*) realloc(pm->ustr, sizeof(UTF32) * nlen);
    }else if ((end - st) < ulen) {
       pm->ustr = (UTF32*) realloc(pm->ustr, sizeof(UTF32) * nlen);
       memmove(pm->ustr + st + ulen, pm->ustr + end,
              sizeof(UTF32) * (pm->len - end));
    }
    memcpy(pm->ustr + st, pustr, sizeof(UTF32) * ulen);
    free(pustr);

    /* STEP2: strip or move props in the interval.  */
    for (pmp = pm->pslots, i = 0; i < pm->slotsnum; pmp++, i++) {
       n = pmp->num;
       ppv = pmp->pprops;
       for (j = 0; j < n;) {
           pv = ppv[j];
           ASSERT(pv->type == EIMIL_TYPE_PROP);
           pprop = &pv->v.prop;
           mst = pprop->st;
           mend = pprop->end;
           if ((mend >= st) && (mst < st)) {
              /* <--->         */
              /*   <===>       */
              pprop->end = st;
              j++;
           }else if ((mend <= end) && (mst >= st)) {
              /*   <--->       */
              /*  <======>     */
              pprop->st = -1;
              pprop->end = -1;
              pprop->target = NULL;
              n--;
              if (n > j) {
                  memmove(ppv + j, ppv + j + 1,
                         sizeof(EIMIL_value*) * (n - i));
              }
              EIMIL_RMREF(*pv);
           }else if ((mst <= end) && (mend > end)) {
              /*       <--->   */
              /*  <======>     */
              pprop->st = nend;
              j++;
           }else if ((mst < st) && (mend > end)) {
              /* <-------->    */
              /*    <===>      */
              /*     |         */
              /*     V         */
              /* <-><===><>    */
              /*  i      i+1   */
              pv2 = EIMIL_copy_value(pv);
              if (!pv2) return 0;
              pv2->v.prop.st = nend;
              EIMIL_ADDREF(*pv2);
              pprop->end = st;
              ppv = (EIMIL_value**) realloc(ppv, sizeof(EIMIL_value*) * (n + 1));
              pmp->pprops = ppv;
              if (n > (j + 1)) {
                  memmove(ppv + j + 2, ppv + j + 1,
                         sizeof(EIMIL_value*) * (n - j));
              }
              ppv[j + 1] = pv2;
              n++;
              j += 2;
           }else if (mst < st) {
              /* <---->        */
              /*       <====>  */
              j++;
           }else{
              /*        <----> */
              /* <====>        */
              pprop->st += dlen;
              pprop->end += dlen;
              j++;
           }
       }
    }

    /* STEP3: add props of the text. */
    if (!EIMIL_add_props_of_IMText(pm, ptx)) return 0;

    return 1;
}

Here is the call graph for this function:

int EIMIL_UTF32_strcmp ( const UTF32 pstr1,
const UTF32 pstr2 
)

Definition at line 48 of file EIMILTextUtil.c.

{
    for (;; pstr1++, pstr2++) {
       if (*pstr1 > *pstr2) return 1;
       if (*pstr1 < *pstr2) return -1;
       if (*pstr1 == 0) return 0;
    }
    return 0;
}

Here is the caller graph for this function:

int EIMIL_UTF32_string_len ( const UTF32 pstr)

Definition at line 38 of file EIMILTextUtil.c.

{
    int i;
    for (i = 0;*pstr;pstr++, i++);
    return i;
}

Here is the caller graph for this function:

static void set_feedback ( UTF32 basestr,
UTF32 strend,
EIMIL_prop pprop,
IMFeedbackList pfbl 
) [static]

Definition at line 1231 of file EIMILTextUtil.c.

{
    int st, end;
    IMFeedback *pfb;
    EIMIL_value *pv;

    if (pprop->type != EIMIL_TYPE_NUMBER) return;

    st = EIMIL_adjust_UTF32_pos_to_UTF16(pprop->st, basestr, strend); 
    ASSERT(st >= 0);
    end = EIMIL_adjust_UTF32_pos_to_UTF16(pprop->end, basestr, strend);
    ASSERT(end >= 0);

    pv = pprop->pvals[0];
    ASSERT(pv->type == EIMIL_TYPE_NUMBER);
    for (pfb = pfbl->feedbacks + st; end > st; st++, pfb++) {
       if (IM_FEEDBACK_TYPE(pfb)) continue;
       IM_FEEDBACK_TYPE(pfb) = IM_DECORATION_FEEDBACK;
       IM_FEEDBACK_VALUE(pfb) = pv->v.number;
    }
}

Here is the call graph for this function: