[deliverable/binutils-gdb.git] / readline / mbutil.c

/* mbutil.c -- readline multibyte character utility functions */

/* Copyright (C) 2001 Free Software Foundation, Inc.

   This file is part of the GNU Readline Library, a library for
   reading lines of text with interactive input and history editing.

   The GNU Readline Library is free software; you can redistribute it
   and/or modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2, or
   (at your option) any later version.

   The GNU Readline Library is distributed in the hope that it will be
   useful, but WITHOUT ANY WARRANTY; without even the implied warranty
   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   The GNU General Public License is often shipped with GNU software, and
   is generally kept in a file called COPYING or LICENSE.  If you do not
   have a copy of the license, write to the Free Software Foundation,
   59 Temple Place, Suite 330, Boston, MA 02111 USA. */
#define READLINE_LIBRARY

#if defined (HAVE_CONFIG_H)
#  include <config.h>
#endif

#include <sys/types.h>
#include <fcntl.h>
#include "posixjmp.h"

#if defined (HAVE_UNISTD_H)
#  include <unistd.h>	   /* for _POSIX_VERSION */
#endif /* HAVE_UNISTD_H */

#if defined (HAVE_STDLIB_H)
#  include <stdlib.h>
#else
#  include "ansi_stdlib.h"
#endif /* HAVE_STDLIB_H */

#include <stdio.h>
#include <ctype.h>

/* System-specific feature definitions and include files. */
#include "rldefs.h"
#include "rlmbutil.h"

#if defined (TIOCSTAT_IN_SYS_IOCTL)
#  include <sys/ioctl.h>
#endif /* TIOCSTAT_IN_SYS_IOCTL */

/* Some standard library routines. */
#include "readline.h"

#include "rlprivate.h"
#include "xmalloc.h"

/* Declared here so it can be shared between the readline and history
   libraries. */
#if defined (HANDLE_MULTIBYTE)
int rl_byte_oriented = 0;
#else
int rl_byte_oriented = 1;
#endif

/* **************************************************************** */
/*								    */
/*		Multibyte Character Utility Functions		    */
/*								    */
/* **************************************************************** */

#if defined(HANDLE_MULTIBYTE)

static int
_rl_find_next_mbchar_internal (string, seed, count, find_non_zero)
     char *string;
     int seed, count, find_non_zero;
{
  size_t tmp = 0;
  mbstate_t ps;
  int point = 0;
  wchar_t wc;

  memset(&ps, 0, sizeof (mbstate_t));
  if (seed < 0)
    seed = 0;
  if (count <= 0)
    return seed;

  point = seed + _rl_adjust_point(string, seed, &ps);
  /* if this is true, means that seed was not pointed character
     started byte.  So correct the point and consume count */
  if (seed < point)
    count --;

  while (count > 0)  
    {
      tmp = mbrtowc (&wc, string+point, strlen(string + point), &ps);
      if ((size_t)(tmp) == (size_t)-1 || (size_t)(tmp) == (size_t)-2)
	{
	  /* invalid bytes. asume a byte represents a character */
	  point++;
	  count--;
	  /* reset states. */
	  memset(&ps, 0, sizeof(mbstate_t));
	}
      else if (tmp == (size_t)0)
	/* found '\0' char */
	break;
      else
	{
	  /* valid bytes */
	  point += tmp;
	  if (find_non_zero)
	    {
	      if (wcwidth (wc) == 0)
		continue;
	      else
		count--;
	    }
	  else
	    count--;
	}
    }

  if (find_non_zero)
    {
      tmp = mbrtowc (&wc, string + point, strlen (string + point), &ps);
      while (wcwidth (wc) == 0)
	{
	  point += tmp;
	  tmp = mbrtowc (&wc, string + point, strlen (string + point), &ps);
	  if (tmp == (size_t)(0) || tmp == (size_t)(-1) || tmp == (size_t)(-2))
	    break;
	}
    }
    return point;
}

static int
_rl_find_prev_mbchar_internal (string, seed, find_non_zero)
     char *string;
     int seed, find_non_zero;
{
  mbstate_t ps;
  int prev, non_zero_prev, point, length;
  size_t tmp;
  wchar_t wc;

  memset(&ps, 0, sizeof(mbstate_t));
  length = strlen(string);
  
  if (seed < 0)
    return 0;
  else if (length < seed)
    return length;

  prev = non_zero_prev = point = 0;
  while (point < seed)
    {
      tmp = mbrtowc (&wc, string + point, length - point, &ps);
      if ((size_t)(tmp) == (size_t)-1 || (size_t)(tmp) == (size_t)-2)
	{
	  /* in this case, bytes are invalid or shorted to compose
	     multibyte char, so assume that the first byte represents
	     a single character anyway. */
	  tmp = 1;
	  /* clear the state of the byte sequence, because
	     in this case effect of mbstate is undefined  */
	  memset(&ps, 0, sizeof (mbstate_t));
	}
      else if (tmp == 0)
	break;			/* Found '\0' char.  Can this happen? */
      else
	{
	  if (find_non_zero)
	    {
	      if (wcwidth (wc) != 0)
		prev = point;
	    }
	  else
	    prev = point;  
	}

      point += tmp;
    }

  return prev;
}

/* return the number of bytes parsed from the multibyte sequence starting
   at src, if a non-L'\0' wide character was recognized. It returns 0, 
   if a L'\0' wide character was recognized. It  returns (size_t)(-1), 
   if an invalid multibyte sequence was encountered. It returns (size_t)(-2) 
   if it couldn't parse a complete  multibyte character.  */
int
_rl_get_char_len (src, ps)
     char *src;
     mbstate_t *ps;
{
  size_t tmp;

  tmp = mbrlen((const char *)src, (size_t)strlen (src), ps);
  if (tmp == (size_t)(-2))
    {
      /* shorted to compose multibyte char */
      if (ps)
	memset (ps, 0, sizeof(mbstate_t));
      return -2;
    }
  else if (tmp == (size_t)(-1))
    {
      /* invalid to compose multibyte char */
      /* initialize the conversion state */
      if (ps)
	memset (ps, 0, sizeof(mbstate_t));
      return -1;
    }
  else if (tmp == (size_t)0)
    return 0;
  else
    return (int)tmp;
}

/* compare the specified two characters. If the characters matched,
   return 1. Otherwise return 0. */
int
_rl_compare_chars (buf1, pos1, ps1, buf2, pos2, ps2)
     char *buf1;
     int pos1;
     mbstate_t *ps1;
     char *buf2;
     int pos2;
     mbstate_t *ps2;
{
  int i, w1, w2;

  if ((w1 = _rl_get_char_len (&buf1[pos1], ps1)) <= 0 || 
	(w2 = _rl_get_char_len (&buf2[pos2], ps2)) <= 0 ||
	(w1 != w2) ||
	(buf1[pos1] != buf2[pos2]))
    return 0;

  for (i = 1; i < w1; i++)
    if (buf1[pos1+i] != buf2[pos2+i])
      return 0;

  return 1;
}

/* adjust pointed byte and find mbstate of the point of string.
   adjusted point will be point <= adjusted_point, and returns
   differences of the byte(adjusted_point - point).
   if point is invalied (point < 0 || more than string length),
   it returns -1 */
int
_rl_adjust_point(string, point, ps)
     char *string;
     int point;
     mbstate_t *ps;
{
  size_t tmp = 0;
  int length;
  int pos = 0;

  length = strlen(string);
  if (point < 0)
    return -1;
  if (length < point)
    return -1;
  
  while (pos < point)
    {
      tmp = mbrlen (string + pos, length - pos, ps);
      if((size_t)(tmp) == (size_t)-1 || (size_t)(tmp) == (size_t)-2)
	{
	  /* in this case, bytes are invalid or shorted to compose
	     multibyte char, so assume that the first byte represents
	     a single character anyway. */
	  pos++;
	  /* clear the state of the byte sequence, because
	     in this case effect of mbstate is undefined  */
	  if (ps)
	    memset (ps, 0, sizeof (mbstate_t));
	}
      else if (tmp == 0)
	pos++;
      else
	pos += tmp;
    }

  return (pos - point);
}

int
_rl_is_mbchar_matched (string, seed, end, mbchar, length)
     char *string;
     int seed, end;
     char *mbchar;
     int length;
{
  int i;

  if ((end - seed) < length)
    return 0;

  for (i = 0; i < length; i++)
    if (string[seed + i] != mbchar[i])
      return 0;
  return 1;
}
#endif /* HANDLE_MULTIBYTE */

/* Find next `count' characters started byte point of the specified seed.
   If flags is MB_FIND_NONZERO, we look for non-zero-width multibyte
   characters. */
#undef _rl_find_next_mbchar
int
_rl_find_next_mbchar (string, seed, count, flags)
     char *string;
     int seed, count, flags;
{
#if defined (HANDLE_MULTIBYTE)
  return _rl_find_next_mbchar_internal (string, seed, count, flags);
#else
  return (seed + count);
#endif
}

/* Find previous character started byte point of the specified seed.
   Returned point will be point <= seed.  If flags is MB_FIND_NONZERO,
   we look for non-zero-width multibyte characters. */
#undef _rl_find_prev_mbchar
int
_rl_find_prev_mbchar (string, seed, flags)
     char *string;
     int seed, flags;
{
#if defined (HANDLE_MULTIBYTE)
  return _rl_find_prev_mbchar_internal (string, seed, flags);
#else
  return ((seed == 0) ? seed : seed - 1);
#endif
}
Commit	Line	Data
9255ee31 EZ	1	/* mbutil.c -- readline multibyte character utility functions */
	2
	3	/* Copyright (C) 2001 Free Software Foundation, Inc.
	4
	5	This file is part of the GNU Readline Library, a library for
	6	reading lines of text with interactive input and history editing.
	7
	8	The GNU Readline Library is free software; you can redistribute it
	9	and/or modify it under the terms of the GNU General Public License
	10	as published by the Free Software Foundation; either version 2, or
	11	(at your option) any later version.
	12
	13	The GNU Readline Library is distributed in the hope that it will be
	14	useful, but WITHOUT ANY WARRANTY; without even the implied warranty
	15	of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	The GNU General Public License is often shipped with GNU software, and
	19	is generally kept in a file called COPYING or LICENSE. If you do not
	20	have a copy of the license, write to the Free Software Foundation,
	21	59 Temple Place, Suite 330, Boston, MA 02111 USA. */
	22	#define READLINE_LIBRARY
	23
	24	#if defined (HAVE_CONFIG_H)
	25	# include <config.h>
	26	#endif
	27
	28	#include <sys/types.h>
	29	#include <fcntl.h>
	30	#include "posixjmp.h"
	31
	32	#if defined (HAVE_UNISTD_H)
	33	# include <unistd.h> /* for _POSIX_VERSION */
	34	#endif /* HAVE_UNISTD_H */
	35
	36	#if defined (HAVE_STDLIB_H)
	37	# include <stdlib.h>
	38	#else
	39	# include "ansi_stdlib.h"
	40	#endif /* HAVE_STDLIB_H */
	41
	42	#include <stdio.h>
	43	#include <ctype.h>
	44
	45	/* System-specific feature definitions and include files. */
	46	#include "rldefs.h"
	47	#include "rlmbutil.h"
	48
	49	#if defined (TIOCSTAT_IN_SYS_IOCTL)
	50	# include <sys/ioctl.h>
	51	#endif /* TIOCSTAT_IN_SYS_IOCTL */
	52
	53	/* Some standard library routines. */
	54	#include "readline.h"
	55
	56	#include "rlprivate.h"
	57	#include "xmalloc.h"
	58
	59	/* Declared here so it can be shared between the readline and history
	60	libraries. */
	61	#if defined (HANDLE_MULTIBYTE)
	62	int rl_byte_oriented = 0;
	63	#else
	64	int rl_byte_oriented = 1;
65	#endif
66
67	/* **************************************************************** */
68	/* */
69	/* Multibyte Character Utility Functions */
70	/* */
71	/* **************************************************************** */
72
73	#if defined(HANDLE_MULTIBYTE)
74
75	static int
76	_rl_find_next_mbchar_internal (string, seed, count, find_non_zero)
77	char *string;
78	int seed, count, find_non_zero;
79	{
80	size_t tmp = 0;
81	mbstate_t ps;
82	int point = 0;
83	wchar_t wc;
84
85	memset(&ps, 0, sizeof (mbstate_t));
86	if (seed < 0)
87	seed = 0;
88	if (count <= 0)
89	return seed;
90
91	point = seed + _rl_adjust_point(string, seed, &ps);
92	/* if this is true, means that seed was not pointed character
93	started byte. So correct the point and consume count */
94	if (seed < point)
95	count --;
96
97	while (count > 0)
98	{
99	tmp = mbrtowc (&wc, string+point, strlen(string + point), &ps);
100	if ((size_t)(tmp) == (size_t)-1 \|\| (size_t)(tmp) == (size_t)-2)
101	{
102	/* invalid bytes. asume a byte represents a character */
103	point++;
104	count--;
105	/* reset states. */
106	memset(&ps, 0, sizeof(mbstate_t));
107	}
108	else if (tmp == (size_t)0)
109	/* found '\0' char */
110	break;
111	else
112	{
113	/* valid bytes */
114	point += tmp;
115	if (find_non_zero)
116	{
117	if (wcwidth (wc) == 0)
118	continue;
119	else
120	count--;
121	}
122	else
123	count--;
124	}
125	}
126
127	if (find_non_zero)
128	{
129	tmp = mbrtowc (&wc, string + point, strlen (string + point), &ps);
130	while (wcwidth (wc) == 0)
131	{
132	point += tmp;
133	tmp = mbrtowc (&wc, string + point, strlen (string + point), &ps);
134	if (tmp == (size_t)(0) \|\| tmp == (size_t)(-1) \|\| tmp == (size_t)(-2))
135	break;
136	}
137	}
138	return point;
139	}
140
141	static int
142	_rl_find_prev_mbchar_internal (string, seed, find_non_zero)
143	char *string;
144	int seed, find_non_zero;
145	{
146	mbstate_t ps;
147	int prev, non_zero_prev, point, length;
148	size_t tmp;
149	wchar_t wc;
150
151	memset(&ps, 0, sizeof(mbstate_t));
152	length = strlen(string);
153
154	if (seed < 0)
155	return 0;
156	else if (length < seed)
157	return length;
158
159	prev = non_zero_prev = point = 0;
160	while (point < seed)
161	{
162	tmp = mbrtowc (&wc, string + point, length - point, &ps);
163	if ((size_t)(tmp) == (size_t)-1 \|\| (size_t)(tmp) == (size_t)-2)
164	{
165	/* in this case, bytes are invalid or shorted to compose
166	multibyte char, so assume that the first byte represents
167	a single character anyway. */
168	tmp = 1;
169	/* clear the state of the byte sequence, because
170	in this case effect of mbstate is undefined */
171	memset(&ps, 0, sizeof (mbstate_t));
172	}
173	else if (tmp == 0)
174	break; /* Found '\0' char. Can this happen? */
175	else
176	{
177	if (find_non_zero)
178	{
179	if (wcwidth (wc) != 0)
180	prev = point;
181	}
182	else
183	prev = point;
184	}
185
186	point += tmp;
187	}
188
189	return prev;
190	}
191
192	/* return the number of bytes parsed from the multibyte sequence starting
193	at src, if a non-L'\0' wide character was recognized. It returns 0,
194	if a L'\0' wide character was recognized. It returns (size_t)(-1),
195	if an invalid multibyte sequence was encountered. It returns (size_t)(-2)
196	if it couldn't parse a complete multibyte character. */
197	int
198	_rl_get_char_len (src, ps)
199	char *src;
200	mbstate_t *ps;
201	{
202	size_t tmp;
203
204	tmp = mbrlen((const char *)src, (size_t)strlen (src), ps);
205	if (tmp == (size_t)(-2))
206	{
207	/* shorted to compose multibyte char */
5af408ce EZ	208	if (ps)
5af408ce EZ	209	memset (ps, 0, sizeof(mbstate_t));
9255ee31 EZ	210	return -2;
	211	}
	212	else if (tmp == (size_t)(-1))
	213	{
	214	/* invalid to compose multibyte char */
	215	/* initialize the conversion state */
5af408ce EZ	216	if (ps)
5af408ce EZ	217	memset (ps, 0, sizeof(mbstate_t));
9255ee31 EZ	218	return -1;
	219	}
	220	else if (tmp == (size_t)0)
	221	return 0;
	222	else
	223	return (int)tmp;
	224	}
	225
	226	/* compare the specified two characters. If the characters matched,
	227	return 1. Otherwise return 0. */
	228	int
	229	_rl_compare_chars (buf1, pos1, ps1, buf2, pos2, ps2)
5af408ce EZ	230	char *buf1;
	231	int pos1;
	232	mbstate_t *ps1;
	233	char *buf2;
	234	int pos2;
	235	mbstate_t *ps2;
9255ee31 EZ	236	{
	237	int i, w1, w2;
	238
	239	if ((w1 = _rl_get_char_len (&buf1[pos1], ps1)) <= 0 \|\|
	240	(w2 = _rl_get_char_len (&buf2[pos2], ps2)) <= 0 \|\|
	241	(w1 != w2) \|\|
	242	(buf1[pos1] != buf2[pos2]))
	243	return 0;
	244
	245	for (i = 1; i < w1; i++)
	246	if (buf1[pos1+i] != buf2[pos2+i])
	247	return 0;
	248
	249	return 1;
	250	}
	251
	252	/* adjust pointed byte and find mbstate of the point of string.
	253	adjusted point will be point <= adjusted_point, and returns
	254	differences of the byte(adjusted_point - point).
	255	if point is invalied (point < 0 \|\| more than string length),
	256	it returns -1 */
	257	int
	258	_rl_adjust_point(string, point, ps)
	259	char *string;
	260	int point;
	261	mbstate_t *ps;
	262	{
	263	size_t tmp = 0;
	264	int length;
	265	int pos = 0;
	266
	267	length = strlen(string);
	268	if (point < 0)
	269	return -1;
	270	if (length < point)
	271	return -1;
	272
	273	while (pos < point)
	274	{
	275	tmp = mbrlen (string + pos, length - pos, ps);
	276	if((size_t)(tmp) == (size_t)-1 \|\| (size_t)(tmp) == (size_t)-2)
	277	{
	278	/* in this case, bytes are invalid or shorted to compose
	279	multibyte char, so assume that the first byte represents
	280	a single character anyway. */
	281	pos++;
	282	/* clear the state of the byte sequence, because
	283	in this case effect of mbstate is undefined */
5af408ce EZ	284	if (ps)
5af408ce EZ	285	memset (ps, 0, sizeof (mbstate_t));
9255ee31	286	}
5af408ce EZ	287	else if (tmp == 0)
5af408ce EZ	288	pos++;
9255ee31 EZ	289	else
	290	pos += tmp;
	291	}
	292
	293	return (pos - point);
	294	}
	295
	296	int
	297	_rl_is_mbchar_matched (string, seed, end, mbchar, length)
	298	char *string;
	299	int seed, end;
	300	char *mbchar;
	301	int length;
	302	{
	303	int i;
	304
	305	if ((end - seed) < length)
	306	return 0;
	307
	308	for (i = 0; i < length; i++)
	309	if (string[seed + i] != mbchar[i])
	310	return 0;
	311	return 1;
	312	}
	313	#endif /* HANDLE_MULTIBYTE */
	314
	315	/* Find next `count' characters started byte point of the specified seed.
	316	If flags is MB_FIND_NONZERO, we look for non-zero-width multibyte
	317	characters. */
	318	#undef _rl_find_next_mbchar
	319	int
	320	_rl_find_next_mbchar (string, seed, count, flags)
	321	char *string;
	322	int seed, count, flags;
	323	{
	324	#if defined (HANDLE_MULTIBYTE)
	325	return _rl_find_next_mbchar_internal (string, seed, count, flags);
	326	#else
	327	return (seed + count);
	328	#endif
	329	}
	330
	331	/* Find previous character started byte point of the specified seed.
	332	Returned point will be point <= seed. If flags is MB_FIND_NONZERO,
	333	we look for non-zero-width multibyte characters. */
	334	#undef _rl_find_prev_mbchar
	335	int
	336	_rl_find_prev_mbchar (string, seed, flags)
	337	char *string;
	338	int seed, flags;
	339	{
	340	#if defined (HANDLE_MULTIBYTE)
	341	return _rl_find_prev_mbchar_internal (string, seed, flags);
	342	#else
	343	return ((seed == 0) ? seed : seed - 1);
	344	#endif
	345	}