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

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

/* Copyright (C) 2001-2005 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;
  mbstate_t ps;
  int point;
  wchar_t wc;

  tmp = 0;

  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 (MB_INVALIDCH ((size_t)tmp))
	{
	  /* invalid bytes. asume a byte represents a character */
	  point++;
	  count--;
	  /* reset states. */
	  memset(&ps, 0, sizeof(mbstate_t));
	}
      else if (MB_NULLWCH (tmp))
	break;			/* found wide '\0' */
      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 (tmp > 0 && wcwidth (wc) == 0)
	{
	  point += tmp;
	  tmp = mbrtowc (&wc, string + point, strlen (string + point), &ps);
	  if (MB_NULLWCH (tmp) || MB_INVALIDCH (tmp))
	    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 (MB_INVALIDCH ((size_t)tmp))
	{
	  /* 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));

	  /* Since we're assuming that this byte represents a single
	     non-zero-width character, don't forget about it. */
	  prev = point;
	}
      else if (MB_NULLWCH (tmp))
	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 (MB_INVALIDCH ((size_t)tmp))
	{
	  /* 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 (MB_NULLWCH (tmp))
	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;
}

wchar_t
_rl_char_value (buf, ind)
     char *buf;
     int ind;
{
  size_t tmp;
  wchar_t wc;
  mbstate_t ps;
  int l;

  if (MB_LEN_MAX == 1 || rl_byte_oriented)
    return ((wchar_t) buf[ind]);
  l = strlen (buf);
  if (ind >= l - 1)
    return ((wchar_t) buf[ind]);
  memset (&ps, 0, sizeof (mbstate_t));
  tmp = mbrtowc (&wc, buf + ind, l - ind, &ps);
  if (MB_INVALIDCH (tmp) || MB_NULLWCH (tmp))  
    return ((wchar_t) buf[ind]);
  return wc;
}
#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 */
9255ee31 EZ	2
5bdf8622	3	/* Copyright (C) 2001-2005 Free Software Foundation, Inc.
9255ee31 EZ	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	{
5bdf8622	80	size_t tmp;
9255ee31	81	mbstate_t ps;
5bdf8622	82	int point;
9255ee31 EZ	83	wchar_t wc;
9255ee31 EZ	84
5bdf8622 DJ	85	tmp = 0;
5bdf8622 DJ	86
9255ee31 EZ	87	memset(&ps, 0, sizeof (mbstate_t));
	88	if (seed < 0)
	89	seed = 0;
	90	if (count <= 0)
	91	return seed;
	92
5bdf8622	93	point = seed + _rl_adjust_point (string, seed, &ps);
9255ee31 EZ	94	/* if this is true, means that seed was not pointed character
	95	started byte. So correct the point and consume count */
	96	if (seed < point)
5bdf8622	97	count--;
9255ee31 EZ	98
	99	while (count > 0)
	100	{
	101	tmp = mbrtowc (&wc, string+point, strlen(string + point), &ps);
5bdf8622	102	if (MB_INVALIDCH ((size_t)tmp))
9255ee31 EZ	103	{
	104	/* invalid bytes. asume a byte represents a character */
	105	point++;
	106	count--;
	107	/* reset states. */
	108	memset(&ps, 0, sizeof(mbstate_t));
	109	}
5bdf8622 DJ	110	else if (MB_NULLWCH (tmp))
5bdf8622 DJ	111	break; /* found wide '\0' */
9255ee31 EZ	112	else
	113	{
	114	/* valid bytes */
	115	point += tmp;
	116	if (find_non_zero)
	117	{
	118	if (wcwidth (wc) == 0)
	119	continue;
	120	else
	121	count--;
	122	}
	123	else
	124	count--;
	125	}
	126	}
	127
	128	if (find_non_zero)
	129	{
	130	tmp = mbrtowc (&wc, string + point, strlen (string + point), &ps);
5bdf8622	131	while (tmp > 0 && wcwidth (wc) == 0)
9255ee31 EZ	132	{
	133	point += tmp;
	134	tmp = mbrtowc (&wc, string + point, strlen (string + point), &ps);
5bdf8622	135	if (MB_NULLWCH (tmp) \|\| MB_INVALIDCH (tmp))
9255ee31 EZ	136	break;
	137	}
	138	}
5bdf8622 DJ	139
5bdf8622 DJ	140	return point;
9255ee31 EZ	141	}
	142
	143	static int
	144	_rl_find_prev_mbchar_internal (string, seed, find_non_zero)
	145	char *string;
	146	int seed, find_non_zero;
	147	{
	148	mbstate_t ps;
	149	int prev, non_zero_prev, point, length;
	150	size_t tmp;
	151	wchar_t wc;
	152
	153	memset(&ps, 0, sizeof(mbstate_t));
	154	length = strlen(string);
	155
	156	if (seed < 0)
	157	return 0;
	158	else if (length < seed)
	159	return length;
	160
	161	prev = non_zero_prev = point = 0;
	162	while (point < seed)
	163	{
	164	tmp = mbrtowc (&wc, string + point, length - point, &ps);
5bdf8622	165	if (MB_INVALIDCH ((size_t)tmp))
9255ee31 EZ	166	{
	167	/* in this case, bytes are invalid or shorted to compose
	168	multibyte char, so assume that the first byte represents
	169	a single character anyway. */
	170	tmp = 1;
	171	/* clear the state of the byte sequence, because
	172	in this case effect of mbstate is undefined */
	173	memset(&ps, 0, sizeof (mbstate_t));
5bdf8622 DJ	174
	175	/* Since we're assuming that this byte represents a single
	176	non-zero-width character, don't forget about it. */
	177	prev = point;
9255ee31	178	}
5bdf8622	179	else if (MB_NULLWCH (tmp))
9255ee31 EZ	180	break; /* Found '\0' char. Can this happen? */
	181	else
	182	{
	183	if (find_non_zero)
	184	{
	185	if (wcwidth (wc) != 0)
	186	prev = point;
	187	}
	188	else
	189	prev = point;
	190	}
	191
	192	point += tmp;
	193	}
	194
	195	return prev;
	196	}
	197
	198	/* return the number of bytes parsed from the multibyte sequence starting
	199	at src, if a non-L'\0' wide character was recognized. It returns 0,
	200	if a L'\0' wide character was recognized. It returns (size_t)(-1),
	201	if an invalid multibyte sequence was encountered. It returns (size_t)(-2)
	202	if it couldn't parse a complete multibyte character. */
	203	int
	204	_rl_get_char_len (src, ps)
	205	char *src;
	206	mbstate_t *ps;
	207	{
	208	size_t tmp;
	209
	210	tmp = mbrlen((const char *)src, (size_t)strlen (src), ps);
	211	if (tmp == (size_t)(-2))
	212	{
	213	/* shorted to compose multibyte char */
5af408ce EZ	214	if (ps)
5af408ce EZ	215	memset (ps, 0, sizeof(mbstate_t));
9255ee31 EZ	216	return -2;
	217	}
	218	else if (tmp == (size_t)(-1))
	219	{
	220	/* invalid to compose multibyte char */
	221	/* initialize the conversion state */
5af408ce EZ	222	if (ps)
5af408ce EZ	223	memset (ps, 0, sizeof(mbstate_t));
9255ee31 EZ	224	return -1;
	225	}
	226	else if (tmp == (size_t)0)
	227	return 0;
	228	else
	229	return (int)tmp;
	230	}
	231
	232	/* compare the specified two characters. If the characters matched,
	233	return 1. Otherwise return 0. */
	234	int
	235	_rl_compare_chars (buf1, pos1, ps1, buf2, pos2, ps2)
5af408ce EZ	236	char *buf1;
	237	int pos1;
	238	mbstate_t *ps1;
	239	char *buf2;
	240	int pos2;
	241	mbstate_t *ps2;
9255ee31 EZ	242	{
	243	int i, w1, w2;
	244
	245	if ((w1 = _rl_get_char_len (&buf1[pos1], ps1)) <= 0 \|\|
	246	(w2 = _rl_get_char_len (&buf2[pos2], ps2)) <= 0 \|\|
	247	(w1 != w2) \|\|
	248	(buf1[pos1] != buf2[pos2]))
	249	return 0;
	250
	251	for (i = 1; i < w1; i++)
	252	if (buf1[pos1+i] != buf2[pos2+i])
	253	return 0;
	254
	255	return 1;
	256	}
	257
	258	/* adjust pointed byte and find mbstate of the point of string.
	259	adjusted point will be point <= adjusted_point, and returns
	260	differences of the byte(adjusted_point - point).
	261	if point is invalied (point < 0 \|\| more than string length),
	262	it returns -1 */
	263	int
	264	_rl_adjust_point(string, point, ps)
	265	char *string;
	266	int point;
	267	mbstate_t *ps;
	268	{
	269	size_t tmp = 0;
	270	int length;
	271	int pos = 0;
	272
	273	length = strlen(string);
	274	if (point < 0)
	275	return -1;
	276	if (length < point)
	277	return -1;
	278
	279	while (pos < point)
	280	{
	281	tmp = mbrlen (string + pos, length - pos, ps);
5bdf8622	282	if (MB_INVALIDCH ((size_t)tmp))
9255ee31 EZ	283	{
	284	/* in this case, bytes are invalid or shorted to compose
	285	multibyte char, so assume that the first byte represents
	286	a single character anyway. */
	287	pos++;
	288	/* clear the state of the byte sequence, because
	289	in this case effect of mbstate is undefined */
5af408ce EZ	290	if (ps)
5af408ce EZ	291	memset (ps, 0, sizeof (mbstate_t));
9255ee31	292	}
5bdf8622	293	else if (MB_NULLWCH (tmp))
5af408ce	294	pos++;
9255ee31 EZ	295	else
	296	pos += tmp;
	297	}
	298
	299	return (pos - point);
	300	}
	301
	302	int
	303	_rl_is_mbchar_matched (string, seed, end, mbchar, length)
	304	char *string;
	305	int seed, end;
	306	char *mbchar;
	307	int length;
	308	{
	309	int i;
	310
	311	if ((end - seed) < length)
	312	return 0;
	313
	314	for (i = 0; i < length; i++)
	315	if (string[seed + i] != mbchar[i])
	316	return 0;
	317	return 1;
	318	}
5bdf8622 DJ	319
	320	wchar_t
	321	_rl_char_value (buf, ind)
	322	char *buf;
	323	int ind;
	324	{
	325	size_t tmp;
	326	wchar_t wc;
	327	mbstate_t ps;
	328	int l;
	329
	330	if (MB_LEN_MAX == 1 \|\| rl_byte_oriented)
	331	return ((wchar_t) buf[ind]);
	332	l = strlen (buf);
	333	if (ind >= l - 1)
	334	return ((wchar_t) buf[ind]);
	335	memset (&ps, 0, sizeof (mbstate_t));
	336	tmp = mbrtowc (&wc, buf + ind, l - ind, &ps);
	337	if (MB_INVALIDCH (tmp) \|\| MB_NULLWCH (tmp))
	338	return ((wchar_t) buf[ind]);
	339	return wc;
	340	}
9255ee31 EZ	341	#endif /* HANDLE_MULTIBYTE */
	342
	343	/* Find next `count' characters started byte point of the specified seed.
	344	If flags is MB_FIND_NONZERO, we look for non-zero-width multibyte
	345	characters. */
	346	#undef _rl_find_next_mbchar
	347	int
	348	_rl_find_next_mbchar (string, seed, count, flags)
	349	char *string;
	350	int seed, count, flags;
	351	{
	352	#if defined (HANDLE_MULTIBYTE)
	353	return _rl_find_next_mbchar_internal (string, seed, count, flags);
	354	#else
	355	return (seed + count);
	356	#endif
	357	}
	358
	359	/* Find previous character started byte point of the specified seed.
	360	Returned point will be point <= seed. If flags is MB_FIND_NONZERO,
	361	we look for non-zero-width multibyte characters. */
	362	#undef _rl_find_prev_mbchar
	363	int
	364	_rl_find_prev_mbchar (string, seed, flags)
	365	char *string;
	366	int seed, flags;
	367	{
	368	#if defined (HANDLE_MULTIBYTE)
	369	return _rl_find_prev_mbchar_internal (string, seed, flags);
	370	#else
	371	return ((seed == 0) ? seed : seed - 1);
	372	#endif
	373	}