/* mtext.c -- M-text module.
- Copyright (C) 2003, 2004
+ Copyright (C) 2003, 2004, 2005
National Institute of Advanced Industrial Science and Technology (AIST)
Registration Number H15PRO112
M-text ¤Ë¤Ï¡¢C-string ¤Ë¤Ê¤¤°Ê²¼¤ÎÆÃħ¤¬¤¢¤ë¡£
- @li M-text ¤ÏÈó¾ï¤Ë¿¤¯¤Î¼ïÎà¤Îʸ»ú¤ò¡¢Æ±»þ¤Ë¡¢º®ºß¤µ¤»¤Æ¡¢Æ±Åù¤Ë
- °·¤¦¤³¤È¤¬¤Ç¤¤ë¡£Unicode ¤ÎÁ´¤Æ¤Îʸ»ú¤Ï¤â¤Á¤í¤ó¡¢¤è¤ê¿¤¯¤Îʸ»ú¤Þ
- ¤Ç°·¤¨¤ë¡£¤³¤ì¤Ï¿¸À¸ì¥Æ¥¥¹¥È¤ò°·¤¦¾å¤Ç¤Ïɬ¿Ü¤Îµ¡Ç½¤Ç¤¢¤ë¡£
+ @li M-text ¤ÏÈó¾ï¤Ë¿¤¯¤Î¼ïÎà¤Îʸ»ú¤ò¡¢Æ±»þ¤Ë¡¢º®ºß¤µ¤»¤Æ¡¢Æ±Åù¤Ë°·¤¦¤³¤È¤¬¤Ç¤¤ë¡£
+ Unicode ¤ÎÁ´¤Æ¤Îʸ»ú¤Ï¤â¤Á¤í¤ó¡¢¤è¤ê¿¤¯¤Îʸ»ú¤Þ¤Ç¤â°·¤¦¤³¤È¤¬¤Ç¤¤ë¡£
+ ¤³¤ì¤Ï¿¸À¸ì¥Æ¥¥¹¥È¤ò°·¤¦¾å¤Ç¤Ïɬ¿Ü¤Îµ¡Ç½¤Ç¤¢¤ë¡£
- @li M-text Æâ¤Î³Æʸ»ú¤Ï¡¢@e ¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£ ¤È¸Æ¤Ð¤ì¤ë¥×¥í¥Ñ¥Æ¥£
- ¤ò»ý¤Ä¤³¤È¤¬¤Ç¤¤ë¡£¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Ë¤è¤Ã¤Æ¡¢¥Æ¥¥¹¥È¤Î³ÆÉô°Ì¤Ë
- ´Ø¤¹¤ëÍÍ¡¹¤Ê¾ðÊó¤ò M-text Æâ¤ËÊÝ»ý¤¹¤ë¤³¤È¤¬¤Ç¤¤ë¡£¤½¤Î¤¿¤á¡¢¤½¤ì
- ¤é¤Î¾ðÊó¤ò¥¢¥×¥ê¥±¡¼¥·¥ç¥ó¥×¥í¥°¥é¥àÆâ¤ÇÅý°ìŪ¤Ë°·¤¦¤³¤È¤¬¤Ç¤¤ë¡£
- ¤Þ¤¿¡¢M-text ¼«ÂΤ¬ËÉ٤ʾðÊó¤ò»ý¤Ä¤¿¤á¡¢¥¢¥×¥ê¥±¡¼¥·¥ç¥ó¥×¥í¥°¥é
- ¥àÃæ¤Î³Æ´Ø¿ô¤ò´ÊÁDz½¤¹¤ë¤³¤È¤¬¤Ç¤¤ë¡£
+ @li M-text Æâ¤Î³Æʸ»ú¤Ï¡¢@e ¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£
+ ¤È¸Æ¤Ð¤ì¤ë¥×¥í¥Ñ¥Æ¥£¤ò»ý¤Á¡¢
+ ¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Ë¤è¤Ã¤Æ¡¢¥Æ¥¥¹¥È¤Î³ÆÉô°Ì¤Ë´Ø¤¹¤ëÍÍ¡¹¤Ê¾ðÊó¤ò
+ M-text Æâ¤ËÊÝ»ý¤¹¤ë¤³¤È¤¬²Äǽ¤Ë¤Ê¤ë¡£
+ ¤½¤Î¤¿¤á¡¢¤½¤ì¤é¤Î¾ðÊó¤ò¥¢¥×¥ê¥±¡¼¥·¥ç¥ó¥×¥í¥°¥é¥àÆâ¤ÇÅý°ìŪ¤Ë°·¤¦¤³¤È¤¬²Äǽ¤Ë¤Ê¤ë¡£
+ ¤Þ¤¿¡¢M-text
+ ¼«ÂΤ¬ËÉ٤ʾðÊó¤ò»ý¤Ä¤¿¤á¡¢¥¢¥×¥ê¥±¡¼¥·¥ç¥ó¥×¥í¥°¥é¥àÃæ¤Î³Æ´Ø¿ô¤ò´ÊÁDz½¤¹¤ë¤³¤È¤¬¤Ç¤¤ë¡£
- ¤µ¤é¤Ëm17n ¥é¥¤¥Ö¥é¥ê¤Ï¡¢ C-string ¤òÁàºî¤¹¤ë¤¿¤á¤ËÄ󶡤µ¤ì¤ë¼ï¡¹
- ¤Î´Ø¿ô¤ÈƱÅù¤Î¤â¤Î¤ò M-text ¤òÁàºî¤¹¤ë¤¿¤á¤Ë¥µ¥Ý¡¼¥È¤·¤Æ¤¤¤ë¡£ */
+ ¤µ¤é¤Ëm17n ¥é¥¤¥Ö¥é¥ê¤Ï¡¢ C-string
+ ¤òÁàºî¤¹¤ë¤¿¤á¤ËÄ󶡤µ¤ì¤ë¼ï¡¹¤Î´Ø¿ô¤ÈƱÅù¤Î¤â¤Î¤ò M-text
+ ¤òÁàºî¤¹¤ë¤¿¤á¤Ë¥µ¥Ý¡¼¥È¤·¤Æ¤¤¤ë¡£ */
/*=*/
static MSymbol M_charbag;
-#ifdef WORDS_BIGENDIAN
-static enum MTextFormat default_utf_16 = MTEXT_FORMAT_UTF_16BE;
-static enum MTextFormat default_utf_32 = MTEXT_FORMAT_UTF_32BE;
-#else
-static enum MTextFormat default_utf_16 = MTEXT_FORMAT_UTF_16LE;
-static enum MTextFormat default_utf_32 = MTEXT_FORMAT_UTF_32LE;
-#endif
-
-/** Increment character position CHAR_POS and byte position BYTE_POS
+/** Increment character position CHAR_POS and unit position UNIT_POS
so that they point to the next character in M-text MT. No range
- check for CHAR_POS and BYTE_POS. */
+ check for CHAR_POS and UNIT_POS. */
-#define INC_POSITION(mt, char_pos, byte_pos) \
+#define INC_POSITION(mt, char_pos, unit_pos) \
do { \
int c; \
\
- if ((mt)->format == MTEXT_FORMAT_UTF_8) \
+ if ((mt)->format <= MTEXT_FORMAT_UTF_8) \
{ \
- c = (mt)->data[(byte_pos)]; \
- (byte_pos) += CHAR_UNITS_BY_HEAD_UTF8 (c); \
+ c = (mt)->data[(unit_pos)]; \
+ (unit_pos) += CHAR_UNITS_BY_HEAD_UTF8 (c); \
} \
- else \
+ else if ((mt)->format <= MTEXT_FORMAT_UTF_16BE) \
{ \
- c = ((unsigned short *) ((mt)->data))[(byte_pos)]; \
+ c = ((unsigned short *) ((mt)->data))[(unit_pos)]; \
\
- if ((mt)->format != default_utf_16) \
+ if ((mt)->format != MTEXT_FORMAT_UTF_16) \
c = SWAP_16 (c); \
- (byte_pos) += (c < 0xD800 || c >= 0xE000) ? 1 : 2; \
+ (unit_pos) += CHAR_UNITS_BY_HEAD_UTF16 (c); \
} \
+ else \
+ (unit_pos)++; \
(char_pos)++; \
} while (0)
-/** Decrement character position CHAR_POS and byte position BYTE_POS
+/** Decrement character position CHAR_POS and unit position UNIT_POS
so that they point to the previous character in M-text MT. No
- range check for CHAR_POS and BYTE_POS. */
+ range check for CHAR_POS and UNIT_POS. */
-#define DEC_POSITION(mt, char_pos, byte_pos) \
+#define DEC_POSITION(mt, char_pos, unit_pos) \
do { \
- if ((mt)->format == MTEXT_FORMAT_UTF_8) \
+ if ((mt)->format <= MTEXT_FORMAT_UTF_8) \
{ \
- unsigned char *p1 = (mt)->data + (byte_pos); \
+ unsigned char *p1 = (mt)->data + (unit_pos); \
unsigned char *p0 = p1 - 1; \
\
while (! CHAR_HEAD_P (p0)) p0--; \
- (byte_pos) -= (p1 - p0); \
+ (unit_pos) -= (p1 - p0); \
} \
- else \
+ else if ((mt)->format <= MTEXT_FORMAT_UTF_16BE) \
{ \
- int c = ((unsigned short *) ((mt)->data))[(byte_pos) - 1]; \
+ int c = ((unsigned short *) ((mt)->data))[(unit_pos) - 1]; \
\
- if ((mt)->format != default_utf_16) \
+ if ((mt)->format != MTEXT_FORMAT_UTF_16) \
c = SWAP_16 (c); \
- (byte_pos) -= (c < 0xD800 || c >= 0xE000) ? 1 : 2; \
+ (unit_pos) -= 2 - (c < 0xD800 || c >= 0xE000); \
} \
+ else \
+ (unit_pos)--; \
(char_pos)--; \
} while (0)
+#define FORMAT_COVERAGE(fmt) \
+ (fmt == MTEXT_FORMAT_UTF_8 ? MTEXT_COVERAGE_FULL \
+ : fmt == MTEXT_FORMAT_US_ASCII ? MTEXT_COVERAGE_ASCII \
+ : fmt >= MTEXT_FORMAT_UTF_32LE ? MTEXT_COVERAGE_FULL \
+ : MTEXT_COVERAGE_UNICODE)
+
+/* Compoare sub-texts in MT1 (range FROM1 and TO1) and MT2 (range
+ FROM2 to TO2). */
static int
compare (MText *mt1, int from1, int to1, MText *mt2, int from2, int to2)
{
if (mt1->format == mt2->format
- && (mt1->format < MTEXT_FORMAT_UTF_8))
+ && (mt1->format <= MTEXT_FORMAT_UTF_8))
{
unsigned char *p1, *pend1, *p2, *pend2;
+ int unit_bytes = UNIT_BYTES (mt1->format);
+ int nbytes;
+ int result;
- p1 = mt1->data + mtext__char_to_byte (mt1, from1);
- pend1 = mt1->data + mtext__char_to_byte (mt1, to1);
+ p1 = mt1->data + mtext__char_to_byte (mt1, from1) * unit_bytes;
+ pend1 = mt1->data + mtext__char_to_byte (mt1, to1) * unit_bytes;
- p2 = mt2->data + mtext__char_to_byte (mt2, from2);
- pend2 = mt2->data + mtext__char_to_byte (mt2, to2);
+ p2 = mt2->data + mtext__char_to_byte (mt2, from2) * unit_bytes;
+ pend2 = mt2->data + mtext__char_to_byte (mt2, to2) * unit_bytes;
- for (; p1 < pend1 && p2 < pend2; p1++, p2++)
- if (*p1 != *p2)
- return (*p1 > *p2 ? 1 : -1);
- return (p2 == pend2 ? (p1 < pend1) : -1);
+ if (pend1 - p1 < pend2 - p2)
+ nbytes = pend1 - p1;
+ else
+ nbytes = pend2 - p2;
+ result = memcmp (p1, p2, nbytes);
+ if (result)
+ return result;
+ return ((pend1 - p1) - (pend2 - p2));
}
for (; from1 < to1 && from2 < to2; from1++, from2++)
{
return (from2 == to2 ? (from1 < to1) : -1);
}
-static MText *
-copy (MText *mt1, int pos, MText *mt2, int from, int to)
+
+/* Return how many units are required in UTF-8 to represent characters
+ between FROM and TO of MT. */
+
+static int
+count_by_utf_8 (MText *mt, int from, int to)
{
- int pos_byte = POS_CHAR_TO_BYTE (mt1, pos);
- int nbytes;
- struct MTextPlist *plist;
- unsigned char *p;
+ int n, c;
- if (mt2->format <= MTEXT_FORMAT_UTF_8)
+ for (n = 0; from < to; from++)
{
- int from_byte = POS_CHAR_TO_BYTE (mt2, from);
-
- p = mt2->data + from_byte;
- nbytes = POS_CHAR_TO_BYTE (mt2, to) - from_byte;
+ c = mtext_ref_char (mt, from);
+ n += CHAR_UNITS_UTF8 (c);
}
- else
+ return n;
+}
+
+
+/* Return how many units are required in UTF-16 to represent
+ characters between FROM and TO of MT. */
+
+static int
+count_by_utf_16 (MText *mt, int from, int to)
+{
+ int n, c;
+
+ for (n = 0; from < to; from++)
{
- unsigned char *p1;
- int pos1;
+ c = mtext_ref_char (mt, from);
+ n += CHAR_UNITS_UTF16 (c);
+ }
+ return n;
+}
+
+
+/* Insert text between FROM and TO of MT2 at POS of MT1. */
- p = p1 = alloca (MAX_UNICODE_CHAR_BYTES * (to - from));
- for (pos1 = from; pos1 < to; pos1++)
+static MText *
+insert (MText *mt1, int pos, MText *mt2, int from, int to)
+{
+ int pos_unit = POS_CHAR_TO_BYTE (mt1, pos);
+ int from_unit = POS_CHAR_TO_BYTE (mt2, from);
+ int new_units = POS_CHAR_TO_BYTE (mt2, to) - from_unit;
+ int unit_bytes;
+
+ if (mt1->nchars == 0)
+ mt1->format = mt2->format, mt1->coverage = mt2->coverage;
+ else if (mt1->format != mt2->format)
+ {
+ /* Be sure to make mt1->format sufficient to contain all
+ characters in mt2. */
+ if (mt1->format == MTEXT_FORMAT_UTF_8
+ || mt1->format == MTEXT_FORMAT_UTF_32
+ || (mt1->format == MTEXT_FORMAT_UTF_16
+ && mt2->format <= MTEXT_FORMAT_UTF_16BE
+ && mt2->format != MTEXT_FORMAT_UTF_8))
+ ;
+ else if (mt1->format == MTEXT_FORMAT_US_ASCII)
+ {
+ if (mt2->format == MTEXT_FORMAT_UTF_8)
+ mt1->format = MTEXT_FORMAT_UTF_8, mt1->coverage = mt2->coverage;
+ else if (mt2->format == MTEXT_FORMAT_UTF_16
+ || mt2->format == MTEXT_FORMAT_UTF_32)
+ mtext__adjust_format (mt1, mt2->format);
+ else
+ mtext__adjust_format (mt1, MTEXT_FORMAT_UTF_8);
+ }
+ else
{
- int c = mtext_ref_char (mt2, pos1);
- p1 += CHAR_STRING (c, p1);
+ mtext__adjust_format (mt1, MTEXT_FORMAT_UTF_8);
+ pos_unit = POS_CHAR_TO_BYTE (mt1, pos);
}
- nbytes = p1 - p;
}
- if (mt1->cache_char_pos > pos)
+ unit_bytes = UNIT_BYTES (mt1->format);
+
+ if (mt1->format == mt2->format)
{
- mt1->cache_char_pos = pos;
- mt1->cache_byte_pos = pos_byte;
- }
+ int pos_byte = pos_unit * unit_bytes;
+ int total_bytes = (mt1->nbytes + new_units) * unit_bytes;
+ int new_bytes = new_units * unit_bytes;
- if (pos_byte + nbytes >= mt1->allocated)
+ if (total_bytes + unit_bytes > mt1->allocated)
+ {
+ mt1->allocated = total_bytes + unit_bytes;
+ MTABLE_REALLOC (mt1->data, mt1->allocated, MERROR_MTEXT);
+ }
+ if (pos < mt1->nchars)
+ memmove (mt1->data + pos_byte + new_bytes, mt1->data + pos_byte,
+ (mt1->nbytes - pos_unit + 1) * unit_bytes);
+ memcpy (mt1->data + pos_byte, mt2->data + from_unit * unit_bytes,
+ new_bytes);
+ }
+ else if (mt1->format == MTEXT_FORMAT_UTF_8)
{
- mt1->allocated = pos_byte + nbytes + 1;
- MTABLE_REALLOC (mt1->data, mt1->allocated, MERROR_MTEXT);
+ unsigned char *p;
+ int total_bytes, i, c;
+
+ new_units = count_by_utf_8 (mt2, from, to);
+ total_bytes = mt1->nbytes + new_units;
+
+ if (total_bytes + 1 > mt1->allocated)
+ {
+ mt1->allocated = total_bytes + 1;
+ MTABLE_REALLOC (mt1->data, mt1->allocated, MERROR_MTEXT);
+ }
+ p = mt1->data + pos_unit;
+ memmove (p + new_units, p, mt1->nbytes - pos_unit + 1);
+ for (i = from; i < to; i++)
+ {
+ c = mtext_ref_char (mt2, i);
+ p += CHAR_STRING_UTF8 (c, p);
+ }
}
- memcpy (mt1->data + pos_byte, p, nbytes);
- mt1->nbytes = pos_byte + nbytes;
- mt1->data[mt1->nbytes] = 0;
+ else if (mt1->format == MTEXT_FORMAT_UTF_16)
+ {
+ unsigned short *p;
+ int total_bytes, i, c;
- plist = mtext__copy_plist (mt2->plist, from, to, mt1, pos);
- if (pos == 0)
+ new_units = count_by_utf_16 (mt2, from, to);
+ total_bytes = (mt1->nbytes + new_units) * USHORT_SIZE;
+
+ if (total_bytes + USHORT_SIZE > mt1->allocated)
+ {
+ mt1->allocated = total_bytes + USHORT_SIZE;
+ MTABLE_REALLOC (mt1->data, mt1->allocated, MERROR_MTEXT);
+ }
+ p = (unsigned short *) mt1->data + pos_unit;
+ memmove (p + new_units, p,
+ (mt1->nbytes - pos_unit + 1) * USHORT_SIZE);
+ for (i = from; i < to; i++)
+ {
+ c = mtext_ref_char (mt2, i);
+ p += CHAR_STRING_UTF16 (c, p);
+ }
+ }
+ else /* MTEXT_FORMAT_UTF_32 */
{
- if (mt1->plist)
- mtext__free_plist (mt1);
- mt1->plist = plist;
+ unsigned int *p;
+ int total_bytes, i;
+
+ new_units = to - from;
+ total_bytes = (mt1->nbytes + new_units) * UINT_SIZE;
+
+ if (total_bytes + UINT_SIZE > mt1->allocated)
+ {
+ mt1->allocated = total_bytes + UINT_SIZE;
+ MTABLE_REALLOC (mt1->data, mt1->allocated, MERROR_MTEXT);
+ }
+ p = (unsigned *) mt1->data + pos_unit;
+ memmove (p + new_units, p,
+ (mt1->nbytes - pos_unit + 1) * UINT_SIZE);
+ for (i = from; i < to; i++)
+ *p++ = mtext_ref_char (mt2, i);
}
- else
+
+ mtext__adjust_plist_for_insert
+ (mt1, pos, to - from,
+ mtext__copy_plist (mt2->plist, from, to, mt1, pos));
+ mt1->nchars += to - from;
+ mt1->nbytes += new_units;
+ if (mt1->cache_char_pos > pos)
{
- if (pos < mt1->nchars)
- mtext__adjust_plist_for_delete (mt1, pos, mt1->nchars - pos);
- if (from < to)
- mtext__adjust_plist_for_insert (mt1, pos, to - from, plist);
+ mt1->cache_char_pos += to - from;
+ mt1->cache_byte_pos += new_units;
}
- mt1->nchars = pos + (to - from);
- if (mt1->nchars < mt1->nbytes)
- mt1->format = MTEXT_FORMAT_UTF_8;
return mt1;
}
static int
-count_utf_8_chars (void *data, int nitems)
+count_utf_8_chars (const void *data, int nitems)
{
unsigned char *p = (unsigned char *) data;
unsigned char *pend = p + nitems;
}
static int
-count_utf_16_chars (void *data, int nitems, int swap)
+count_utf_16_chars (const void *data, int nitems, int swap)
{
unsigned short *p = (unsigned short *) data;
unsigned short *pend = p + nitems;
int nchars = 0;
+ int prev_surrogate = 0;
- while (p < pend)
+ for (; p < pend; p++)
{
- unsigned b;
+ int c = *p;
- for (; p < pend; nchars++, p++)
+ if (swap)
+ c = SWAP_16 (c);
+ if (prev_surrogate)
{
- b = swap ? *p & 0xFF : *p >> 8;
-
- if (b >= 0xD8 && b < 0xE0)
- {
- if (b >= 0xDC)
- return -1;
- break;
- }
+ if (c < 0xDC00 || c >= 0xE000)
+ /* Invalid surrogate */
+ nchars++;
+ }
+ else
+ {
+ if (c >= 0xD800 && c < 0xDC00)
+ prev_surrogate = 1;
+ nchars++;
}
- if (p == pend)
- break;
- if (p + 1 == pend)
- return -1;
- p++;
- b = swap ? *p & 0xFF : *p >> 8;
- if (b < 0xDC || b >= 0xE0)
- return -1;
- nchars++;
- p++;
}
-
+ if (prev_surrogate)
+ nchars++;
return nchars;
}
while (from < to && STRING_CHAR_ADVANCE_UTF8 (p) != c) from++;
}
- else if (mt->format <= MTEXT_FORMAT_UTF_16LE)
+ else if (mt->format <= MTEXT_FORMAT_UTF_16BE)
{
unsigned short *p = (unsigned short *) (mt->data) + from_byte;
- if (mt->format == default_utf_16)
- {
- unsigned short *p = (unsigned short *) (mt->data) + from_byte;
-
- while (from < to && STRING_CHAR_ADVANCE_UTF16 (p) != c) from++;
- }
+ if (mt->format == MTEXT_FORMAT_UTF_16)
+ while (from < to && STRING_CHAR_ADVANCE_UTF16 (p) != c) from++;
else if (c < 0x10000)
{
c = SWAP_16 (c);
p += ((*p & 0xFF) < 0xD8 || (*p & 0xFF) >= 0xE0) ? 1 : 2;
}
}
+ else
+ from = to;
}
- else if (c < 0x110000)
+ else
{
unsigned *p = (unsigned *) (mt->data) + from_byte;
unsigned c1 = c;
- if (mt->format != default_utf_32)
+ if (mt->format != MTEXT_FORMAT_UTF_32)
c1 = SWAP_32 (c1);
while (from < to && *p++ != c1) from++;
}
{
unsigned short *p = (unsigned short *) (mt->data) + to_byte;
- if (mt->format == default_utf_16)
+ if (mt->format == MTEXT_FORMAT_UTF_16)
{
while (from < to)
{
int c1 = (c >> 10) + 0xD800;
int c2 = (c & 0x3FF) + 0xDC00;
- c1 = SWAP_32 (c1);
- c2 = SWAP_32 (c2);
+ c1 = SWAP_16 (c1);
+ c2 = SWAP_16 (c2);
while (from < to && (p[-1] != c2 || p[-2] != c1))
{
to--;
}
}
}
- else if (c < 0x110000)
+ else
{
unsigned *p = (unsigned *) (mt->data) + to_byte;
unsigned c1 = c;
- if (mt->format != default_utf_32)
+ if (mt->format != MTEXT_FORMAT_UTF_32)
c1 = SWAP_32 (c1);
while (from < to && p[-1] != c1) to--, p--;
}
int
mtext__init ()
{
+ M17N_OBJECT_ADD_ARRAY (mtext_table, "M-text");
M_charbag = msymbol_as_managing_key (" charbag");
mtext_table.count = 0;
return 0;
void
mtext__fini (void)
{
- mdebug__report_object ("M-text", &mtext_table);
+ mtext__wseg_fini ();
}
}
MText *
-mtext__from_data (void *data, int nitems, enum MTextFormat format,
+mtext__from_data (const void *data, int nitems, enum MTextFormat format,
int need_copy)
{
MText *mt;
- int nchars = nitems;
- int bytes = nitems;
+ int nchars, nbytes, unit_bytes;
if (format == MTEXT_FORMAT_US_ASCII)
{
- char *p = (char *) data, *pend = p + nitems;
+ const char *p = (char *) data, *pend = p + nitems;
while (p < pend)
if (*p++ < 0)
MERROR (MERROR_MTEXT, NULL);
+ nchars = nbytes = nitems;
+ unit_bytes = 1;
}
else if (format == MTEXT_FORMAT_UTF_8)
{
if ((nchars = count_utf_8_chars (data, nitems)) < 0)
MERROR (MERROR_MTEXT, NULL);
+ nbytes = nitems;
+ unit_bytes = 1;
}
else if (format <= MTEXT_FORMAT_UTF_16BE)
{
if ((nchars = count_utf_16_chars (data, nitems,
- format != default_utf_16)) < 0)
+ format != MTEXT_FORMAT_UTF_16)) < 0)
MERROR (MERROR_MTEXT, NULL);
- bytes = sizeof (short) * nitems;
+ nbytes = USHORT_SIZE * nitems;
+ unit_bytes = USHORT_SIZE;
}
- else if (format <= MTEXT_FORMAT_UTF_32BE)
+ else /* MTEXT_FORMAT_UTF_32XX */
{
- unsigned *p = (unsigned *) data, *pend = p + nitems;
- int swap = format != default_utf_32;
-
- for (; p < pend; p++)
- {
- unsigned c = swap ? SWAP_32 (*p) : *p;
-
- if ((c >= 0xD800 && c < 0xE000) || (c >= 0x110000))
- MERROR (MERROR_MTEXT, NULL);
- }
- bytes = sizeof (unsigned) * nitems;
+ nchars = nitems;
+ nbytes = UINT_SIZE * nitems;
+ unit_bytes = UINT_SIZE;
}
- else
- MERROR (MERROR_MTEXT, NULL);
mt = mtext ();
mt->format = format;
- mt->allocated = need_copy ? bytes : -1;
+ mt->coverage = FORMAT_COVERAGE (format);
+ mt->allocated = need_copy ? nbytes + unit_bytes : -1;
mt->nchars = nchars;
mt->nbytes = nitems;
if (need_copy)
{
- mt->data = malloc (bytes + 1);
- memcpy (mt->data, data, bytes);
- mt->data[bytes] = 0;
+ MTABLE_MALLOC (mt->data, mt->allocated, MERROR_MTEXT);
+ memcpy (mt->data, data, nbytes);
+ mt->data[nbytes] = 0;
}
else
mt->data = (unsigned char *) data;
}
-/* Not yet implemented. */
-
-int
+void
mtext__adjust_format (MText *mt, enum MTextFormat format)
{
- if (mt->format == format)
- return 0;
- if (mt->format == MTEXT_FORMAT_US_ASCII)
- {
- if (format == MTEXT_FORMAT_UTF_8)
- mt->format = MTEXT_FORMAT_UTF_8;
- MERROR (MERROR_MTEXT, -1);
- }
- else if (mt->format == MTEXT_FORMAT_UTF_8)
- {
- MERROR (MERROR_MTEXT, -1);
- }
- else if (mt->format <= MTEXT_FORMAT_UTF_16BE)
- {
- MERROR (MERROR_MTEXT, -1);
- }
- else
- {
- MERROR (MERROR_MTEXT, -1);
- }
- return 0;
-}
-
-
-int
-mtext__replace (MText *mt, int from, int to, char *from_str, char *to_str)
-{
- int from_byte = POS_CHAR_TO_BYTE (mt, from);
- int to_byte = POS_CHAR_TO_BYTE (mt, to);
- unsigned char *p = MTEXT_DATA (mt) + from_byte;
- unsigned char *endp = MTEXT_DATA (mt) + to_byte;
- int from_str_len = strlen (from_str);
- int to_str_len = strlen (to_str);
- int diff = to_str_len - from_str_len;
- unsigned char saved_byte;
- int pos, pos_byte;
-
- if (mtext_nchars (mt) == 0
- || from_str_len == 0)
- return 0;
- M_CHECK_READONLY (mt, -1);
- M_CHECK_RANGE (mt, from, to, -1, 0);
+ int i, c;
- saved_byte = *endp;
- *endp = '\0';
- while ((p = (unsigned char *) strstr ((char *) p, from_str)) != NULL)
- {
- if (diff < 0)
+ if (mt->nchars > 0)
+ switch (format)
+ {
+ case MTEXT_FORMAT_US_ASCII:
{
- pos_byte = p - MTEXT_DATA (mt);
- pos = POS_BYTE_TO_CHAR (mt, pos_byte);
- mtext_del (mt, pos, pos - diff);
+ unsigned char *p = mt->data;
+
+ for (i = 0; i < mt->nchars; i++)
+ *p++ = mtext_ref_char (mt, i);
+ mt->nbytes = mt->nchars;
+ mt->cache_byte_pos = mt->cache_char_pos;
+ break;
}
- else if (diff > 0)
+
+ case MTEXT_FORMAT_UTF_8:
{
- pos_byte = p - MTEXT_DATA (mt);
- pos = POS_BYTE_TO_CHAR (mt, pos_byte);
- mtext_ins_char (mt, pos, ' ', diff);
- /* The above may relocate mt->data. */
- endp += (MTEXT_DATA (mt) + pos_byte) - p;
- p = MTEXT_DATA (mt) + pos_byte;
+ unsigned char *p0, *p1;
+
+ i = count_by_utf_8 (mt, 0, mt->nchars) + 1;
+ MTABLE_MALLOC (p0, i, MERROR_MTEXT);
+ mt->allocated = i;
+ for (i = 0, p1 = p0; i < mt->nchars; i++)
+ {
+ c = mtext_ref_char (mt, i);
+ p1 += CHAR_STRING_UTF8 (c, p1);
+ }
+ *p1 = '\0';
+ free (mt->data);
+ mt->data = p0;
+ mt->nbytes = p1 - p0;
+ mt->cache_char_pos = mt->cache_byte_pos = 0;
+ break;
}
- memmove (p, to_str, to_str_len);
- p += to_str_len;
- endp += diff;
- }
- *endp = saved_byte;
- return 0;
+
+ default:
+ if (format == MTEXT_FORMAT_UTF_16)
+ {
+ unsigned short *p0, *p1;
+
+ i = (count_by_utf_16 (mt, 0, mt->nchars) + 1) * USHORT_SIZE;
+ MTABLE_MALLOC (p0, i, MERROR_MTEXT);
+ mt->allocated = i;
+ for (i = 0, p1 = p0; i < mt->nchars; i++)
+ {
+ c = mtext_ref_char (mt, i);
+ p1 += CHAR_STRING_UTF16 (c, p1);
+ }
+ *p1 = 0;
+ free (mt->data);
+ mt->data = (unsigned char *) p0;
+ mt->nbytes = p1 - p0;
+ mt->cache_char_pos = mt->cache_byte_pos = 0;
+ break;
+ }
+ else
+ {
+ unsigned int *p;
+
+ mt->allocated = (mt->nchars + 1) * UINT_SIZE;
+ MTABLE_MALLOC (p, mt->allocated, MERROR_MTEXT);
+ for (i = 0; i < mt->nchars; i++)
+ p[i] = mtext_ref_char (mt, i);
+ p[i] = 0;
+ free (mt->data);
+ mt->data = (unsigned char *) p;
+ mt->nbytes = mt->nchars;
+ mt->cache_byte_pos = mt->cache_char_pos;
+ }
+ }
+ mt->format = format;
+ mt->coverage = FORMAT_COVERAGE (format);
}
else if (mt->format <= MTEXT_FORMAT_UTF_16BE)
{
unsigned short *p = ((unsigned short *) (mt->data)) + byte_pos;
- unsigned short newline = mt->format == default_utf_16 ? 0x0A00 : 0x000A;
+ unsigned short newline = (mt->format == MTEXT_FORMAT_UTF_16
+ ? 0x0A00 : 0x000A);
if (p[-1] == newline)
return pos;
else
{
unsigned *p = ((unsigned *) (mt->data)) + byte_pos;
- unsigned newline = mt->format == default_utf_32 ? 0x0A000000 : 0x0000000A;
+ unsigned newline = (mt->format == MTEXT_FORMAT_UTF_32
+ ? 0x0A000000 : 0x0000000A);
if (p[-1] == newline)
return pos;
{
unsigned short *p = ((unsigned short *) (mt->data)) + byte_pos;
unsigned short *endp;
- unsigned short newline = mt->format == default_utf_16 ? 0x0A00 : 0x000A;
+ unsigned short newline = (mt->format == MTEXT_FORMAT_UTF_16
+ ? 0x0A00 : 0x000A);
if (*p == newline)
return pos + 1;
{
unsigned *p = ((unsigned *) (mt->data)) + byte_pos;
unsigned *endp;
- unsigned newline = mt->format == default_utf_32 ? 0x0A000000 : 0x0000000A;
+ unsigned newline = (mt->format == MTEXT_FORMAT_UTF_32
+ ? 0x0A000000 : 0x0000000A);
if (*p == newline)
return pos + 1;
\f
/* External API */
+#ifdef WORDS_BIGENDIAN
+const enum MTextFormat MTEXT_FORMAT_UTF_16 = MTEXT_FORMAT_UTF_16BE;
+#else
+const enum MTextFormat MTEXT_FORMAT_UTF_16 = MTEXT_FORMAT_UTF_16LE;
+#endif
+
+#ifdef WORDS_BIGENDIAN
+const int MTEXT_FORMAT_UTF_32 = MTEXT_FORMAT_UTF_32BE;
+#else
+const int MTEXT_FORMAT_UTF_32 = MTEXT_FORMAT_UTF_32LE;
+#endif
+
/*** @addtogroup m17nMtext */
/*** @{ */
/*=*/
The mtext () function allocates a new M-text of length 0 and
returns a pointer to it. The allocated M-text will not be freed
- unless the user explicitly does so with the m17n_object_free ()
+ unless the user explicitly does so with the m17n_object_unref ()
function. */
/***ja
@brief ¿·¤·¤¤M-text¤ò³ä¤êÅö¤Æ¤ë.
- ´Ø¿ô mtext () ¤Ï¡¢Ä¹¤µ 0 ¤Î¿·¤·¤¤ M-text ¤ò³ä¤êÅö¤Æ¡¢¤½¤ì¤Ø¤Î¥Ý¥¤
- ¥ó¥¿¤òÊÖ¤¹¡£³ä¤êÅö¤Æ¤é¤ì¤¿ M-text ¤Ï¡¢´Ø¿ô m17n_object_free () ¤Ë
- ¤è¤Ã¤Æ¥æ¡¼¥¶¤¬ÌÀ¼¨Åª¤Ë¹Ô¤Ê¤ï¤Ê¤¤¸Â¤ê¡¢²òÊü¤µ¤ì¤Ê¤¤¡£
+ ´Ø¿ô mtext () ¤Ï¡¢Ä¹¤µ 0 ¤Î¿·¤·¤¤ M-text
+ ¤ò³ä¤êÅö¤Æ¡¢¤½¤ì¤Ø¤Î¥Ý¥¤¥ó¥¿¤òÊÖ¤¹¡£³ä¤êÅö¤Æ¤é¤ì¤¿ M-text ¤Ï¡¢´Ø¿ô
+ m17n_object_unref () ¤Ë¤è¤Ã¤Æ¥æ¡¼¥¶¤¬ÌÀ¼¨Åª¤Ë¹Ô¤Ê¤ï¤Ê¤¤¸Â¤ê¡¢²òÊü¤µ¤ì¤Ê¤¤¡£
@latexonly \IPAlabel{mtext} @endlatexonly */
/***
@seealso
- m17n_object_free () */
+ m17n_object_unref () */
MText *
mtext ()
MText *mt;
M17N_OBJECT (mt, free_mtext, MERROR_MTEXT);
- mt->format = MTEXT_FORMAT_UTF_8;
+ mt->format = MTEXT_FORMAT_US_ASCII;
+ mt->coverage = MTEXT_COVERAGE_ASCII;
M17N_OBJECT_REGISTER (mtext_table, mt);
return mt;
}
The contents of $DATA must not be modified while the M-text is alive.
The allocated M-text will not be freed unless the user explicitly
- does so with the m17n_object_free () function. Even in that case,
+ does so with the m17n_object_unref () function. Even in that case,
$DATA is not freed.
@return
/***ja
@brief »ØÄê¤Î¥Ç¡¼¥¿¤ò¸µ¤Ë¿·¤·¤¤ M-text ¤ò³ä¤êÅö¤Æ¤ë.
- ´Ø¿ô mtext_from_data () ¤Ï¡¢Í×ÁÇ¿ô $NITEMS ¤ÎÇÛÎó $DATA ¤Ç»ØÄꤵ¤ì
- ¤¿Ê¸»úÎó¤ò»ý¤Ä¿·¤·¤¤ M-text ¤ò³ä¤êÅö¤Æ¤ë¡£$FORMAT ¤Ï $DATA ¤Î¥Õ¥©¡¼
- ¥Þ¥Ã¥È¤ò¼¨¤¹¡£
+ ´Ø¿ô mtext_from_data () ¤Ï¡¢Í×ÁÇ¿ô $NITEMS ¤ÎÇÛÎó $DATA
+ ¤Ç»ØÄꤵ¤ì¤¿Ê¸»úÎó¤ò»ý¤Ä¿·¤·¤¤ M-text ¤ò³ä¤êÅö¤Æ¤ë¡£$FORMAT ¤Ï $DATA
+ ¤Î¥Õ¥©¡¼¥Þ¥Ã¥È¤ò¼¨¤¹¡£
$FORMAT ¤¬ #MTEXT_FORMAT_US_ASCII ¤« #MTEXT_FORMAT_UTF_8 ¤Ê¤é¤Ð¡¢
- $DATA ¤ÎÆâÍÆ¤Ï @c unsigned @c char ·¿¤Ç¤¢¤ê¡¢$NITEMS ¤Ï¥Ð¥¤¥Èñ°Ì
- ¤Çɽ¤µ¤ì¤Æ¤¤¤ë¡£
+ $DATA ¤ÎÆâÍÆ¤Ï @c unsigned @c char ·¿¤Ç¤¢¤ê¡¢$NITEMS
+ ¤Ï¥Ð¥¤¥Èñ°Ì¤Çɽ¤µ¤ì¤Æ¤¤¤ë¡£
$FORMAT ¤¬ #MTEXT_FORMAT_UTF_16LE ¤« #MTEXT_FORMAT_UTF_16BE ¤Ê¤é¤Ð¡¢
$DATA ¤ÎÆâÍÆ¤Ï @c unsigned @c short ·¿¤Ç¤¢¤ê¡¢$NITEMS ¤Ï unsigned
³ä¤êÅö¤Æ¤é¤ì¤¿ M-text ¤Îʸ»úÎó¤ÏÊѹ¹¤Ç¤¤Ê¤¤¡£$DATA ¤ÎÆâÍƤÏ
M-text ¤¬Í¸ú¤Ê´Ö¤ÏÊѹ¹¤·¤Æ¤Ï¤Ê¤é¤Ê¤¤¡£
- ³ä¤êÅö¤Æ¤é¤ì¤¿ M-text ¤Ï¡¢´Ø¿ô m17n_object_free () ¤Ë¤è¤Ã¤Æ¥æ¡¼¥¶
- ¤¬ÌÀ¼¨Åª¤Ë¹Ô¤Ê¤ï¤Ê¤¤¸Â¤ê¡¢²òÊü¤µ¤ì¤Ê¤¤¡£¤½¤Î¾ì¹ç¤Ç¤â $DATA ¤Ï²òÊü
- ¤µ¤ì¤Ê¤¤¡£
+ ³ä¤êÅö¤Æ¤é¤ì¤¿ M-text ¤Ï¡¢´Ø¿ô m17n_object_unref ()
+ ¤Ë¤è¤Ã¤Æ¥æ¡¼¥¶¤¬ÌÀ¼¨Åª¤Ë¹Ô¤Ê¤ï¤Ê¤¤¸Â¤ê¡¢²òÊü¤µ¤ì¤Ê¤¤¡£¤½¤Î¾ì¹ç¤Ç¤â $DATA ¤Ï²òÊü¤µ¤ì¤Ê¤¤¡£
@return
- ½èÍý¤¬À®¸ù¤¹¤ì¤Ð¡¢mtext_from_data () ¤Ï³ä¤êÅö¤Æ¤é¤ì¤¿M-text ¤Ø¤Î¥Ý
- ¥¤¥ó¥¿¤òÊÖ¤¹¡£¤½¤¦¤Ç¤Ê¤±¤ì¤Ð @c NULL ¤òÊÖ¤·³°ÉôÊÑ¿ô #merror_code ¤Ë
- ¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£ */
+ ½èÍý¤¬À®¸ù¤¹¤ì¤Ð¡¢mtext_from_data () ¤Ï³ä¤êÅö¤Æ¤é¤ì¤¿M-text
+ ¤Ø¤Î¥Ý¥¤¥ó¥¿¤òÊÖ¤¹¡£¤½¤¦¤Ç¤Ê¤±¤ì¤Ð @c NULL ¤òÊÖ¤·³°ÉôÊÑ¿ô #merror_code
+ ¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£ */
/***
@errors
@c MERROR_MTEXT */
MText *
-mtext_from_data (void *data, int nitems, enum MTextFormat format)
+mtext_from_data (const void *data, int nitems, enum MTextFormat format)
{
- if (nitems < 0)
+ if (nitems < 0
+ || format < MTEXT_FORMAT_US_ASCII || format >= MTEXT_FORMAT_MAX)
MERROR (MERROR_MTEXT, NULL);
- if (nitems == 0)
- {
- if (format == MTEXT_FORMAT_US_ASCII
- || format == MTEXT_FORMAT_UTF_8)
- {
- unsigned char *p = data;
+ return mtext__from_data (data, nitems, format, 0);
+}
- while (*p++) nitems++;
- }
- else if (format <= MTEXT_FORMAT_UTF_16BE)
- {
- unsigned short *p = data;
+/*=*/
- while (*p++) nitems++;
- }
- else if (format <= MTEXT_FORMAT_UTF_32BE)
- {
- unsigned *p = data;
+/***en
+ @brief Get information about the text data in M-text.
- while (*p++) nitems++;
- }
- else
+ The mtext_data () function returns a pointer to the text data of
+ M-text $MT. If $FMT is not NULL, the format of the text data is
+ stored in it. If $NUNITS is not NULL, the number of units of the
+ text data is stored in it.
+
+ If $POS_IDX is not NULL and it points to a non-negative number,
+ what it points to is a character position. In this case, the
+ return value is a pointer to the text data of a character at that
+ position.
+
+ Otherwise, if $UNIT_IDX is not NULL, it points to a unit position.
+ In this case, the return value is a pointer to the text data of a
+ character containing that unit.
+
+ The character position and unit position of the return value are
+ stored in $POS_IDX and $UNIT_DIX respectively if they are not
+ NULL.
+
+ <ul>
+
+ <li> If the format of the text data is MTEXT_FORMAT_US_ASCII or
+ MTEXT_FORMAT_UTF_8, one unit is unsigned char.
+
+ <li> If the format is MTEXT_FORMAT_UTF_16LE or
+ MTEXT_FORMAT_UTF_16BE, one unit is unsigned short.
+
+ <li> If the format is MTEXT_FORMAT_UTF_32LE or
+ MTEXT_FORMAT_UTF_32BE, one unit is unsigned int.
+
+ </ul> */
+
+void *
+mtext_data (MText *mt, enum MTextFormat *fmt, int *nunits,
+ int *pos_idx, int *unit_idx)
+{
+ void *data;
+ int pos = 0, unit_pos = 0;
+
+ if (fmt)
+ *fmt = mt->format;
+ data = MTEXT_DATA (mt);
+ if (pos_idx && *pos_idx >= 0)
+ {
+ pos = *pos_idx;
+ if (pos > mtext_nchars (mt))
MERROR (MERROR_MTEXT, NULL);
+ unit_pos = POS_CHAR_TO_BYTE (mt, pos);
}
- return mtext__from_data (data, nitems, format, 0);
+ else if (unit_idx)
+ {
+ unit_pos = *unit_idx;
+
+ if (unit_pos < 0 || unit_pos > mtext_nbytes (mt))
+ MERROR (MERROR_MTEXT, NULL);
+ pos = POS_BYTE_TO_CHAR (mt, unit_pos);
+ unit_pos = POS_CHAR_TO_BYTE (mt, pos);
+ }
+ if (nunits)
+ *nunits = mtext_nbytes (mt) - unit_pos;
+ if (pos_idx)
+ *pos_idx = pos;
+ if (unit_idx)
+ *unit_idx = unit_pos;
+ if (unit_pos > 0)
+ {
+ if (mt->format <= MTEXT_FORMAT_UTF_8)
+ data = (unsigned char *) data + unit_pos;
+ else if (mt->format <= MTEXT_FORMAT_UTF_16BE)
+ data = (unsigned short *) data + unit_pos;
+ else
+ data = (unsigned int *) data + unit_pos;
+ }
+ return data;
}
/*=*/
/***ja
@brief M-text Ãæ¤Î»ØÄꤵ¤ì¤¿°ÌÃÖ¤Îʸ»ú¤òÊÖ¤¹.
- ´Ø¿ô mtext_ref_char () ¤Ï¡¢M-text $MT ¤Î°ÌÃÖ $POS ¤Îʸ»ú¤òÊÖ¤¹¡£
- ¥¨¥é¡¼¤¬¸¡½Ð¤µ¤ì¤¿¾ì¹ç¤Ï -1 ¤òÊÖ¤·¡¢³°ÉôÊÑ¿ô #merror_code
+ ´Ø¿ô mtext_ref_char () ¤Ï¡¢M-text $MT ¤Î°ÌÃÖ $POS
+ ¤Îʸ»ú¤òÊÖ¤¹¡£¥¨¥é¡¼¤¬¸¡½Ð¤µ¤ì¤¿¾ì¹ç¤Ï -1 ¤òÊÖ¤·¡¢³°ÉôÊÑ¿ô #merror_code
¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£
@latexonly \IPAlabel{mtext_ref_char} @endlatexonly */
{
unsigned char *p = mt->data + POS_CHAR_TO_BYTE (mt, pos);
- c = STRING_CHAR (p);
+ c = STRING_CHAR_UTF8 (p);
}
else if (mt->format <= MTEXT_FORMAT_UTF_16BE)
{
unsigned short *p
= (unsigned short *) (mt->data) + POS_CHAR_TO_BYTE (mt, pos);
+ unsigned short p1[2];
- if (mt->format == default_utf_16)
- c = STRING_CHAR_UTF16 (p);
- else
+ if (mt->format != MTEXT_FORMAT_UTF_16)
{
- c = (*p >> 8) | ((*p & 0xFF) << 8);
- if (c >= 0xD800 && c < 0xE000)
- {
- int c1 = (p[1] >> 8) | ((p[1] & 0xFF) << 8);
- c = ((c - 0xD800) << 10) + (c1 - 0xDC00) + 0x10000;
- }
+ p1[0] = SWAP_16 (*p);
+ if (p1[0] >= 0xD800 || p1[0] < 0xDC00)
+ p1[1] = SWAP_16 (p[1]);
+ p = p1;
}
+ c = STRING_CHAR_UTF16 (p);
}
else
{
- unsigned *p = (unsigned *) (mt->data) + POS_CHAR_TO_BYTE (mt, pos);
-
- if (mt->format == default_utf_32)
- c = *p;
- else
- c = SWAP_32 (*p);
+ c = ((unsigned *) (mt->data))[pos];
+ if (mt->format != MTEXT_FORMAT_UTF_32)
+ c = SWAP_32 (c);
}
return c;
}
M-text $MT ¤Î°ÌÃÖ $POS ¤ËÀßÄꤹ¤ë¡£
@return
- ½èÍý¤ËÀ®¸ù¤¹¤ì¤Ð mtext_set_char () ¤Ï 0 ¤òÊÖ¤¹¡£¼ºÇÔ¤¹¤ì¤Ð -1 ¤òÊÖ
- ¤·¡¢³°ÉôÊÑ¿ô #merror_code ¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£
+ ½èÍý¤ËÀ®¸ù¤¹¤ì¤Ð mtext_set_char () ¤Ï 0 ¤òÊÖ¤¹¡£¼ºÇÔ¤¹¤ì¤Ð -1
+ ¤òÊÖ¤·¡¢³°ÉôÊÑ¿ô #merror_code ¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£
@latexonly \IPAlabel{mtext_set_char} @endlatexonly */
int
mtext_set_char (MText *mt, int pos, int c)
{
- int byte_pos;
- int bytes_old, bytes_new;
+ int pos_unit;
+ int old_units, new_units;
int delta;
- unsigned char str[MAX_UTF8_CHAR_BYTES];
unsigned char *p;
- int i;
+ int unit_bytes;
M_CHECK_POS (mt, pos, -1);
M_CHECK_READONLY (mt, -1);
- byte_pos = POS_CHAR_TO_BYTE (mt, pos);
- p = mt->data + byte_pos;
- bytes_old = CHAR_BYTES_AT (p);
- bytes_new = CHAR_STRING (c, str);
- delta = bytes_new - bytes_old;
+ mtext__adjust_plist_for_change (mt, pos, 1, 1);
+
+ if (mt->format <= MTEXT_FORMAT_UTF_8)
+ {
+ if (c >= 0x80)
+ mt->format = MTEXT_FORMAT_UTF_8, mt->coverage = MTEXT_COVERAGE_FULL;
+ }
+ else if (mt->format <= MTEXT_FORMAT_UTF_16BE)
+ {
+ if (c >= 0x110000)
+ mtext__adjust_format (mt, MTEXT_FORMAT_UTF_8);
+ else if (mt->format != MTEXT_FORMAT_UTF_16)
+ mtext__adjust_format (mt, MTEXT_FORMAT_UTF_16);
+ }
+ else if (mt->format != MTEXT_FORMAT_UTF_32)
+ mtext__adjust_format (mt, MTEXT_FORMAT_UTF_32);
- /* mtext__adjust_plist_for_change (mt, pos, pos + 1);*/
+ unit_bytes = UNIT_BYTES (mt->format);
+ pos_unit = POS_CHAR_TO_BYTE (mt, pos);
+ p = mt->data + pos_unit * unit_bytes;
+ old_units = CHAR_UNITS_AT (mt, p);
+ new_units = CHAR_UNITS (c, mt->format);
+ delta = new_units - old_units;
if (delta)
{
- int byte_pos_old = byte_pos + bytes_old;
- int byte_pos_new = byte_pos + bytes_new;
-
if (mt->cache_char_pos > pos)
mt->cache_byte_pos += delta;
- if ((mt->allocated - mt->nbytes) <= delta)
+ if ((mt->nbytes + delta + 1) * unit_bytes > mt->allocated)
{
- mt->allocated = mt->nbytes + delta + 1;
+ mt->allocated = (mt->nbytes + delta + 1) * unit_bytes;
MTABLE_REALLOC (mt->data, mt->allocated, MERROR_MTEXT);
}
- memmove (mt->data + byte_pos_old, mt->data + byte_pos_new,
- mt->nbytes - byte_pos_old);
+ memmove (mt->data + (pos_unit + new_units) * unit_bytes,
+ mt->data + (pos_unit + old_units) * unit_bytes,
+ (mt->nbytes - pos_unit - old_units + 1) * unit_bytes);
mt->nbytes += delta;
- mt->data[mt->nbytes] = 0;
+ mt->data[mt->nbytes * unit_bytes] = 0;
+ }
+ switch (mt->format)
+ {
+ case MTEXT_FORMAT_US_ASCII:
+ mt->data[pos_unit] = c;
+ break;
+ case MTEXT_FORMAT_UTF_8:
+ {
+ unsigned char *p = mt->data + pos_unit;
+ CHAR_STRING_UTF8 (c, p);
+ break;
+ }
+ default:
+ if (mt->format == MTEXT_FORMAT_UTF_16)
+ {
+ unsigned short *p = (unsigned short *) mt->data + pos_unit;
+
+ CHAR_STRING_UTF16 (c, p);
+ }
+ else
+ ((unsigned *) mt->data)[pos_unit] = c;
}
- for (i = 0; i < bytes_new; i++)
- mt->data[byte_pos + i] = str[i];
return 0;
}
M-text $MT ¤ÎËöÈø¤ËÄɲ乤롣
@return
- ¤³¤Î´Ø¿ô¤ÏÊѹ¹¤µ¤ì¤¿ M-text $MT ¤Ø¤Î¥Ý¥¤¥ó¥¿¤òÊÖ¤¹¡£$C ¤¬Àµ¤·¤¤Ê¸
- »ú¤Ç¤Ê¤¤¾ì¹ç¤Ë¤Ï @c NULL ¤òÊÖ¤¹¡£ */
+ ¤³¤Î´Ø¿ô¤ÏÊѹ¹¤µ¤ì¤¿ M-text $MT ¤Ø¤Î¥Ý¥¤¥ó¥¿¤òÊÖ¤¹¡£$C
+ ¤¬Àµ¤·¤¤Ê¸»ú¤Ç¤Ê¤¤¾ì¹ç¤Ë¤Ï @c NULL ¤òÊÖ¤¹¡£ */
/***
@seealso
MText *
mtext_cat_char (MText *mt, int c)
{
- unsigned char buf[MAX_UTF8_CHAR_BYTES];
- int nbytes;
- int total_bytes;
+ int nunits;
+ int unit_bytes = UNIT_BYTES (mt->format);
M_CHECK_READONLY (mt, NULL);
if (c < 0 || c > MCHAR_MAX)
return NULL;
- nbytes = CHAR_STRING (c, buf);
+ mtext__adjust_plist_for_insert (mt, mt->nchars, 1, NULL);
- total_bytes = mt->nbytes + nbytes;
+ if (c >= 0x80
+ && (mt->format == MTEXT_FORMAT_US_ASCII
+ || (c >= 0x10000
+ && (mt->format == MTEXT_FORMAT_UTF_16LE
+ || mt->format == MTEXT_FORMAT_UTF_16BE))))
- mtext__adjust_plist_for_insert (mt, mt->nchars, 1, NULL);
+ {
+ mtext__adjust_format (mt, MTEXT_FORMAT_UTF_8);
+ unit_bytes = 1;
+ }
+ else if (mt->format >= MTEXT_FORMAT_UTF_32LE)
+ {
+ if (mt->format != MTEXT_FORMAT_UTF_32)
+ mtext__adjust_format (mt, MTEXT_FORMAT_UTF_32);
+ }
+ else if (mt->format >= MTEXT_FORMAT_UTF_16LE)
+ {
+ if (mt->format != MTEXT_FORMAT_UTF_16)
+ mtext__adjust_format (mt, MTEXT_FORMAT_UTF_16);
+ }
- if (total_bytes >= mt->allocated)
+ nunits = CHAR_UNITS (c, mt->format);
+ if ((mt->nbytes + nunits + 1) * unit_bytes > mt->allocated)
{
- mt->allocated = total_bytes + 1;
+ mt->allocated = (mt->nbytes + nunits + 1) * unit_bytes;
MTABLE_REALLOC (mt->data, mt->allocated, MERROR_MTEXT);
}
- memcpy (mt->data + mt->nbytes, buf, nbytes);
- mt->nbytes = total_bytes;
+
+ if (mt->format <= MTEXT_FORMAT_UTF_8)
+ {
+ unsigned char *p = mt->data + mt->nbytes;
+ p += CHAR_STRING_UTF8 (c, p);
+ *p = 0;
+ }
+ else if (mt->format == MTEXT_FORMAT_UTF_16)
+ {
+ unsigned short *p = (unsigned short *) mt->data + mt->nbytes;
+ p += CHAR_STRING_UTF16 (c, p);
+ *p = 0;
+ }
+ else
+ {
+ unsigned *p = (unsigned *) mt->data + mt->nbytes;
+ *p++ = c;
+ *p = 0;
+ }
+
mt->nchars++;
- mt->data[total_bytes] = 0;
+ mt->nbytes += nunits;
return mt;
}
/***ja
@brief M-text ¤Î¥³¥Ô¡¼¤òºî¤ë.
- ´Ø¿ô mtext_dup () ¤Ï¡¢M-text $MT ¤Î¥³¥Ô¡¼¤òºî¤ë¡£$MT ¤Î¥Æ¥¥¹¥È¥×
- ¥í¥Ñ¥Æ¥£¤Ï¤¹¤Ù¤Æ·Ñ¾µ¤µ¤ì¤ë¡£
+ ´Ø¿ô mtext_dup () ¤Ï¡¢M-text $MT ¤Î¥³¥Ô¡¼¤òºî¤ë¡£$MT
+ ¤Î¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Ï¤¹¤Ù¤Æ·Ñ¾µ¤µ¤ì¤ë¡£
@return
¤³¤Î´Ø¿ô¤Ïºî¤é¤ì¤¿¥³¥Ô¡¼¤Ø¤Î¥Ý¥¤¥ó¥¿¤òÊÖ¤¹¡£
MText *
mtext_dup (MText *mt)
{
- return copy (mtext (), 0, mt, 0, mt->nchars);
+ return mtext_duplicate (mt, 0, mtext_nchars (mt));
}
/*=*/
/***ja
@brief 2¸Ä¤Î M-text¤òÏ¢·ë¤¹¤ë.
- ´Ø¿ô mtext_cat () ¤Ï¡¢ M-text $MT2 ¤ò M-text $MT1 ¤ÎËöÈø¤ËÉÕ¤±²Ã¤¨
- ¤ë¡£$MT2 ¤Î¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Ï¤¹¤Ù¤Æ·Ñ¾µ¤µ¤ì¤ë¡£$MT2 ¤ÏÊѹ¹¤µ¤ì¤Ê
- ¤¤¡£
+ ´Ø¿ô mtext_cat () ¤Ï¡¢ M-text $MT2 ¤ò M-text $MT1
+ ¤ÎËöÈø¤ËÉÕ¤±²Ã¤¨¤ë¡£$MT2 ¤Î¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Ï¤¹¤Ù¤Æ·Ñ¾µ¤µ¤ì¤ë¡£$MT2 ¤ÏÊѹ¹¤µ¤ì¤Ê¤¤¡£
@return
¤³¤Î´Ø¿ô¤ÏÊѹ¹¤µ¤ì¤¿ M-text $MT1 ¤Ø¤Î¥Ý¥¤¥ó¥¿¤òÊÖ¤¹¡£
{
M_CHECK_READONLY (mt1, NULL);
- return copy (mt1, mt1->nchars, mt2, 0, mt2->nchars);
+ if (mt2->nchars > 0)
+ insert (mt1, mt1->nchars, mt2, 0, mt2->nchars);
+ return mt1;
}
text properties. If the length of $MT2 is less than $N, all
characters are copied. $MT2 is not modified.
- @return
- If the operation was successful, mtext_ncat () returns a pointer
- to the resulting M-text $MT1. If an error is detected, it returns
- @c NULL and assigns an error code to the global variable @c
- merror_code. */
-
+ @return
+ If the operation was successful, mtext_ncat () returns a
+ pointer to the resulting M-text $MT1. If an error is detected, it
+ returns @c NULL and assigns an error code to the global variable
+ #merror_code. */
/***ja
@brief M-text ¤Î°ìÉô¤òÊ̤ΠM-text ¤ËÉղ乤ë.
´Ø¿ô mtext_ncat () ¤Ï¡¢M-text $MT2 ¤Î¤Ï¤¸¤á¤Î $N ʸ»ú¤ò M-text
- $MT1 ¤ÎËöÈø¤ËÉÕ¤±²Ã¤¨¤ë¡£$MT2 ¤Î¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Ï¤¹¤Ù¤Æ·Ñ¾µ¤µ¤ì
- ¤ë¡£$MT2 ¤ÎŤµ¤¬ $N °Ê²¼¤Ê¤é¤Ð¡¢$MT2 ¤Î¤¹¤Ù¤Æ¤Îʸ»ú¤¬Éղ䵤ì¤ë¡£
- $MT2 ¤ÏÊѹ¹¤µ¤ì¤Ê¤¤¡£
+ $MT1 ¤ÎËöÈø¤ËÉÕ¤±²Ã¤¨¤ë¡£$MT2 ¤Î¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Ï¤¹¤Ù¤Æ·Ñ¾µ¤µ¤ì¤ë¡£$MT2
+ ¤ÎŤµ¤¬ $N °Ê²¼¤Ê¤é¤Ð¡¢$MT2 ¤Î¤¹¤Ù¤Æ¤Îʸ»ú¤¬Éղ䵤ì¤ë¡£ $MT2 ¤ÏÊѹ¹¤µ¤ì¤Ê¤¤¡£
@return
- ½èÍý¤¬À®¸ù¤·¤¿¾ì¹ç¡¢mtext_ncat () ¤ÏÊѹ¹¤µ¤ì¤¿ M-text $MT1 ¤Ø¤Î¥Ý
- ¥¤¥ó¥¿¤òÊÖ¤¹¡£¥¨¥é¡¼¤¬¸¡½Ð¤µ¤ì¤¿¾ì¹ç¤Ï @c NULL ¤òÊÖ¤·¡¢³°ÉôÊÑ¿ô @c
- merror_code ¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£
+ ½èÍý¤¬À®¸ù¤·¤¿¾ì¹ç¡¢mtext_ncat () ¤ÏÊѹ¹¤µ¤ì¤¿ M-text $MT1
+ ¤Ø¤Î¥Ý¥¤¥ó¥¿¤òÊÖ¤¹¡£¥¨¥é¡¼¤¬¸¡½Ð¤µ¤ì¤¿¾ì¹ç¤Ï @c NULL ¤òÊÖ¤·¡¢³°ÉôÊÑ¿ô
+ #merror_code ¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£
@latexonly \IPAlabel{mtext_ncat} @endlatexonly */
M_CHECK_READONLY (mt1, NULL);
if (n < 0)
MERROR (MERROR_RANGE, NULL);
- return copy (mt1, mt1->nchars, mt2, 0, mt2->nchars < n ? mt2->nchars : n);
+ if (mt2->nchars > 0)
+ insert (mt1, mt1->nchars, mt2, 0, mt2->nchars < n ? mt2->nchars : n);
+ return mt1;
}
@brief M-text ¤òÊ̤ΠM-text ¤Ë¥³¥Ô¡¼¤¹¤ë.
´Ø¿ô mtext_cpy () ¤Ï M-text $MT2 ¤ò M-text $MT1 ¤Ë¾å½ñ¤¥³¥Ô¡¼¤¹¤ë¡£
- $MT2 ¤Î¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Ï¤¹¤Ù¤Æ·Ñ¾µ¤µ¤ì¤ë¡£$MT1 ¤ÎŤµ¤ÏɬÍפ˱þ
- ¤¸¤Æ¿¤Ð¤µ¤ì¤ë¡£$MT2 ¤ÏÊѹ¹¤µ¤ì¤Ê¤¤¡£
+ $MT2 ¤Î¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Ï¤¹¤Ù¤Æ·Ñ¾µ¤µ¤ì¤ë¡£$MT1
+ ¤ÎŤµ¤ÏɬÍפ˱þ¤¸¤Æ¿¤Ð¤µ¤ì¤ë¡£$MT2 ¤ÏÊѹ¹¤µ¤ì¤Ê¤¤¡£
@return
¤³¤Î´Ø¿ô¤ÏÊѹ¹¤µ¤ì¤¿ M-text $MT1 ¤Ø¤Î¥Ý¥¤¥ó¥¿¤òÊÖ¤¹¡£
mtext_cpy (MText *mt1, MText *mt2)
{
M_CHECK_READONLY (mt1, NULL);
- return copy (mt1, 0, mt2, 0, mt2->nchars);
+ mtext_del (mt1, 0, mt1->nchars);
+ if (mt2->nchars > 0)
+ insert (mt1, 0, mt2, 0, mt2->nchars);
+ return mt1;
}
/*=*/
@return
If the operation was successful, mtext_ncpy () returns a pointer
to the resulting M-text $MT1. If an error is detected, it returns
- @c NULL and assigns an error code to the global variable @c
- merror_code. */
+ @c NULL and assigns an error code to the global variable
+ #merror_code. */
/***ja
@brief M-text ¤Ë´Þ¤Þ¤ì¤ëºÇ½é¤Î²¿Ê¸»ú¤«¤ò¥³¥Ô¡¼¤¹¤ë.
´Ø¿ô mtext_ncpy () ¤Ï¡¢M-text $MT2 ¤ÎºÇ½é¤Î $N ʸ»ú¤ò M-text $MT1
- ¤Ë¾å½ñ¤¥³¥Ô¡¼¤¹¤ë¡£$MT2 ¤Î¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Ï¤¹¤Ù¤Æ·Ñ¾µ¤µ¤ì¤ë¡£
- ¤â¤· $MT2 ¤ÎŤµ¤¬ $N ¤è¤ê¤â¾®¤µ¤±¤ì¤Ð $MT2 ¤Î¤¹¤Ù¤Æ¤Îʸ»ú¤ò¥³¥Ô¡¼
- ¤¹¤ë¡£$MT1 ¤ÎŤµ¤ÏɬÍפ˱þ¤¸¤Æ¿¤Ð¤µ¤ì¤ë¡£$MT2 ¤ÏÊѹ¹¤µ¤ì¤Ê¤¤¡£
+ ¤Ë¾å½ñ¤¥³¥Ô¡¼¤¹¤ë¡£$MT2 ¤Î¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Ï¤¹¤Ù¤Æ·Ñ¾µ¤µ¤ì¤ë¡£¤â¤· $MT2
+ ¤ÎŤµ¤¬ $N ¤è¤ê¤â¾®¤µ¤±¤ì¤Ð $MT2 ¤Î¤¹¤Ù¤Æ¤Îʸ»ú¤ò¥³¥Ô¡¼¤¹¤ë¡£$MT1
+ ¤ÎŤµ¤ÏɬÍפ˱þ¤¸¤Æ¿¤Ð¤µ¤ì¤ë¡£$MT2 ¤ÏÊѹ¹¤µ¤ì¤Ê¤¤¡£
@return
- ½èÍý¤¬À®¸ù¤·¤¿¾ì¹ç¡¢mtext_ncpy () ¤ÏÊѹ¹¤µ¤ì¤¿ M-text $MT1 ¤Ø¤Î¥Ý
- ¥¤¥ó¥¿¤òÊÖ¤¹¡£¥¨¥é¡¼¤¬¸¡½Ð¤µ¤ì¤¿¾ì¹ç¤Ï @c NULL ¤òÊÖ¤·¡¢³°ÉôÊÑ¿ô @c
- merror_code ¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£
+ ½èÍý¤¬À®¸ù¤·¤¿¾ì¹ç¡¢mtext_ncpy () ¤ÏÊѹ¹¤µ¤ì¤¿ M-text $MT1
+ ¤Ø¤Î¥Ý¥¤¥ó¥¿¤òÊÖ¤¹¡£¥¨¥é¡¼¤¬¸¡½Ð¤µ¤ì¤¿¾ì¹ç¤Ï @c NULL ¤òÊÖ¤·¡¢³°ÉôÊÑ¿ô
+ #merror_code ¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£
@latexonly \IPAlabel{mtext_ncpy} @endlatexonly */
M_CHECK_READONLY (mt1, NULL);
if (n < 0)
MERROR (MERROR_RANGE, NULL);
- return (copy (mt1, 0, mt2, 0, mt2->nchars < n ? mt2->nchars : n));
+ mtext_del (mt1, 0, mt1->nchars);
+ if (mt2->nchars > 0)
+ insert (mt1, 0, mt2, 0, mt2->nchars < n ? mt2->nchars : n);
+ return mt1;
}
/*=*/
(exclusive) while inheriting all the text properties of $MT. $MT
itself is not modified.
- @return
- If the operation was successful, mtext_duplicate () returns a
- pointer to the created M-text. If an error is detected, it returns 0
- and assigns an error code to the external variable #merror_code. */
+ @return If the operation was successful, mtext_duplicate ()
+ returns a pointer to the created M-text. If an error is detected,
+ it returns NULL and assigns an error code to the external variable
+ #merror_code. */
/***ja
@brief ´û¸¤Î M-text ¤Î°ìÉô¤«¤é¿·¤·¤¤ M-text ¤ò¤Ä¤¯¤ë.
- ´Ø¿ô mtext_duplicate () ¤Ï¡¢M-text $MT ¤Î $FROM ¡Ê´Þ¤à¡Ë¤«¤é $TO
- ¡Ê´Þ¤Þ¤Ê¤¤¡Ë¤Þ¤Ç¤ÎÉôʬ¤Î¥³¥Ô¡¼¤òºî¤ë¡£¤³¤Î¤È¤ $MT ¤Î¥Æ¥¥¹¥È¥×¥í
- ¥Ñ¥Æ¥£¤Ï¤¹¤Ù¤Æ·Ñ¾µ¤µ¤ì¤ë¡£$MT ¤½¤Î¤â¤Î¤ÏÊѹ¹¤µ¤ì¤Ê¤¤¡£
+ ´Ø¿ô mtext_duplicate () ¤Ï¡¢M-text $MT ¤Î $FROM ¡Ê$FROM ¼«ÂΤâ´Þ¤à¡Ë¤«¤é
+ $TO ¡Ê$TO ¼«ÂΤϴޤޤʤ¤¡Ë¤Þ¤Ç¤ÎÉôʬ¤Î¥³¥Ô¡¼¤òºî¤ë¡£¤³¤Î¤È¤ $MT
+ ¤Î¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Ï¤¹¤Ù¤Æ·Ñ¾µ¤µ¤ì¤ë¡£$MT ¤½¤Î¤â¤Î¤ÏÊѹ¹¤µ¤ì¤Ê¤¤¡£
@return
- ½èÍý¤¬À®¸ù¤¹¤ì¤Ð¡¢mtext_duplicate () ¤Ïºî¤é¤ì¤¿ M-text ¤Ø¤Î¥Ý¥¤¥ó
- ¥¿¤òÊÖ¤¹¡£¥¨¥é¡¼¤¬¸¡½Ð¤µ¤ì¤¿¾ì¹ç¤Ï @c NULL ¤òÊÖ¤·¡¢³°ÉôÊÑ¿ô
+ ½èÍý¤¬À®¸ù¤¹¤ì¤Ð¡¢mtext_duplicate () ¤Ïºî¤é¤ì¤¿ M-text
+ ¤Ø¤Î¥Ý¥¤¥ó¥¿¤òÊÖ¤¹¡£¥¨¥é¡¼¤¬¸¡½Ð¤µ¤ì¤¿¾ì¹ç¤Ï @c NULL ¤òÊÖ¤·¡¢³°ÉôÊÑ¿ô
#merror_code ¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£
@latexonly \IPAlabel{mtext_duplicate} @endlatexonly */
MText *new = mtext ();
M_CHECK_RANGE (mt, from, to, NULL, new);
- return copy (new, 0, mt, from, to);
+ new->format = mt->format;
+ new->coverage = mt->coverage;
+ insert (new, 0, mt, from, to);
+ return new;
}
/*=*/
/***ja
@brief M-text ¤Ë»ØÄêÈϰϤÎʸ»ú¤ò¥³¥Ô¡¼¤¹¤ë.
- ´Ø¿ô mtext_copy () ¤Ï¡¢ M-text $MT2 ¤Î $FROM ¡Ê´Þ¤à¡Ë¤«¤é $TO ¡Ê´Þ
- ¤Þ¤Ê¤¤¡Ë¤Þ¤Ç¤ÎÈϰϤΥƥ¥¹¥È¤ò M-text $MT1 ¤Î°ÌÃÖ $POS ¤«¤é¾å½ñ¤
- ¥³¥Ô¡¼¤¹¤ë¡£$MT2 ¤Î¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Ï¤¹¤Ù¤Æ·Ñ¾µ¤µ¤ì¤ë¡£$MT1 ¤ÎĹ
- ¤µ¤ÏɬÍפ˱þ¤¸¤Æ¿¤Ð¤µ¤ì¤ë¡£$MT2 ¤ÏÊѹ¹¤µ¤ì¤Ê¤¤¡£
+ ´Ø¿ô mtext_copy () ¤Ï¡¢ M-text $MT2 ¤Î $FROM ¡Ê$FROM ¼«ÂΤâ´Þ¤à¡Ë¤«¤é
+ $TO ¡Ê$TO ¼«ÂΤϴޤޤʤ¤¡Ë¤Þ¤Ç¤ÎÈϰϤΥƥ¥¹¥È¤ò M-text $MT1 ¤Î°ÌÃÖ $POS
+ ¤«¤é¾å½ñ¤¥³¥Ô¡¼¤¹¤ë¡£$MT2 ¤Î¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Ï¤¹¤Ù¤Æ·Ñ¾µ¤µ¤ì¤ë¡£$MT1
+ ¤ÎŤµ¤ÏɬÍפ˱þ¤¸¤Æ¿¤Ð¤µ¤ì¤ë¡£$MT2 ¤ÏÊѹ¹¤µ¤ì¤Ê¤¤¡£
@latexonly \IPAlabel{mtext_copy} @endlatexonly
@return
- ½èÍý¤¬À®¸ù¤·¤¿¾ì¹ç¡¢mtext_copy () ¤ÏÊѹ¹¤µ¤ì¤¿ $MT1 ¤Ø¤Î¥Ý¥¤¥ó¥¿¤ò
- ÊÖ¤¹¡£¤½¤¦¤Ç¤Ê¤±¤ì¤Ð @c NULL ¤òÊÖ¤·¡¢³°ÉôÊÑ¿ô #merror_code ¤Ë¥¨¥é¡¼
- ¥³¡¼¥É¤òÀßÄꤹ¤ë¡£ */
+ ½èÍý¤¬À®¸ù¤·¤¿¾ì¹ç¡¢mtext_copy () ¤ÏÊѹ¹¤µ¤ì¤¿ $MT1
+ ¤Ø¤Î¥Ý¥¤¥ó¥¿¤òÊÖ¤¹¡£¤½¤¦¤Ç¤Ê¤±¤ì¤Ð @c NULL ¤òÊÖ¤·¡¢³°ÉôÊÑ¿ô #merror_code
+ ¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£ */
/***
@errors
{
M_CHECK_POS_X (mt1, pos, NULL);
M_CHECK_READONLY (mt1, NULL);
- M_CHECK_RANGE (mt2, from, to, NULL, mt1);
- return copy (mt1, pos, mt2, from, to);
+ M_CHECK_RANGE_X (mt2, from, to, NULL);
+ mtext_del (mt1, pos, mt1->nchars);
+ return insert (mt1, pos, mt2, from, to);
}
/*=*/
/***ja
@brief »ØÄêÈϰϤÎʸ»ú¤òÇ˲õŪ¤Ë¼è¤ê½ü¤¯.
- ´Ø¿ô mtext_del () ¤Ï¡¢M-text $MT ¤Î $FROM ¡Ê´Þ¤à¡Ë¤«¤é $TO ¡Ê´Þ¤Þ
- ¤Ê¤¤¡Ë¤Þ¤Ç¤Îʸ»ú¤òÇ˲õŪ¤Ë¼è¤ê½ü¤¯¡£·ë²ÌŪ¤Ë $MT ¤ÏŤµ¤¬ ($TO @c
+ ´Ø¿ô mtext_del () ¤Ï¡¢M-text $MT ¤Î $FROM ¡Ê$FROM ¼«ÂΤâ´Þ¤à¡Ë¤«¤é $TO
+ ¡Ê$TO ¼«ÂΤϴޤޤʤ¤¡Ë¤Þ¤Ç¤Îʸ»ú¤òÇ˲õŪ¤Ë¼è¤ê½ü¤¯¡£·ë²ÌŪ¤Ë $MT ¤ÏŤµ¤¬ ($TO @c
- $FROM) ¤À¤±½Ì¤à¤³¤È¤Ë¤Ê¤ë¡£
@return
- ½èÍý¤¬À®¸ù¤¹¤ì¤Ð mtext_del () ¤Ï 0 ¤òÊÖ¤¹¡£¤½¤¦¤Ç¤Ê¤±¤ì¤Ð -1 ¤òÊÖ
- ¤·¡¢³°ÉôÊÑ¿ô #merror_code ¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£ */
+ ½èÍý¤¬À®¸ù¤¹¤ì¤Ð mtext_del () ¤Ï 0 ¤òÊÖ¤¹¡£¤½¤¦¤Ç¤Ê¤±¤ì¤Ð -1
+ ¤òÊÖ¤·¡¢³°ÉôÊÑ¿ô #merror_code ¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£ */
/***
@errors
mtext_del (MText *mt, int from, int to)
{
int from_byte, to_byte;
+ int unit_bytes = UNIT_BYTES (mt->format);
M_CHECK_READONLY (mt, -1);
M_CHECK_RANGE (mt, from, to, -1, 0);
}
mtext__adjust_plist_for_delete (mt, from, to - from);
- memmove (mt->data + from_byte, mt->data + to_byte, mt->nbytes - to_byte + 1);
+ memmove (mt->data + from_byte * unit_bytes,
+ mt->data + to_byte * unit_bytes,
+ (mt->nbytes - to_byte + 1) * unit_bytes);
mt->nchars -= (to - from);
mt->nbytes -= (to_byte - from_byte);
mt->cache_char_pos = from;
/***ja
@brief M-text ¤òÊ̤ΠM-text ¤ËÁÞÆþ¤¹¤ë.
- ´Ø¿ô mtext_ins () ¤Ï M-text $MT1 ¤Î $POS ¤Î°ÌÃÖ¤Ë Ê̤ΠM-text $MT2
- ¤òÁÞÆþ¤¹¤ë¡£¤³¤Î·ë²Ì $MT1 ¤ÎŤµ¤Ï $MT2 ¤ÎŤµÊ¬¤À¤±Áý¤¨¤ë¡£ÁÞÆþ¤Î
- ºÝ¡¢$MT2 ¤Î¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Ï¤¹¤Ù¤Æ·Ñ¾µ¤µ¤ì¤ë¡£$MT2 ¤½¤Î¤â¤Î¤ÏÊÑ
- ¹¹¤µ¤ì¤Ê¤¤¡£
+ ´Ø¿ô mtext_ins () ¤Ï M-text $MT1 ¤Î $POS ¤Î°ÌÃÖ¤ËÊ̤ΠM-text $MT2
+ ¤òÁÞÆþ¤¹¤ë¡£¤³¤Î·ë²Ì $MT1 ¤ÎŤµ¤Ï $MT2 ¤ÎŤµÊ¬¤À¤±Áý¤¨¤ë¡£ÁÞÆþ¤ÎºÝ¡¢$MT2
+ ¤Î¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Ï¤¹¤Ù¤Æ·Ñ¾µ¤µ¤ì¤ë¡£$MT2 ¤½¤Î¤â¤Î¤ÏÊѹ¹¤µ¤ì¤Ê¤¤¡£
@return
- ½èÍý¤¬À®¸ù¤¹¤ì¤Ð mtext_ins () ¤Ï 0 ¤òÊÖ¤¹¡£¤½¤¦¤Ç¤Ê¤±¤ì¤Ð -1 ¤òÊÖ
- ¤·¡¢³°ÉôÊÑ¿ô #merror_code ¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£ */
+ ½èÍý¤¬À®¸ù¤¹¤ì¤Ð mtext_ins () ¤Ï 0 ¤òÊÖ¤¹¡£¤½¤¦¤Ç¤Ê¤±¤ì¤Ð -1
+ ¤òÊÖ¤·¡¢³°ÉôÊÑ¿ô #merror_code ¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£ */
/***
@errors
- @c MERROR_RANGE
+ @c MERROR_RANGE , @c MERROR_MTEXT
@seealso
- mtext_del () */
+ mtext_del () , mtext_insert () */
int
mtext_ins (MText *mt1, int pos, MText *mt2)
{
- int byte_pos;
- int total_bytes;
-
M_CHECK_READONLY (mt1, -1);
M_CHECK_POS_X (mt1, pos, -1);
if (mt2->nchars == 0)
return 0;
- mtext__adjust_plist_for_insert
- (mt1, pos, mt2->nchars,
- mtext__copy_plist (mt2->plist, 0, mt2->nchars, mt1, pos));
-
- total_bytes = mt1->nbytes + mt2->nbytes;
- if (total_bytes >= mt1->allocated)
- {
- mt1->allocated = total_bytes + 1;
- MTABLE_REALLOC (mt1->data, mt1->allocated, MERROR_MTEXT);
- }
- byte_pos = POS_CHAR_TO_BYTE (mt1, pos);
- if (mt1->cache_char_pos > pos)
- {
- mt1->cache_char_pos += mt2->nchars;
- mt1->cache_byte_pos += mt2->nbytes;
- }
- memmove (mt1->data + byte_pos + mt2->nbytes, mt1->data + byte_pos,
- mt1->nbytes - byte_pos + 1);
- memcpy (mt1->data + byte_pos, mt2->data, mt2->nbytes);
- mt1->nbytes += mt2->nbytes;
- mt1->nchars += mt2->nchars;
+ insert (mt1, pos, mt2, 0, mt2->nchars);
return 0;
}
+/*=*/
+
+/***en
+ @brief Insert sub-text of an M-text into another M-text.
+
+ The mtext_insert () function inserts sub-text of M-text $MT2
+ between $FROM (inclusive) and $TO (exclusive) into M-text $MT1, at
+ position $POS. As a result, $MT1 is lengthen by ($TO - $FROM).
+ On insertion, all the text properties of the sub-text of $MT2 are
+ inherited.
+
+ @return If the operation was successful, mtext_insert () returns
+ 0. Otherwise, it returns -1 and assigns an error code to the
+ external variable #merror_code. */
+
+/***ja
+ @brief M-text ¤Î°ìÉô¤òÊ̤ΠM-text ¤ËÁÞÆþ¤¹¤ë.
+
+ ´Ø¿ô mtext_insert () ¤Ï M-text $MT1 Ãæ¤Î $POS ¤Î°ÌÃ֤ˡ¢Ê̤Î
+ M-text $MT2 ¤Î $FROM ¡Ê$FROM ¼«ÂΤâ´Þ¤à¡Ë¤«¤é $TO ¡Ê$TO ¼«ÂΤϴޤÞ
+ ¤Ê¤¤¡Ë¤Þ¤Ç¤Îʸ»ú¤òÁÞÆþ¤¹¤ë¡£·ë²ÌŪ¤Ë $MT1 ¤ÏŤµ¤¬ ($TO - $FROM)
+ ¤À¤±¿¤Ó¤ë¡£ÁÞÆþ¤ÎºÝ¡¢ $MT2 Ãæ¤Î¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Ï¤¹¤Ù¤Æ·Ñ¾µ¤µ¤ì
+ ¤ë¡£
+
+ @return
+ ½èÍý¤¬À®¸ù¤¹¤ì¤Ð¡¢mtext_insert () ¤Ï 0 ¤òÊÖ¤¹¡£¤½¤¦¤Ç¤Ê¤±¤ì¤Ð -1
+ ¤òÊÖ¤·¡¢³°ÉôÊÑ¿ô #merror_code ¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£ */
+
+/***
+ @errors
+ @c MERROR_MTEXT , @c MERROR_RANGE
+
+ @seealso
+ mtext_ins () */
+
+int
+mtext_insert (MText *mt1, int pos, MText *mt2, int from, int to)
+{
+ M_CHECK_READONLY (mt1, -1);
+ M_CHECK_POS_X (mt1, pos, -1);
+ M_CHECK_RANGE (mt2, from, to, -1, 0);
+
+ insert (mt1, pos, mt2, from, to);
+ return 0;
+}
/*=*/
/***ja
@brief M-text ¤Ëʸ»ú¤òÁÞÆþ¤¹¤ë.
- ´Ø¿ô mtext_ins_char () ¤Ï M-text $MT ¤Î $POS ¤Î°ÌÃÖ¤Ëʸ»ú $C ¤ò $N
+ ´Ø¿ô mtext_ins_char () ¤Ï M-text $MT ¤Î $POS ¤Î°ÌÃÖ¤Ëʸ»ú $C ¤Î¥³¥Ô¡¼¤ò $N
¸ÄÁÞÆþ¤¹¤ë¡£¤³¤Î·ë²Ì $MT1 ¤ÎŤµ¤Ï $N ¤À¤±Áý¤¨¤ë¡£
@return
int
mtext_ins_char (MText *mt, int pos, int c, int n)
{
- int byte_pos;
- int nbytes, total_bytes;
- unsigned char *buf;
+ int nunits;
+ int unit_bytes = UNIT_BYTES (mt->format);
+ int pos_unit;
int i;
M_CHECK_READONLY (mt, -1);
if (n <= 0)
return 0;
mtext__adjust_plist_for_insert (mt, pos, n, NULL);
- buf = alloca (MAX_UTF8_CHAR_BYTES * n);
- for (i = 0, nbytes = 0; i < n; i++)
- nbytes += CHAR_STRING (c, buf + nbytes);
- total_bytes = mt->nbytes + nbytes;
- if (total_bytes >= mt->allocated)
+
+ if (c >= 0x80
+ && (mt->format == MTEXT_FORMAT_US_ASCII
+ || (c >= 0x10000 && (mt->format == MTEXT_FORMAT_UTF_16LE
+ || mt->format == MTEXT_FORMAT_UTF_16BE))))
+ {
+ mtext__adjust_format (mt, MTEXT_FORMAT_UTF_8);
+ unit_bytes = 1;
+ }
+ else if (mt->format >= MTEXT_FORMAT_UTF_32LE)
+ {
+ if (mt->format != MTEXT_FORMAT_UTF_32)
+ mtext__adjust_format (mt, MTEXT_FORMAT_UTF_32);
+ }
+ else if (mt->format >= MTEXT_FORMAT_UTF_16LE)
{
- mt->allocated = total_bytes + 1;
+ if (mt->format != MTEXT_FORMAT_UTF_16)
+ mtext__adjust_format (mt, MTEXT_FORMAT_UTF_16);
+ }
+
+ nunits = CHAR_UNITS (c, mt->format);
+ if ((mt->nbytes + nunits * n + 1) * unit_bytes > mt->allocated)
+ {
+ mt->allocated = (mt->nbytes + nunits * n + 1) * unit_bytes;
MTABLE_REALLOC (mt->data, mt->allocated, MERROR_MTEXT);
}
- byte_pos = POS_CHAR_TO_BYTE (mt, pos);
+ pos_unit = POS_CHAR_TO_BYTE (mt, pos);
if (mt->cache_char_pos > pos)
{
- mt->cache_char_pos++;
- mt->cache_byte_pos += nbytes;
+ mt->cache_char_pos += n;
+ mt->cache_byte_pos += nunits * n;
+ }
+ memmove (mt->data + (pos_unit + nunits * n) * unit_bytes,
+ mt->data + pos_unit * unit_bytes,
+ (mt->nbytes - pos_unit + 1) * unit_bytes);
+ if (mt->format <= MTEXT_FORMAT_UTF_8)
+ {
+ unsigned char *p = mt->data + pos_unit;
+
+ for (i = 0; i < n; i++)
+ p += CHAR_STRING_UTF8 (c, p);
+ }
+ else if (mt->format == MTEXT_FORMAT_UTF_16)
+ {
+ unsigned short *p = (unsigned short *) mt->data + pos_unit;
+
+ for (i = 0; i < n; i++)
+ p += CHAR_STRING_UTF16 (c, p);
+ }
+ else
+ {
+ unsigned *p = (unsigned *) mt->data + pos_unit;
+
+ for (i = 0; i < n; i++)
+ *p++ = c;
}
- memmove (mt->data + byte_pos + nbytes, mt->data + byte_pos,
- mt->nbytes - byte_pos + 1);
- memcpy (mt->data + byte_pos, buf, nbytes);
- mt->nbytes += nbytes;
mt->nchars += n;
+ mt->nbytes += nunits * n;
+ return 0;
+}
+
+/*=*/
+
+/***en
+ @brief Replace sub-text of M-text with another.
+
+ The mtext_replace () function replaces sub-text of M-text $MT1
+ between $FROM1 (inclusive) and $TO1 (exclusinve) with the sub-text
+ of M-text $MT2 between $FROM2 (inclusive) and $TO2 (exclusinve).
+ The new sub-text inherits text properties of the old sub-text.
+
+ @return If the operation was successful, mtext_replace () returns
+ 0. Otherwise, it returns -1 and assigns an error code to the
+ external variable #merror_code. */
+
+/***ja
+ @brief M-text ¤Î°ìÉô¤òÊ̤ΠM-text ¤Î°ìÉô¤ÇÃÖ´¹¤¹¤ë.
+
+ ´Ø¿ô mtext_replace () ¤Ï¡¢ M-text $MT1 ¤Î $FROM1 ¡Ê$FROM1 ¼«ÂΤâ´Þ
+ ¤à¡Ë¤«¤é $TO1 ¡Ê$TO1 ¼«ÂΤϴޤޤʤ¤¡Ë¤Þ¤Ç¤ò¡¢ M-text $MT2 ¤Î
+ $FROM2 ¡Ê$FROM2 ¼«ÂΤâ´Þ¤à¡Ë¤«¤é $TO2 ¡Ê$TO2 ¼«ÂΤϴޤޤʤ¤¡Ë¤ÇÃÖ
+ ¤´¹¤¨¤ë¡£¿·¤·¤¯ÁÞÆþ¤µ¤ì¤¿Éôʬ¤Ï¡¢ÃÖ¤´¹¤¨¤ëÁ°¤Î¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£
+ ¤¹¤Ù¤Æ¤ò·Ñ¾µ¤¹¤ë¡£
+
+ @return ½èÍý¤¬À®¸ù¤¹¤ì¤Ð¡¢ mtext_replace () ¤Ï 0 ¤òÊÖ¤¹¡£¤½¤¦¤Ç¤Ê
+ ¤±¤ì¤Ð -1 ¤òÊÖ¤·¡¢³°ÉôÊÑ¿ô #merror_code ¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£ */
+
+/***
+ @errors
+ @c MERROR_MTEXT , @c MERROR_RANGE
+
+ @seealso
+ mtext_insert () */
+
+int
+mtext_replace (MText *mt1, int from1, int to1,
+ MText *mt2, int from2, int to2)
+{
+ int len1, len2;
+ int from1_byte, from2_byte, old_bytes, new_bytes;
+ int unit_bytes, total_bytes;
+ unsigned char *p;
+ int free_mt2 = 0;
+
+ M_CHECK_READONLY (mt1, -1);
+ M_CHECK_RANGE_X (mt1, from1, to1, -1);
+ M_CHECK_RANGE_X (mt2, from2, to2, -1);
+
+ if (from1 == to1)
+ {
+ struct MTextPlist *saved = mt2->plist;
+
+ mt2->plist = NULL;
+ insert (mt1, from1, mt2, from2, to2);
+ mt2->plist = saved;
+ return 0;
+ }
+
+ if (from2 == to2)
+ {
+ return mtext_del (mt1, from1, to1);
+ }
+
+ if (mt1 == mt2)
+ {
+ mt2 = mtext_duplicate (mt2, from2, to2);
+ to2 -= from2;
+ from2 = 0;
+ free_mt2 = 1;
+ }
+
+ if (mt1->format != mt2->format
+ && mt1->format == MTEXT_FORMAT_US_ASCII)
+ mt1->format = MTEXT_FORMAT_UTF_8;
+ if (mt1->format != mt2->format
+ && mt1->coverage < mt2->coverage)
+ mtext__adjust_format (mt1, mt2->format);
+ if (mt1->format != mt2->format)
+ {
+ mt2 = mtext_duplicate (mt2, from2, to2);
+ mtext__adjust_format (mt2, mt1->format);
+ to2 -= from2;
+ from2 = 0;
+ free_mt2 = 1;
+ }
+
+ len1 = to1 - from1;
+ len2 = to2 - from2;
+ mtext__adjust_plist_for_change (mt1, from1, len1, len2);
+
+ unit_bytes = UNIT_BYTES (mt1->format);
+ from1_byte = POS_CHAR_TO_BYTE (mt1, from1) * unit_bytes;
+ from2_byte = POS_CHAR_TO_BYTE (mt2, from2) * unit_bytes;
+ old_bytes = POS_CHAR_TO_BYTE (mt1, to1) * unit_bytes - from1_byte;
+ new_bytes = POS_CHAR_TO_BYTE (mt2, to2) * unit_bytes - from2_byte;
+ total_bytes = mt1->nbytes * unit_bytes + (new_bytes - old_bytes);
+ if (total_bytes + unit_bytes > mt1->allocated)
+ {
+ mt1->allocated = total_bytes + unit_bytes;
+ MTABLE_REALLOC (mt1->data, mt1->allocated, MERROR_MTEXT);
+ }
+ p = mt1->data + from1_byte;
+ if (to1 < mt1->nchars
+ && old_bytes != new_bytes)
+ memmove (p + new_bytes, p + old_bytes,
+ (mt1->nbytes + 1) * unit_bytes - (from1_byte + old_bytes));
+ memcpy (p, mt2->data + from2_byte, new_bytes);
+ mt1->nchars += len2 - len1;
+ mt1->nbytes += (new_bytes - old_bytes) / unit_bytes;
+ if (mt1->cache_char_pos >= to1)
+ {
+ mt1->cache_char_pos += len2 - len1;
+ mt1->cache_byte_pos += new_bytes - old_bytes;
+ }
+ else if (mt1->cache_char_pos > from1)
+ {
+ mt1->cache_char_pos = from1;
+ mt1->cache_byte_pos = from1_byte;
+ }
+
+ if (free_mt2)
+ M17N_OBJECT_UNREF (mt2);
return 0;
}
´Ø¿ô mtext_character () ¤Ï M-text $MT Ãæ¤Çʸ»ú $C ¤òõ¤¹¡£¤â¤·
$FROM ¤¬ $TO ¤è¤ê¾®¤µ¤±¤ì¤Ð¡¢Ãµº÷¤Ï°ÌÃÖ $FROM ¤«¤éËöÈøÊý¸þ¤Ø¡¢ºÇÂç
- ($TO - 1) ¤Þ¤Ç¿Ê¤à¡£¤½¤¦¤Ç¤Ê¤±¤ì¤Ð°ÌÃÖ ($FROM - 1) ¤«¤éÀèƬÊý¸þ¤Ø¡¢
- ºÇÂç $TO ¤Þ¤Ç¿Ê¤à¡£°ÌÃ֤λØÄê¤Ë¸í¤ê¤¬¤¢¤ë¾ì¹ç¤Ï¡¢$FROM ¤È $TO ¤Îξ
- Êý¤Ë 0 ¤¬»ØÄꤵ¤ì¤¿¤â¤Î¤È¸«¤Ê¤¹¡£
+ ($TO - 1) ¤Þ¤Ç¿Ê¤à¡£¤½¤¦¤Ç¤Ê¤±¤ì¤Ð°ÌÃÖ ($FROM - 1) ¤«¤éÀèƬÊý¸þ¤Ø¡¢ºÇÂç
+ $TO ¤Þ¤Ç¿Ê¤à¡£°ÌÃ֤λØÄê¤Ë¸í¤ê¤¬¤¢¤ë¾ì¹ç¤Ï¡¢$FROM ¤È $TO
+ ¤ÎξÊý¤Ë 0 ¤¬»ØÄꤵ¤ì¤¿¤â¤Î¤È¤ß¤Ê¤¹¡£
@return
- ¤â¤· $C ¤¬¸«¤Ä¤«¤ì¤Ð¡¢mtext_character () ¤Ï¤½¤ÎºÇ½é¤Î½Ð¸½°ÌÃÖ¤òÊÖ
- ¤¹¡£¸«¤Ä¤«¤é¤Ê¤«¤Ã¤¿¾ì¹ç¤Ï³°ÉôÊÑ¿ô #merror_code ¤òÊѹ¹¤»¤º¤Ë -1 ¤òÊÖ
- ¤¹¡£¥¨¥é¡¼¤¬¸¡½Ð¤µ¤ì¤¿¾ì¹ç¤Ï -1 ¤òÊÖ¤·¡¢³°ÉôÊÑ¿ô #merror_code ¤Ë¥¨¥é¡¼
- ¥³¡¼¥É¤òÀßÄꤹ¤ë¡£ */
+ ¤â¤· $C ¤¬¸«¤Ä¤«¤ì¤Ð¡¢mtext_character ()
+ ¤Ï¤½¤ÎºÇ½é¤Î½Ð¸½°ÌÃÖ¤òÊÖ¤¹¡£¸«¤Ä¤«¤é¤Ê¤«¤Ã¤¿¾ì¹ç¤Ï³°ÉôÊÑ¿ô #merror_code
+ ¤òÊѹ¹¤»¤º¤Ë -1 ¤òÊÖ¤¹¡£¥¨¥é¡¼¤¬¸¡½Ð¤µ¤ì¤¿¾ì¹ç¤Ï -1 ¤òÊÖ¤·¡¢³°ÉôÊÑ¿ô
+ #merror_code ¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£ */
/***
@seealso
/***ja
@brief M-text Ãæ¤Ç»ØÄꤵ¤ì¤¿Ê¸»ú¤¬ºÇ½é¤Ë¸½¤ì¤ë°ÌÃÖ¤òÊÖ¤¹.
- ´Ø¿ô mtext_chr () ¤Ï M-text $MT Ãæ¤Çʸ»ú $C ¤òõ¤¹¡£Ãµº÷¤Ï $MT ¤Î
- ÀèƬ¤«¤éËöÈøÊý¸þ¤Ë¿Ê¤à¡£
+ ´Ø¿ô mtext_chr () ¤Ï M-text $MT Ãæ¤Çʸ»ú $C ¤òõ¤¹¡£Ãµº÷¤Ï $MT
+ ¤ÎÀèƬ¤«¤éËöÈøÊý¸þ¤Ë¿Ê¤à¡£
@return
- ¤â¤· $C ¤¬¸«¤Ä¤«¤ì¤Ð¡¢mtext_chr () ¤Ï¤½¤Î½Ð¸½°ÌÃÖ¤òÊÖ¤¹¡£¸«¤Ä¤«¤é
- ¤Ê¤«¤Ã¤¿¾ì¹ç¤Ï -1 ¤òÊÖ¤¹¡£
+ ¤â¤· $C ¤¬¸«¤Ä¤«¤ì¤Ð¡¢mtext_chr ()
+ ¤Ï¤½¤Î½Ð¸½°ÌÃÖ¤òÊÖ¤¹¡£¸«¤Ä¤«¤é¤Ê¤«¤Ã¤¿¾ì¹ç¤Ï -1 ¤òÊÖ¤¹¡£
@latexonly \IPAlabel{mtext_chr} @endlatexonly */
/***ja
@brief M-text Ãæ¤Ç»ØÄꤵ¤ì¤¿Ê¸»ú¤¬ºÇ¸å¤Ë¸½¤ì¤ë°ÌÃÖ¤òÊÖ¤¹.
- ´Ø¿ô mtext_rchr () ¤Ï M-text $MT Ãæ¤Çʸ»ú $C ¤òõ¤¹¡£Ãµº÷¤Ï $MT ¤Î
- ºÇ¸å¤«¤éÀèƬÊý¸þ¤Ø¤È¸å¸þ¤¤Ë¿Ê¤à¡£
+ ´Ø¿ô mtext_rchr () ¤Ï M-text $MT Ãæ¤Çʸ»ú $C ¤òõ¤¹¡£Ãµº÷¤Ï $MT
+ ¤ÎºÇ¸å¤«¤éÀèƬÊý¸þ¤Ø¤È¸å¸þ¤¤Ë¿Ê¤à¡£
@return
- ¤â¤· $C ¤¬¸«¤Ä¤«¤ì¤Ð¡¢mtext_rchr () ¤Ï¤½¤Î½Ð¸½°ÌÃÖ¤òÊÖ¤¹¡£¸«¤Ä¤«¤é
- ¤Ê¤«¤Ã¤¿¾ì¹ç¤Ï -1 ¤òÊÖ¤¹¡£
+ ¤â¤· $C ¤¬¸«¤Ä¤«¤ì¤Ð¡¢mtext_rchr ()
+ ¤Ï¤½¤Î½Ð¸½°ÌÃÖ¤òÊÖ¤¹¡£¸«¤Ä¤«¤é¤Ê¤«¤Ã¤¿¾ì¹ç¤Ï -1 ¤òÊÖ¤¹¡£
@latexonly \IPAlabel{mtext_rchr} @endlatexonly */
´Ø¿ô mtext_cmp () ¤Ï¡¢ M-text $MT1 ¤È $MT2 ¤òʸ»úñ°Ì¤ÇÈæ³Ó¤¹¤ë¡£
@return
- ¤³¤Î´Ø¿ô¤Ï¡¢$MT1 ¤È $MT2 ¤¬Åù¤·¤±¤ì¤Ð 0¡¢$MT1 ¤¬ $MT2 ¤è¤êÂ礤±¤ì
- ¤Ð 1¡¢$MT1 ¤¬ $MT2 ¤è¤ê¾®¤µ¤±¤ì¤Ð -1 ¤òÊÖ¤¹¡£Èæ³Ó¤Ïʸ»ú¥³¡¼¥É¤Ë´ð¤Å
- ¤¯¡£
+ ¤³¤Î´Ø¿ô¤Ï¡¢$MT1 ¤È $MT2 ¤¬Åù¤·¤±¤ì¤Ð 0¡¢$MT1 ¤¬ $MT2 ¤è¤êÂ礤±¤ì¤Ð
+ 1¡¢$MT1 ¤¬ $MT2 ¤è¤ê¾®¤µ¤±¤ì¤Ð -1 ¤òÊÖ¤¹¡£Èæ³Ó¤Ïʸ»ú¥³¡¼¥É¤Ë´ð¤Å¤¯¡£
@latexonly \IPAlabel{mtext_cmp} @endlatexonly */
/***ja
@brief Æó¤Ä¤Î M-text ¤ÎÀèƬÉôʬ¤òʸ»úñ°Ì¤ÇÈæ³Ó¤¹¤ë.
- ´Ø¿ô mtext_ncmp () ¤Ï¡¢´Ø¿ô mtext_cmp () ƱÍͤΠM-text Ʊ»Î¤ÎÈæ³Ó
- ¤òÀèƬ¤«¤éºÇÂç $N ʸ»ú¤Þ¤Ç¤Ë´Ø¤·¤Æ¹Ô¤Ê¤¦¡£
+ ´Ø¿ô mtext_ncmp () ¤Ï¡¢´Ø¿ô mtext_cmp () ƱÍͤΠM-text
+ Ʊ»Î¤ÎÈæ³Ó¤òÀèƬ¤«¤éºÇÂç $N ʸ»ú¤Þ¤Ç¤Ë´Ø¤·¤Æ¹Ô¤Ê¤¦¡£
@return
- ¤³¤Î´Ø¿ô¤Ï¡¢$MT1 ¤È $MT2 ¤¬Åù¤·¤±¤ì¤Ð 0¡¢$MT1 ¤¬ $MT2 ¤è¤êÂ礤±¤ì
- ¤Ð 1¡¢$MT1 ¤¬ $MT2 ¤è¤ê¾®¤µ¤±¤ì¤Ð -1 ¤òÊÖ¤¹¡£
+ ¤³¤Î´Ø¿ô¤Ï¡¢$MT1 ¤È $MT2 ¤¬Åù¤·¤±¤ì¤Ð 0¡¢$MT1 ¤¬ $MT2 ¤è¤êÂ礤±¤ì¤Ð
+ 1¡¢$MT1 ¤¬ $MT2 ¤è¤ê¾®¤µ¤±¤ì¤Ð -1 ¤òÊÖ¤¹¡£
@latexonly \IPAlabel{mtext_ncmp} @endlatexonly */
/***ja
@brief Æó¤Ä¤Î M-text ¤Î»ØÄꤷ¤¿ÎΰèƱ»Î¤òÈæ³Ó¤¹¤ë.
- ´Ø¿ô mtext_compare () ¤ÏÆó¤Ä¤Î M-text $MT1 ¤È $MT2 ¤òʸ»úñ°Ì¤ÇÈæ
- ³Ó¤¹¤ë¡£Èæ³ÓÂоݤȤʤë¤Î¤Ï $MT1 ¤Ç¤Ï $FROM1 ¤«¤é $TO1 ¤Þ¤Ç¡¢$MT2
- ¤Ç¤Ï $FROM2 ¤«¤é $TO2 ¤Þ¤Ç¤Ç¤¢¤ë¡£$FROM1 ¤È $FROM2 ¤Ï´Þ¤Þ¤ì¡¢$TO1
- ¤È $TO2 ¤Ï´Þ¤Þ¤ì¤Ê¤¤¡£$FROM1 ¤È $TO1 ¡Ê¤¢¤ë¤¤¤Ï $FROM2 ¤È $TO2 ¡Ë
- ¤¬Åù¤·¤¤¾ì¹ç¤ÏŤµ¥¼¥í¤Î M-text ¤ò°ÕÌ£¤¹¤ë¡£ÈÏ°Ï»ØÄê¤Ë¸í¤ê¤¬¤¢¤ë¾ì
- ¹ç¤Ï¡¢$FROM1 ¤È $TO1 ¡Ê¤¢¤ë¤¤¤Ï $FROM2 ¤È $TO2 ¡Ë ξÊý¤Ë 0 ¤¬»ØÄꤵ
- ¤ì¤¿¤â¤Î¤È¸«¤Ê¤¹¡£
+ ´Ø¿ô mtext_compare () ¤ÏÆó¤Ä¤Î M-text $MT1 ¤È $MT2
+ ¤òʸ»úñ°Ì¤ÇÈæ³Ó¤¹¤ë¡£Èæ³Ó¤ÎÂÐ¾Ý¤Ï $MT1 ¤Î¤¦¤Á $FROM1 ¤«¤é $TO1 ¤Þ¤Ç¤È¡¢$MT2
+ ¤Î¤¦¤Á $FROM2 ¤«¤é $TO2 ¤Þ¤Ç¤Ç¤¢¤ë¡£$FROM1 ¤È $FROM2 ¤Ï´Þ¤Þ¤ì¡¢$TO1
+ ¤È $TO2 ¤Ï´Þ¤Þ¤ì¤Ê¤¤¡£$FROM1 ¤È $TO1 ¡Ê¤¢¤ë¤¤¤Ï $FROM2 ¤È $TO2
+ ¡Ë¤¬Åù¤·¤¤¾ì¹ç¤ÏŤµ¥¼¥í¤Î M-text ¤ò°ÕÌ£¤¹¤ë¡£ÈÏ°Ï»ØÄê¤Ë¸í¤ê¤¬¤¢¤ë¾ì¹ç¤Ï¡¢
+ $FROM1 ¤È $TO1 ¡Ê¤¢¤ë¤¤¤Ï $FROM2 ¤È $TO2 ¡Ë ξÊý¤Ë 0 ¤¬»ØÄꤵ¤ì¤¿¤â¤Î¤È¤ß¤Ê¤¹¡£
@return
- ¤³¤Î´Ø¿ô¤Ï¡¢$MT1 ¤È $MT2 ¤¬Åù¤·¤±¤ì¤Ð 0¡¢$MT1 ¤¬ $MT2 ¤è¤êÂ礤±¤ì
- ¤Ð 1 ¡¢$MT1 ¤¬ $MT2 ¤è¤ê¾®¤µ¤±¤ì¤Ð -1 ¤òÊÖ¤¹¡£Èæ³Ó¤Ïʸ»ú¥³¡¼¥É¤Ë´ð
- ¤Å¤¯¡£ */
+ ¤³¤Î´Ø¿ô¤Ï¡¢$MT1 ¤È $MT2 ¤¬Åù¤·¤±¤ì¤Ð 0¡¢$MT1 ¤¬ $MT2 ¤è¤êÂ礤±¤ì¤Ð
+ 1 ¡¢$MT1 ¤¬ $MT2 ¤è¤ê¾®¤µ¤±¤ì¤Ð -1 ¤òÊÖ¤¹¡£Èæ³Ó¤Ïʸ»ú¥³¡¼¥É¤Ë´ð¤Å¤¯¡£ */
/***
@seealso
/***ja
@brief ¤¢¤ë½¸¹ç¤Îʸ»ú¤ò M-text ¤ÎÃæ¤Çõ¤¹.
- ´Ø¿ô mtext_spn () ¤Ï¡¢M-text $MT1 ¤ÎÀèƬÉôʬ¤Ç M-text $MT2 ¤Ë´Þ¤Þ
- ¤ì¤ëʸ»ú¤À¤±¤Ç¤Ç¤¤Æ¤¤¤ëÉôʬ¤ÎºÇÂ獵¤òÊÖ¤¹¡£
+ ´Ø¿ô mtext_spn () ¤Ï¡¢M-text $MT1 ¤ÎÀèƬ¤«¤é M-text $MT2
+ ¤Ë´Þ¤Þ¤ì¤ëʸ»ú¤À¤±¤Ç¤Ç¤¤Æ¤¤¤ëÉôʬ¤ÎŤµ¤òÊÖ¤¹¡£
@latexonly \IPAlabel{mtext_spn} @endlatexonly */
/***ja
@brief ¤¢¤ë½¸¹ç¤Ë°¤µ¤Ê¤¤Ê¸»ú¤ò M-text ¤ÎÃæ¤Çõ¤¹.
- ´Ø¿ô mtext_cspn () ¤Ï¡¢M-text $MT1 ¤ÎÀèƬÉôʬ¤Ç M-text $MT2 ¤Ë´Þ¤Þ
- ¤ì¤Ê¤¤Ê¸»ú¤À¤±¤Ç¤Ç¤¤Æ¤¤¤ëÉôʬ¤ÎºÇÂ獵¤òÊÖ¤¹¡£
+ ´Ø¿ô mtext_cspn () ¤Ï¡¢M-text $MT1 ¤ÎÀèƬÉôʬ¤Ç M-text $MT2
+ ¤Ë´Þ¤Þ¤ì¤Ê¤¤Ê¸»ú¤À¤±¤Ç¤Ç¤¤Æ¤¤¤ëÉôʬ¤ÎŤµ¤òÊÖ¤¹¡£
@latexonly \IPAlabel{mtext_cspn} @endlatexonly */
If no such character is found, it returns -1. */
/***ja
- @brief ¤¢¤ë½¸¹ç¤Îʸ»ú¤Î¤É¤ì¤«¤ò M-text ¤ÎÃæ¤Çõ¤¹.
+ @brief ¤¢¤ë½¸¹ç¤Ë°¤¹Ê¸»ú¤ò M-text ¤ÎÃ椫¤éõ¤¹.
- ´Ø¿ô mtext_pbrk () ¤Ï¡¢M-text $MT1 Ãæ¤Ç M-text $MT2 ¤Î¤¤¤º¤ì¤«¤Îʸ
- »ú¤¬ºÇ½é¤Ë¸½¤ì¤ë°ÌÃÖ¤òÄ´¤Ù¤ë¡£
+ ´Ø¿ô mtext_pbrk () ¤Ï¡¢M-text $MT1 Ãæ¤Ç M-text $MT2
+ ¤Îʸ»ú¤Î¤É¤ì¤«¤¬ºÇ½é¤Ë¸½¤ì¤ë°ÌÃÖ¤òÄ´¤Ù¤ë¡£
@return
- ¸«¤Ä¤«¤Ã¤¿Ê¸»ú¤Î¡¢$MT1 Æâ¤Ë¤ª¤±¤ë½Ð¸½°ÌÃÖ¤òÊÖ¤¹¡£¤â¤·¤½¤Î¤è¤¦¤Êʸ
- »ú¤¬¤Ê¤±¤ì¤Ð -1 ¤òÊÖ¤¹¡£
+ ¸«¤Ä¤«¤Ã¤¿Ê¸»ú¤Î¡¢$MT1
+ Æâ¤Ë¤ª¤±¤ë½Ð¸½°ÌÃÖ¤òÊÖ¤¹¡£¤â¤·¤½¤Î¤è¤¦¤Êʸ»ú¤¬¤Ê¤±¤ì¤Ð -1 ¤òÊÖ¤¹¡£
@latexonly \IPAlabel{mtext_pbrk} @endlatexonly */
/***ja
@brief M-text Ãæ¤Î¥È¡¼¥¯¥ó¤òõ¤¹.
- ´Ø¿ô mtext_tok () ¤Ï¡¢M-text $MT ¤ÎÃæ¤Ç°ÌÃÖ $POS °Ê¹ßºÇ½é¤Ë¸½¤ì¤ë
- ¥È¡¼¥¯¥ó¤òõ¤¹¡£¤³¤³¤Ç¥È¡¼¥¯¥ó¤È¤Ï M-text $DELIM ¤ÎÃæ¤Ë¸½¤ï¤ì¤Ê¤¤
- ʸ»ú¤À¤±¤«¤é¤Ê¤ëÉôʬʸ»úÎó¤Ç¤¢¤ë¡£$POS ¤Î·¿¤¬ @c int ¤Ç¤Ï¤Ê¤¯¤Æ @c
+ ´Ø¿ô mtext_tok () ¤Ï¡¢M-text $MT ¤ÎÃæ¤Ç°ÌÃÖ $POS
+ °Ê¹ßºÇ½é¤Ë¸½¤ì¤ë¥È¡¼¥¯¥ó¤òõ¤¹¡£¤³¤³¤Ç¥È¡¼¥¯¥ó¤È¤Ï M-text $DELIM
+ ¤ÎÃæ¤Ë¸½¤ï¤ì¤Ê¤¤Ê¸»ú¤À¤±¤«¤é¤Ê¤ëÉôʬʸ»úÎó¤Ç¤¢¤ë¡£$POS ¤Î·¿¤¬ @c int ¤Ç¤Ï¤Ê¤¯¤Æ @c
int ¤Ø¤Î¥Ý¥¤¥ó¥¿¤Ç¤¢¤ë¤³¤È¤ËÃí°Õ¡£
@return
- ¤â¤·¥È¡¼¥¯¥ó¤¬¸«¤Ä¤«¤ì¤Ð mtext_tok ()¤Ï¤½¤Î¥È¡¼¥¯¥ó¤ËÁêÅö¤¹¤ëÉôʬ
- ¤Î $MT ¤ò¥³¥Ô¡¼¤·¡¢¤½¤Î¥³¥Ô¡¼¤Ø¤Î¥Ý¥¤¥ó¥¿¤òÊÖ¤¹¡£¤³¤Î¾ì¹ç¡¢$POS ¤Ï
- ¸«¤Ä¤«¤Ã¤¿¥È¡¼¥¯¥ó¤Î½ªÃ¼¤Ë¥»¥Ã¥È¤µ¤ì¤ë¡£¥È¡¼¥¯¥ó¤¬¸«¤Ä¤«¤é¤Ê¤«¤Ã¤¿
- ¾ì¹ç¤Ï³°ÉôÊÑ¿ô #merror_code ¤òÊѤ¨¤º¤Ë @c NULL ¤òÊÖ¤¹¡£¥¨¥é¡¼¤¬¸¡½Ð
- ¤µ¤ì¤¿¾ì¹ç¤Ï @c NULL ¤òÊÖ¤·¡¢ÊÑÉôÊÑ¿ô #merror_code ¤Ë¥¨¥é¡¼¥³¡¼¥É¤ò
- ÀßÄꤹ¤ë¡£
+ ¤â¤·¥È¡¼¥¯¥ó¤¬¸«¤Ä¤«¤ì¤Ð mtext_tok ()¤Ï¤½¤Î¥È¡¼¥¯¥ó¤ËÁêÅö¤¹¤ëÉôʬ¤Î
+ $MT ¤ò¥³¥Ô¡¼¤·¡¢¤½¤Î¥³¥Ô¡¼¤Ø¤Î¥Ý¥¤¥ó¥¿¤òÊÖ¤¹¡£¤³¤Î¾ì¹ç¡¢$POS
+ ¤Ï¸«¤Ä¤«¤Ã¤¿¥È¡¼¥¯¥ó¤Î½ªÃ¼¤Ë¥»¥Ã¥È¤µ¤ì¤ë¡£¥È¡¼¥¯¥ó¤¬¸«¤Ä¤«¤é¤Ê¤«¤Ã¤¿¾ì¹ç¤Ï³°ÉôÊÑ¿ô
+ #merror_code ¤òÊѤ¨¤º¤Ë @c NULL ¤òÊÖ¤¹¡£¥¨¥é¡¼¤¬¸¡½Ð¤µ¤ì¤¿¾ì¹ç¤Ï
+ @c NULL ¤òÊÖ¤·¡¢ÊÑÉôÊÑ¿ô #merror_code ¤Ë¥¨¥é¡¼¥³¡¼¥É¤òÀßÄꤹ¤ë¡£
@latexonly \IPAlabel{mtext_tok} @endlatexonly */
return NULL;
*pos = pos2 + span (mt, delim, pos2, Mt);
- return (copy (mtext (), 0, mt, pos2, *pos));
+ return (insert (mtext (), 0, mt, pos2, *pos));
}
/*=*/
@brief M-text Ãæ¤ÇÊ̤ΠM-text ¤òõ¤¹.
´Ø¿ô mtext_text () ¤Ï¡¢M-text $MT1 Ãæ¤Ç°ÌÃÖ $POS °Ê¹ß¤Ë¸½¤ï¤ì¤ë
- M-text $MT2 ¤ÎºÇ½é¤Î°ÌÃÖ¤òÄ´¤Ù¤ë¡£¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Î°ã¤¤¤Ï̵»ë¤µ
- ¤ì¤ë¡£
+ M-text $MT2 ¤ÎºÇ½é¤Î°ÌÃÖ¤òÄ´¤Ù¤ë¡£¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Î°ã¤¤¤Ï̵»ë¤µ¤ì¤ë¡£
@return
- $MT1 Ãæ¤Ë $MT2 ¤¬¸«¤Ä¤«¤ì¤Ð¡¢mtext_text() ¤Ï¤½¤ÎºÇ½é¤Î½Ð¸½°ÌÃÖ¤òÊÖ
- ¤¹¡£¸«¤Ä¤«¤é¤Ê¤¤¾ì¹ç¤Ï -1 ¤òÊÖ¤¹¡£¤â¤· $MT2 ¤¬¶õ¤Ê¤é¤Ð 0 ¤òÊÖ¤¹¡£
+ $MT1 Ãæ¤Ë $MT2 ¤¬¸«¤Ä¤«¤ì¤Ð¡¢mtext_text()
+ ¤Ï¤½¤ÎºÇ½é¤Î½Ð¸½°ÌÃÖ¤òÊÖ¤¹¡£¸«¤Ä¤«¤é¤Ê¤¤¾ì¹ç¤Ï -1 ¤òÊÖ¤¹¡£¤â¤· $MT2 ¤¬¶õ¤Ê¤é¤Ð 0 ¤òÊÖ¤¹¡£
@latexonly \IPAlabel{mtext_text} @endlatexonly */
mtext_text (MText *mt1, int pos, MText *mt2)
{
int from = pos;
- int pos_byte = POS_CHAR_TO_BYTE (mt1, pos);
int c = mtext_ref_char (mt2, 0);
- int nbytes1 = mtext_nbytes (mt1);
int nbytes2 = mtext_nbytes (mt2);
int limit;
int use_memcmp = (mt1->format == mt2->format
|| (mt1->format < MTEXT_FORMAT_UTF_8
&& mt2->format == MTEXT_FORMAT_UTF_8));
- int unit_bytes = (mt1->format <= MTEXT_FORMAT_UTF_8 ? 1
- : mt1->format <= MTEXT_FORMAT_UTF_16BE ? 2
- : 4);
+ int unit_bytes = UNIT_BYTES (mt1->format);
- if (nbytes2 > pos_byte + nbytes1)
+ if (from + mtext_nchars (mt2) > mtext_nchars (mt1))
return -1;
- pos_byte = nbytes1 - nbytes2;
- limit = POS_BYTE_TO_CHAR (mt1, pos_byte);
+ limit = mtext_nchars (mt1) - mtext_nchars (mt2) + 1;
while (1)
{
+ int pos_byte;
+
if ((pos = mtext_character (mt1, from, limit, c)) < 0)
return -1;
pos_byte = POS_CHAR_TO_BYTE (mt1, pos);
/***ja
@brief M-text Ãæ¤ÎÆÃÄê¤ÎÎΰè¤ÇÊ̤ΠM-text ¤òõ¤¹.
- ´Ø¿ô mtext_text () ¤Ï¡¢M-text $MT1 Ãæ¤Î $FROM ¤«¤é $TO ¤Þ¤Ç¤Î´Ö¤Î
- Îΰè¤ÇM-text $MT2 ¤¬ºÇ½é¤Ë¸½¤ï¤ì¤ë°ÌÃÖ¤òÄ´¤Ù¤ë¡£¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£
- ¤Î°ã¤¤¤Ï̵»ë¤µ¤ì¤ë¡£¤â¤· $FROM ¤¬ $TO ¤è¤ê¾®¤µ¤±¤ì¤Ðõº÷¤Ï°ÌÃÖ
- $FROM ¤«¤éËöÈøÊý¸þ¤Ø¡¢¤½¤¦¤Ç¤Ê¤±¤ì¤Ð $TO ¤«¤éÀèƬÊý¸þ¤ØºÇÂç $TO ¤Þ
- ¤Ç¿Ê¤à¡£
+ ´Ø¿ô mtext_search () ¤Ï¡¢M-text $MT1 Ãæ¤Î $FROM ¤«¤é $TO
+ ¤Þ¤Ç¤Î´Ö¤ÎÎΰè¤ÇM-text $MT2
+ ¤¬ºÇ½é¤Ë¸½¤ï¤ì¤ë°ÌÃÖ¤òÄ´¤Ù¤ë¡£¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤Î°ã¤¤¤Ï̵»ë¤µ¤ì¤ë¡£¤â¤·
+ $FROM ¤¬ $TO ¤è¤ê¾®¤µ¤±¤ì¤Ðõº÷¤Ï°ÌÃÖ $FROM ¤«¤éËöÈøÊý¸þ¤Ø¡¢¤½¤¦¤Ç¤Ê¤±¤ì¤Ð
+ $TO ¤«¤éÀèƬÊý¸þ¤Ø¿Ê¤à¡£
@return
- $MT1 Ãæ¤Ë $MT2 ¤¬¸«¤Ä¤«¤ì¤Ð¡¢mtext_search() ¤Ï¤½¤ÎºÇ½é¤Î½Ð¸½°ÌÃÖ¤òÊÖ
- ¤¹¡£¸«¤Ä¤«¤é¤Ê¤¤¾ì¹ç¤Ï -1 ¤òÊÖ¤¹¡£¤â¤· $MT2 ¤¬¶õ¤Ê¤é¤Ð 0 ¤òÊÖ¤¹¡£
+ $MT1 Ãæ¤Ë $MT2 ¤¬¸«¤Ä¤«¤ì¤Ð¡¢mtext_search()
+ ¤Ï¤½¤ÎºÇ½é¤Î½Ð¸½°ÌÃÖ¤òÊÖ¤¹¡£¸«¤Ä¤«¤é¤Ê¤¤¾ì¹ç¤Ï -1 ¤òÊÖ¤¹¡£¤â¤· $MT2 ¤¬¶õ¤Ê¤é¤Ð 0 ¤òÊÖ¤¹¡£
*/
int
return -1;
while (1)
{
- if ((from = find_char_backward (mt1, from, to, c)) < 0)
+ if ((from = find_char_backward (mt1, to, from + 1, c)) < 0)
return -1;
from_byte = POS_CHAR_TO_BYTE (mt1, from);
if (! memcmp (mt1->data + from_byte, mt2->data, nbytes2))
/***ja
@brief Æó¤Ä¤Î M-text ¤òÂçʸ»ú¡¿¾®Ê¸»ú¤Î¶èÊ̤ò̵»ë¤·¤ÆÈæ³Ó¤¹¤ë.
- ´Ø¿ô mtext_casecmp () ¤Ï¡¢´Ø¿ô mtext_cmp () ƱÍͤΠM-text Ʊ»Î¤ÎÈæ
- ³Ó¤ò¡¢Âçʸ»ú¡¿¾®Ê¸»ú¤Î¶èÊ̤ò̵»ë¤·¤Æ¹Ô¤Ê¤¦¡£
+ ´Ø¿ô mtext_casecmp () ¤Ï¡¢´Ø¿ô mtext_cmp () ƱÍͤΠM-text
+ Ʊ»Î¤ÎÈæ³Ó¤ò¡¢Âçʸ»ú¡¿¾®Ê¸»ú¤Î¶èÊ̤ò̵»ë¤·¤Æ¹Ô¤Ê¤¦¡£
@return
- ¤³¤Î´Ø¿ô¤Ï¡¢$MT1 ¤È $MT2 ¤¬Åù¤·¤±¤ì¤Ð 0¡¢$MT1 ¤¬ $MT2 ¤è¤êÂ礤±¤ì
- ¤Ð 1¡¢$MT1 ¤¬ $MT2 ¤è¤ê¾®¤µ¤±¤ì¤Ð -1 ¤òÊÖ¤¹¡£
+ ¤³¤Î´Ø¿ô¤Ï¡¢$MT1 ¤È $MT2 ¤¬Åù¤·¤±¤ì¤Ð 0¡¢$MT1 ¤¬ $MT2
+ ¤è¤êÂ礤±¤ì¤Ð 1¡¢$MT1 ¤¬ $MT2 ¤è¤ê¾®¤µ¤±¤ì¤Ð -1 ¤òÊÖ¤¹¡£
@latexonly \IPAlabel{mtext_casecmp} @endlatexonly */
/***ja
@brief Æó¤Ä¤Î M-text ¤ÎÀèƬÉôʬ¤òÂçʸ»ú¡¿¾®Ê¸»ú¤Î¶èÊ̤ò̵»ë¤·¤ÆÈæ³Ó¤¹¤ë.
- ´Ø¿ô mtext_ncasecmp () ¤Ï¡¢´Ø¿ô mtext_casecmp () ƱÍͤΠM-text Ʊ
- »Î¤ÎÈæ³Ó¤òÀèƬ¤«¤éºÇÂç $N ʸ»ú¤Þ¤Ç¤Ë´Ø¤·¤Æ¹Ô¤Ê¤¦¡£
+ ´Ø¿ô mtext_ncasecmp () ¤Ï¡¢´Ø¿ô mtext_casecmp () ƱÍͤΠM-text
+ Ʊ»Î¤ÎÈæ³Ó¤òÀèƬ¤«¤éºÇÂç $N ʸ»ú¤Þ¤Ç¤Ë´Ø¤·¤Æ¹Ô¤Ê¤¦¡£
@return
- ¤³¤Î´Ø¿ô¤Ï¡¢$MT1 ¤È $MT2 ¤¬Åù¤·¤±¤ì¤Ð 0¡¢$MT1 ¤¬ $MT2 ¤è¤êÂ礤±¤ì
- ¤Ð 1¡¢$MT1 ¤¬ $MT2 ¤è¤ê¾®¤µ¤±¤ì¤Ð -1 ¤òÊÖ¤¹¡£
+ ¤³¤Î´Ø¿ô¤Ï¡¢$MT1 ¤È $MT2 ¤¬Åù¤·¤±¤ì¤Ð 0¡¢$MT1 ¤¬ $MT2
+ ¤è¤êÂ礤±¤ì¤Ð 1¡¢$MT1 ¤¬ $MT2 ¤è¤ê¾®¤µ¤±¤ì¤Ð -1 ¤òÊÖ¤¹¡£
@latexonly \IPAlabel{mtext_ncasecmp} @endlatexonly */
/***ja
@brief Æó¤Ä¤Î M-text ¤Î»ØÄꤷ¤¿Îΰè¤ò¡¢Âçʸ»ú¡¿¾®Ê¸»ú¤Î¶èÊ̤ò̵»ë¤·¤ÆÈæ³Ó¤¹¤ë.
- ´Ø¿ô mtext_compare () ¤ÏÆó¤Ä¤Î M-text $MT1 ¤È $MT2 ¤ò¡¢Âçʸ»ú¡¿¾®
- ʸ»ú¤Î¶èÊ̤ò̵»ë¤·¤Æʸ»úñ°Ì¤ÇÈæ³Ó¤¹¤ë¡£Èæ³ÓÂоݤȤʤë¤Î¤Ï $MT1
- ¤Ç¤Ï $FROM1 ¤«¤é $TO1 ¤Þ¤Ç¡¢$MT2 ¤Ç¤Ï $FROM2 ¤«¤é $TO2 ¤Þ¤Ç¤Ç¤¢¤ë¡£
- $FROM1 ¤È $FROM2 ¤Ï´Þ¤Þ¤ì¡¢$TO1 ¤È $TO2 ¤Ï´Þ¤Þ¤ì¤Ê¤¤¡£$FROM1 ¤È
- $TO1 ¡Ê¤¢¤ë¤¤¤Ï $FROM2 ¤È $TO2 ¡Ë¤¬Åù¤·¤¤¾ì¹ç¤ÏŤµ¥¼¥í¤Î M-text
+ ´Ø¿ô mtext_compare () ¤ÏÆó¤Ä¤Î M-text $MT1 ¤È $MT2
+ ¤ò¡¢Âçʸ»ú¡¿¾®Ê¸»ú¤Î¶èÊ̤ò̵»ë¤·¤Æʸ»úñ°Ì¤ÇÈæ³Ó¤¹¤ë¡£Èæ³Ó¤ÎÂÐ¾Ý¤Ï $MT1
+ ¤Î $FROM1 ¤«¤é $TO1 ¤Þ¤Ç¡¢$MT2 ¤Î $FROM2 ¤«¤é $TO2 ¤Þ¤Ç¤Ç¤¢¤ë¡£
+ $FROM1 ¤È $FROM2 ¤Ï´Þ¤Þ¤ì¡¢$TO1 ¤È $TO2 ¤Ï´Þ¤Þ¤ì¤Ê¤¤¡£$FROM1 ¤È $TO1
+ ¡Ê¤¢¤ë¤¤¤Ï $FROM2 ¤È $TO2 ¡Ë¤¬Åù¤·¤¤¾ì¹ç¤ÏŤµ¥¼¥í¤Î M-text
¤ò°ÕÌ£¤¹¤ë¡£ÈÏ°Ï»ØÄê¤Ë¸í¤ê¤¬¤¢¤ë¾ì¹ç¤Ï¡¢$FROM1 ¤È $TO1 ¡Ê¤¢¤ë¤¤¤Ï
$FROM2 ¤È $TO2 ¡ËξÊý¤Ë 0 ¤¬»ØÄꤵ¤ì¤¿¤â¤Î¤È¸«¤Ê¤¹¡£
@return
- ¤³¤Î´Ø¿ô¤Ï¡¢$MT1 ¤È $MT2 ¤¬Åù¤·¤±¤ì¤Ð0¡¢$MT1 ¤¬ $MT2 ¤è¤êÂ礤±¤ì
- ¤Ð1¡¢$MT1 ¤¬ $MT2 ¤è¤ê¾®¤µ¤±¤ì¤Ð-1¤òÊÖ¤¹¡£Èæ³Ó¤Ïʸ»ú¥³¡¼¥É¤Ë´ð¤Å¤¯¡£
+ ¤³¤Î´Ø¿ô¤Ï¡¢$MT1 ¤È $MT2 ¤¬Åù¤·¤±¤ì¤Ð 0¡¢$MT1 ¤¬ $MT2 ¤è¤êÂ礤±¤ì¤Ð
+ 1¡¢$MT1 ¤¬ $MT2 ¤è¤ê¾®¤µ¤±¤ì¤Ð -1¤òÊÖ¤¹¡£Èæ³Ó¤Ïʸ»ú¥³¡¼¥É¤Ë´ð¤Å¤¯¡£
@latexonly \IPAlabel{mtext_case_compare} @endlatexonly
*/
/***ja
@brief M-text ¤ò¥À¥ó¥×¤¹¤ë.
- ´Ø¿ô mdebug_dump_mtext () ¤Ï M-text $MT ¤ò stderr ¤Ë¿Í´Ö¤Ë²ÄÆɤÊ
- ·Á¤Ç°õºþ¤¹¤ë¡£ $INDENT ¤Ï£²¹ÔÌܰʹߤΥ¤¥ó¥Ç¥ó¥È¤ò»ØÄꤹ¤ë¡£$FULLP
- ¤¬ 0 ¤Ê¤é¤Ð¡¢Ê¸»ú¥³¡¼¥ÉÎó¤À¤±¤ò°õºþ¤¹¤ë¡£¤½¤¦¤Ç¤Ê¤±¤ì¤Ð¡¢ÆâÉô¥Ð¥¤
- ¥ÈÎó¤È¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤â°õºþ¤¹¤ë¡£
+ ´Ø¿ô mdebug_dump_mtext () ¤Ï M-text $MT ¤ò stderr
+ ¤Ë¿Í´Ö¤Ë²ÄÆɤʷÁ¤Ç°õºþ¤¹¤ë¡£ $INDENT ¤Ï£²¹ÔÌܰʹߤΥ¤¥ó¥Ç¥ó¥È¤ò»ØÄꤹ¤ë¡£
+ $FULLP ¤¬ 0 ¤Ê¤é¤Ð¡¢Ê¸»ú¥³¡¼¥ÉÎó¤À¤±¤ò°õºþ¤¹¤ë¡£
+ ¤½¤¦¤Ç¤Ê¤±¤ì¤Ð¡¢ÆâÉô¥Ð¥¤¥ÈÎó¤È¥Æ¥¥¹¥È¥×¥í¥Ñ¥Æ¥£¤â°õºþ¤¹¤ë¡£
@return
¤³¤Î´Ø¿ô¤Ï $MT ¤òÊÖ¤¹¡£ */
memset (prefix, 32, indent);
prefix[indent] = 0;
+ fprintf (stderr,
+ "(mtext (size %d %d %d) (cache %d %d)",
+ mt->nchars, mt->nbytes, mt->allocated,
+ mt->cache_char_pos, mt->cache_byte_pos);
if (! fullp)
{
- fprintf (stderr, "\"");
- for (i = 0; i < mt->nbytes; i++)
+ fprintf (stderr, " \"");
+ for (i = 0; i < mt->nchars; i++)
{
- int c = mt->data[i];
+ int c = mtext_ref_char (mt, i);
if (c >= ' ' && c < 127)
fprintf (stderr, "%c", c);
else
fprintf (stderr, "\\x%02X", c);
}
fprintf (stderr, "\"");
- return mt;
}
-
- fprintf (stderr,
- "(mtext (size %d %d %d) (cache %d %d)",
- mt->nchars, mt->nbytes, mt->allocated,
- mt->cache_char_pos, mt->cache_byte_pos);
- if (mt->nchars > 0)
+ else if (mt->nchars > 0)
{
fprintf (stderr, "\n%s (bytes \"", prefix);
for (i = 0; i < mt->nbytes; i++)
int len;
int c = STRING_CHAR_AND_BYTES (p, len);
- if (c >= ' ' && c < 127 && c != '\\' && c != '"')
+ if (c >= ' ' && c < 127 && c != '\\' && c != '\"')
fputc (c, stderr);
else
fprintf (stderr, "\\x%X", c);
projects / m17n / m17n-lib.git / blobdiff