rxvt-unicode/src/misc.C

/*----------------------------------------------------------------------*
 * File:        misc.C
 *----------------------------------------------------------------------*
 *
 * All portions of code are copyright by their respective author/s.
 * Copyright (c) 1996      mj olesen <olesen@me.QueensU.CA> Queen's Univ at Kingston
 * Copyright (c) 1997,1998 Oezguer Kesim <kesim@math.fu-berlin.de>
 * Copyright (c) 1998-2000 Geoff Wing <gcw@pobox.com>
 * Copyright (c) 2003-2006 Marc Lehmann <pcg@goof.com>
 *
 * This program 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 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *----------------------------------------------------------------------*/

#include "../config.h"          /* NECESSARY */
#include "rxvt.h"               /* NECESSARY */

char *
rxvt_wcstombs (const wchar_t *str, int len)
{
  if (len < 0) len = wcslen (str);

  mbstate mbs;
  char *r = (char *)rxvt_malloc (len * MB_CUR_MAX + 1);

  char *dst = r;
  while (len--)
    {
      ssize_t l = wcrtomb (dst, *str++, mbs);

      if (l < 0)
        *dst++ = '?';
      else
        dst += l;
    }

  *dst++ = 0;

  return (char *)rxvt_realloc (r, dst - r);
}

wchar_t *
rxvt_mbstowcs (const char *str, int len)
{
  if (len < 0) len = strlen (str);

  wchar_t *r = (wchar_t *)rxvt_malloc ((len + 1) * sizeof (wchar_t));

  if ((ssize_t)mbstowcs (r, str, len + 1) < 0)
    *r = 0;

  return r;
}

char *
rxvt_wcstoutf8 (const wchar_t *str, int len)
{
  if (len < 0) len = wcslen (str);

  char *r = (char *)rxvt_malloc (len * 4 + 1);
  char *p = r;

  while (len--)
    {
      unicode_t w = *str++ & UNICODE_MASK;

      if      (w < 0x000080)
        *p++ = w;
      else if (w < 0x000800)
        *p++ = 0xc0 | ( w >>  6),
        *p++ = 0x80 | ( w        & 0x3f);
      else if (w < 0x010000)
        *p++ = 0xe0 | ( w >> 12       ),
        *p++ = 0x80 | ((w >>  6) & 0x3f),
        *p++ = 0x80 | ( w        & 0x3f);
      else if (w < 0x110000)
        *p++ = 0xf0 | ( w >> 18),
        *p++ = 0x80 | ((w >> 12) & 0x3f),
        *p++ = 0x80 | ((w >>  6) & 0x3f),
        *p++ = 0x80 | ( w        & 0x3f);
      else
        *p++ = '?';
    }

  *p++ = 0;

  return (char *)rxvt_realloc (r, p - r);
}

wchar_t *
rxvt_utf8towcs (const char *str, int len)
{
  if (len < 0) len = strlen (str);

  wchar_t *r = (wchar_t *)rxvt_malloc ((len + 1) * sizeof (wchar_t)),
          *p = r;

  unsigned char *s = (unsigned char *)str,
                *e = s + len;

  for (;;)
    {
      len = e - s;

      if (len == 0)
        break;
      else if (s[0] < 0x80)
        *p++ = *s++;
      else if (len >= 2
               && s[0] >= 0xc2 && s[0] <= 0xdf 
               && (s[1] & 0xc0) == 0x80)
        {
          *p++ = ((s[0] & 0x1f) << 6)
               |  (s[1] & 0x3f);
          s += 2;
        }
      else if (len >= 3
               && (   (s[0] == 0xe0                 && s[1] >= 0xa0 && s[1] <= 0xbf)
                   || (s[0] >= 0xe1 && s[0] <= 0xec && s[1] >= 0x80 && s[1] <= 0xbf)
                   || (s[0] == 0xed                 && s[1] >= 0x80 && s[1] <= 0x9f)
                   || (s[0] >= 0xee && s[0] <= 0xef && s[1] >= 0x80 && s[1] <= 0xbf)
                  )
               && (s[2] & 0xc0) == 0x80)
        {
          *p++ = ((s[0] & 0x0f) << 12)
               | ((s[1] & 0x3f) <<  6)
               |  (s[2] & 0x3f);
          s += 3;
        }
      else if (len >= 4
               && (   (s[0] == 0xf0                 && s[1] >= 0x90 && s[1] <= 0xbf)
                   || (s[0] >= 0xf1 && s[0] <= 0xf3 && s[1] >= 0x80 && s[1] <= 0xbf)
                   || (s[0] == 0xf4                 && s[1] >= 0x80 && s[1] <= 0x8f)
                  )
               && (s[2] & 0xc0) == 0x80
               && (s[3] & 0xc0) == 0x80)
        {
          *p++ = ((s[0] & 0x07) << 18) 
               | ((s[1] & 0x3f) << 12) 
               | ((s[2] & 0x3f) <<  6) 
               |  (s[3] & 0x3f);
          s += 4;
        }
      else
        {
          *p++ = 0xfffd;
          s++;
        }
    }

  *p = 0;

  return r;
}

char *
rxvt_r_basename (const char *str) NOTHROW
{
  char *base = strrchr (str, '/');

  return (char *) (base ? base + 1 : str);
}

/*
 * Print an error message
 */
void
rxvt_vlog (const char *fmt, va_list arg_ptr) NOTHROW
{
  char msg[1024];

  vsnprintf (msg, sizeof msg, fmt, arg_ptr);

  if (GET_R && GET_R->log_hook)
    (*GET_R->log_hook) (msg);
  else
    write (STDOUT_FILENO, msg, strlen (msg));
}

void
rxvt_log (const char *fmt,...) NOTHROW
{
  va_list arg_ptr;

  va_start (arg_ptr, fmt);
  rxvt_vlog (fmt, arg_ptr);
  va_end (arg_ptr);
}

/*
 * Print an error message
 */
void
rxvt_warn (const char *fmt,...) NOTHROW
{
  va_list arg_ptr;

  rxvt_log ("%s: ", RESNAME);

  va_start (arg_ptr, fmt);
  rxvt_vlog (fmt, arg_ptr);
  va_end (arg_ptr);
}

void
rxvt_fatal (const char *fmt,...) THROW ((class rxvt_failure_exception))
{
  va_list arg_ptr;

  rxvt_log ("%s: ", RESNAME);

  va_start (arg_ptr, fmt);
  rxvt_vlog (fmt, arg_ptr);
  va_end (arg_ptr);

  rxvt_exit_failure ();
}

void
rxvt_exit_failure () THROW ((class rxvt_failure_exception))
{
  static class rxvt_failure_exception rxvt_failure_exception;
  throw (rxvt_failure_exception);
}

/*
 * remove leading/trailing space in place.
 */
char           *
rxvt_Str_trim (char *str) NOTHROW
{
  char *r, *s;

  if (!str || !*str)            /* shortcut */
    return str;

  /* skip leading spaces */
  for (s = str; *s && isspace (*s); s++) ;

  /* goto end of string */
  r = s + strlen (s) - 1;

  /* dump return and other trailing whitespace */
  while (r > s && isspace (*r))
    r--;

  memmove (str, s, r + 1 - s);
  str[r + 1 - s] = 0;

  return str;
}

/*
 * in-place interpretation of string:
 *
 *      backslash-escaped:      "\a\b\E\e\n\r\t", "\octal"
 *      Ctrl chars:     ^@ .. ^_, ^?
 *
 *      Emacs-style:    "M-" prefix
 *
 * Also,
 *      "M-x" prefixed strings, append "\r" if needed
 *      "\E]" prefixed strings (XTerm escape sequence) append ST if needed
 *
 * returns the converted string length
 */
int
rxvt_Str_escaped (char *str) NOTHROW
{
  char            ch, *s, *d;
  int             i, num, append = 0;

  if (!str || !*str)
    return 0;

  d = s = str;

  if (*s == 'M' && s[1] == '-')
    {
      /* Emacs convenience, replace leading `M-..' with `\E..' */
      *d++ = C0_ESC;
      s += 2;
      if (toupper (*s) == 'X')
        /* append carriage-return for `M-xcommand' */
        for (*d++ = 'x', append = '\r', s++; isspace (*s); s++) ;
    }
  for (; (ch = *s++);)
    {
      if (ch == '\\')
        {
          ch = *s++;
          if (ch >= '0' && ch <= '7')
            {   /* octal */
              num = ch - '0';
              for (i = 0; i < 2; i++, s++)
                {
                  ch = *s;
                  if (ch < '0' || ch > '7')
                    break;
                  num = num * 8 + ch - '0';
                }
              ch = (char)num;
            }
          else if (ch == 'a')
            ch = C0_BEL;        /* bell */
          else if (ch == 'b')
            ch = C0_BS; /* backspace */
          else if (ch == 'E' || ch == 'e')
            ch = C0_ESC;        /* escape */
          else if (ch == 'n')
            ch = '\n';  /* newline */
          else if (ch == 'r')
            ch = '\r';  /* carriage-return */
          else if (ch == 't')
            ch = C0_HT; /* tab */
        }
      else if (ch == '^')
        {
          ch = *s++;
          ch = toupper (ch);
          ch = (ch == '?' ? 127 : (ch - '@'));
        }
      *d++ = ch;
    }

  /* ESC] is an XTerm escape sequence, must be terminated */
  if (*str == '\0' && str[1] == C0_ESC && str[2] == ']')
    append = CHAR_ST;

  /* add trailing character as required */
  if (append && d[-1] != append)
    *d++ = append;
  *d = '\0';

  return (d - str);
}

/*
 * Split a comma-separated string into an array, stripping leading and
 * trailing spaces from each entry.  Empty strings are properly returned
 * Caller should free each entry and array when done
 */
char          **
rxvt_splitcommastring (const char *cs) NOTHROW
{
  int             l, n, p;
  const char     *s, *t;
  char          **ret;

  if ((s = cs) == NULL)
    s = "";

  for (n = 1, t = s; *t; t++)
    if (*t == ',')
      n++;

  ret = (char **)malloc ((n + 1) * sizeof (char *));
  ret[n] = NULL;

  for (l = 0, t = s; l < n; l++)
    {
      for ( ; *t && *t != ','; t++) ;
      p = t - s;
      ret[l] = (char *)malloc (p + 1);
      strncpy (ret[l], s, p);
      ret[l][p] = '\0';
      rxvt_Str_trim (ret[l]);
      s = ++t;
    }

  return ret;
}

void
rxvt_freecommastring (char **cs) NOTHROW
{
  for (int i = 0; cs[i]; ++i)
    free (cs[i]);

  free (cs);
}


Revision:	1.44
Committed:	Mon Sep 3 07:31:12 2007 UTC (16 years, 8 months ago) by ayin
Content type:	text/plain
Branch:	MAIN
Changes since 1.43:	+1 -11 lines
Log Message:	Remove dead code and fix comment.
#	User	Rev	Content
1	root	1.40	/----------------------------------------------------------------------
2	pcg	1.13	* File: misc.C
3	pcg	1.1	----------------------------------------------------------------------
4			*
5			* All portions of code are copyright by their respective author/s.
6			* Copyright (c) 1996 mj olesen <olesen@me.QueensU.CA> Queen's Univ at Kingston
7			* Copyright (c) 1997,1998 Oezguer Kesim <kesim@math.fu-berlin.de>
8			* Copyright (c) 1998-2000 Geoff Wing <gcw@pobox.com>
9	root	1.39	* Copyright (c) 2003-2006 Marc Lehmann <pcg@goof.com>
10	pcg	1.1	*
11			* This program is free software; you can redistribute it and/or modify
12			* it under the terms of the GNU General Public License as published by
13			* the Free Software Foundation; either version 2 of the License, or
14			* (at your option) any later version.
15			*
16			* This program is distributed in the hope that it will be useful,
17			* but WITHOUT ANY WARRANTY; without even the implied warranty of
18			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19			* GNU General Public License for more details.
20			*
21			* You should have received a copy of the GNU General Public License
22			* along with this program; if not, write to the Free Software
23			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24			----------------------------------------------------------------------/
25
26			#include "../config.h" /* NECESSARY */
27			#include "rxvt.h" /* NECESSARY */
28
29	pcg	1.3	char *
30	pcg	1.10	rxvt_wcstombs (const wchar_t *str, int len)
31			{
32	root	1.19	if (len < 0) len = wcslen (str);
33
34	pcg	1.10	mbstate mbs;
35			char r = (char )rxvt_malloc (len * MB_CUR_MAX + 1);
36
37			char *dst = r;
38			while (len--)
39			{
40	root	1.24	ssize_t l = wcrtomb (dst, *str++, mbs);
41	root	1.31
42	pcg	1.10	if (l < 0)
43			*dst++ = '?';
44			else
45			dst += l;
46			}
47
48			*dst++ = 0;
49
50	root	1.24	return (char *)rxvt_realloc (r, dst - r);
51	pcg	1.10	}
52
53	root	1.19	wchar_t *
54			rxvt_mbstowcs (const char *str, int len)
55			{
56			if (len < 0) len = strlen (str);
57
58			wchar_t r = (wchar_t )rxvt_malloc ((len + 1) * sizeof (wchar_t));
59
60	root	1.24	if ((ssize_t)mbstowcs (r, str, len + 1) < 0)
61	root	1.19	*r = 0;
62
63			return r;
64			}
65
66			char *
67			rxvt_wcstoutf8 (const wchar_t *str, int len)
68			{
69			if (len < 0) len = wcslen (str);
70
71			char r = (char )rxvt_malloc (len * 4 + 1);
72			char *p = r;
73
74			while (len--)
75			{
76	root	1.22	unicode_t w = *str++ & UNICODE_MASK;
77	root	1.19
78			if (w < 0x000080)
79			*p++ = w;
80			else if (w < 0x000800)
81			*p++ = 0xc0 \| ( w >> 6),
82			*p++ = 0x80 \| ( w & 0x3f);
83			else if (w < 0x010000)
84			*p++ = 0xe0 \| ( w >> 12 ),
85			*p++ = 0x80 \| ((w >> 6) & 0x3f),
86			*p++ = 0x80 \| ( w & 0x3f);
87			else if (w < 0x110000)
88			*p++ = 0xf0 \| ( w >> 18),
89			*p++ = 0x80 \| ((w >> 12) & 0x3f),
90			*p++ = 0x80 \| ((w >> 6) & 0x3f),
91			*p++ = 0x80 \| ( w & 0x3f);
92			else
93			*p++ = '?';
94			}
95
96	root	1.24	*p++ = 0;
97	root	1.19
98	root	1.24	return (char *)rxvt_realloc (r, p - r);
99	root	1.19	}
100
101			wchar_t *
102			rxvt_utf8towcs (const char *str, int len)
103			{
104			if (len < 0) len = strlen (str);
105
106	root	1.21	wchar_t r = (wchar_t )rxvt_malloc ((len + 1) * sizeof (wchar_t)),
107			*p = r;
108	root	1.19
109	root	1.21	unsigned char s = (unsigned char )str,
110			*e = s + len;
111	root	1.19
112	root	1.21	for (;;)
113	root	1.19	{
114	root	1.21	len = e - s;
115
116			if (len == 0)
117			break;
118			else if (s[0] < 0x80)
119			p++ = s++;
120			else if (len >= 2
121	root	1.19	&& s[0] >= 0xc2 && s[0] <= 0xdf
122			&& (s[1] & 0xc0) == 0x80)
123			{
124			*p++ = ((s[0] & 0x1f) << 6)
125			\| (s[1] & 0x3f);
126	root	1.21	s += 2;
127	root	1.19	}
128	root	1.21	else if (len >= 3
129	root	1.19	&& ( (s[0] == 0xe0 && s[1] >= 0xa0 && s[1] <= 0xbf)
130			\|\| (s[0] >= 0xe1 && s[0] <= 0xec && s[1] >= 0x80 && s[1] <= 0xbf)
131			\|\| (s[0] == 0xed && s[1] >= 0x80 && s[1] <= 0x9f)
132			\|\| (s[0] >= 0xee && s[0] <= 0xef && s[1] >= 0x80 && s[1] <= 0xbf)
133			)
134			&& (s[2] & 0xc0) == 0x80)
135			{
136			*p++ = ((s[0] & 0x0f) << 12)
137			\| ((s[1] & 0x3f) << 6)
138			\| (s[2] & 0x3f);
139	root	1.21	s += 3;
140	root	1.19	}
141	root	1.21	else if (len >= 4
142	root	1.19	&& ( (s[0] == 0xf0 && s[1] >= 0x90 && s[1] <= 0xbf)
143			\|\| (s[0] >= 0xf1 && s[0] <= 0xf3 && s[1] >= 0x80 && s[1] <= 0xbf)
144			\|\| (s[0] == 0xf4 && s[1] >= 0x80 && s[1] <= 0x8f)
145			)
146			&& (s[2] & 0xc0) == 0x80
147			&& (s[3] & 0xc0) == 0x80)
148			{
149			*p++ = ((s[0] & 0x07) << 18)
150			\| ((s[1] & 0x3f) << 12)
151			\| ((s[2] & 0x3f) << 6)
152			\| (s[3] & 0x3f);
153	root	1.21	s += 4;
154	root	1.19	}
155			else
156			{
157			*p++ = 0xfffd;
158	root	1.21	s++;
159	root	1.19	}
160			}
161
162			*p = 0;
163
164			return r;
165			}
166
167	pcg	1.10	char *
168	root	1.36	rxvt_r_basename (const char *str) NOTHROW
169	pcg	1.1	{
170	root	1.15	char *base = strrchr (str, '/');
171	pcg	1.1
172	pcg	1.7	return (char *) (base ? base + 1 : str);
173	pcg	1.1	}
174
175			/*
176			* Print an error message
177			*/
178			void
179	root	1.36	rxvt_vlog (const char *fmt, va_list arg_ptr) NOTHROW
180	pcg	1.12	{
181			char msg[1024];
182
183			vsnprintf (msg, sizeof msg, fmt, arg_ptr);
184
185			if (GET_R && GET_R->log_hook)
186			(*GET_R->log_hook) (msg);
187			else
188			write (STDOUT_FILENO, msg, strlen (msg));
189			}
190
191			void
192	root	1.36	rxvt_log (const char *fmt,...) NOTHROW
193	pcg	1.1	{
194	pcg	1.8	va_list arg_ptr;
195	pcg	1.1
196	pcg	1.7	va_start (arg_ptr, fmt);
197	pcg	1.12	rxvt_vlog (fmt, arg_ptr);
198	pcg	1.7	va_end (arg_ptr);
199	pcg	1.1	}
200
201			/*
202	pcg	1.12	* Print an error message
203			*/
204			void
205	root	1.36	rxvt_warn (const char *fmt,...) NOTHROW
206	pcg	1.12	{
207			va_list arg_ptr;
208
209			rxvt_log ("%s: ", RESNAME);
210
211			va_start (arg_ptr, fmt);
212			rxvt_vlog (fmt, arg_ptr);
213			va_end (arg_ptr);
214			}
215
216			void
217	root	1.36	rxvt_fatal (const char *fmt,...) THROW ((class rxvt_failure_exception))
218	pcg	1.12	{
219			va_list arg_ptr;
220
221			rxvt_log ("%s: ", RESNAME);
222
223			va_start (arg_ptr, fmt);
224			rxvt_vlog (fmt, arg_ptr);
225			va_end (arg_ptr);
226
227			rxvt_exit_failure ();
228			}
229
230			void
231	root	1.36	rxvt_exit_failure () THROW ((class rxvt_failure_exception))
232	pcg	1.12	{
233	root	1.36	static class rxvt_failure_exception rxvt_failure_exception;
234	pcg	1.12	throw (rxvt_failure_exception);
235			}
236
237			/*
238	ayin	1.44	* remove leading/trailing space in place.
239	pcg	1.1	*/
240			char *
241	root	1.36	rxvt_Str_trim (char *str) NOTHROW
242	pcg	1.1	{
243	pcg	1.8	char r, s;
244	pcg	1.1
245	pcg	1.5	if (!str \|\| !str) / shortcut */
246			return str;
247	pcg	1.1
248	pcg	1.5	/* skip leading spaces */
249	pcg	1.7	for (s = str; s && isspace (s); s++) ;
250	root	1.25
251	pcg	1.5	/* goto end of string */
252	root	1.25	r = s + strlen (s) - 1;
253
254			/* dump return and other trailing whitespace */
255			while (r > s && isspace (*r))
256			r--;
257
258			memmove (str, s, r + 1 - s);
259			str[r + 1 - s] = 0;
260	pcg	1.1
261	pcg	1.5	return str;
262	pcg	1.1	}
263
264			/*
265			* in-place interpretation of string:
266			*
267			* backslash-escaped: "\a\b\E\e\n\r\t", "\octal"
268			* Ctrl chars: ^@ .. ^_, ^?
269			*
270			* Emacs-style: "M-" prefix
271			*
272			* Also,
273			* "M-x" prefixed strings, append "\r" if needed
274			* "\E]" prefixed strings (XTerm escape sequence) append ST if needed
275			*
276			* returns the converted string length
277			*/
278			int
279	root	1.36	rxvt_Str_escaped (char *str) NOTHROW
280	pcg	1.1	{
281	pcg	1.5	char ch, s, d;
282			int i, num, append = 0;
283	pcg	1.1
284	pcg	1.5	if (!str \|\| !*str)
285			return 0;
286	pcg	1.1
287	pcg	1.5	d = s = str;
288	pcg	1.1
289	pcg	1.5	if (*s == 'M' && s[1] == '-')
290			{
291			/* Emacs convenience, replace leading `M-..' with `\E..' */
292			*d++ = C0_ESC;
293			s += 2;
294	pcg	1.7	if (toupper (*s) == 'X')
295	pcg	1.5	/* append carriage-return for `M-xcommand' */
296	pcg	1.7	for (d++ = 'x', append = '\r', s++; isspace (s); s++) ;
297	pcg	1.1	}
298	pcg	1.5	for (; (ch = *s++);)
299			{
300			if (ch == '\\')
301			{
302			ch = *s++;
303			if (ch >= '0' && ch <= '7')
304			{ /* octal */
305			num = ch - '0';
306			for (i = 0; i < 2; i++, s++)
307			{
308			ch = *s;
309			if (ch < '0' \|\| ch > '7')
310			break;
311			num = num * 8 + ch - '0';
312			}
313			ch = (char)num;
314			}
315			else if (ch == 'a')
316			ch = C0_BEL; /* bell */
317			else if (ch == 'b')
318			ch = C0_BS; /* backspace */
319			else if (ch == 'E' \|\| ch == 'e')
320			ch = C0_ESC; /* escape */
321			else if (ch == 'n')
322			ch = '\n'; /* newline */
323			else if (ch == 'r')
324			ch = '\r'; /* carriage-return */
325			else if (ch == 't')
326			ch = C0_HT; /* tab */
327			}
328			else if (ch == '^')
329			{
330			ch = *s++;
331	pcg	1.7	ch = toupper (ch);
332	pcg	1.5	ch = (ch == '?' ? 127 : (ch - '@'));
333			}
334			*d++ = ch;
335	pcg	1.1	}
336
337	pcg	1.5	/* ESC] is an XTerm escape sequence, must be terminated */
338			if (*str == '\0' && str[1] == C0_ESC && str[2] == ']')
339			append = CHAR_ST;
340
341			/* add trailing character as required */
342			if (append && d[-1] != append)
343			*d++ = append;
344			*d = '\0';
345	pcg	1.1
346	pcg	1.5	return (d - str);
347	pcg	1.1	}
348
349			/*
350			* Split a comma-separated string into an array, stripping leading and
351	root	1.25	* trailing spaces from each entry. Empty strings are properly returned
352	pcg	1.1	* Caller should free each entry and array when done
353			*/
354			char **
355	root	1.36	rxvt_splitcommastring (const char *cs) NOTHROW
356	pcg	1.1	{
357	pcg	1.5	int l, n, p;
358			const char s, t;
359			char **ret;
360
361			if ((s = cs) == NULL)
362			s = "";
363
364			for (n = 1, t = s; *t; t++)
365			if (*t == ',')
366			n++;
367	root	1.25
368	pcg	1.7	ret = (char *)malloc ((n + 1) sizeof (char *));
369	pcg	1.5	ret[n] = NULL;
370
371			for (l = 0, t = s; l < n; l++)
372			{
373			for ( ; t && t != ','; t++) ;
374			p = t - s;
375	pcg	1.7	ret[l] = (char *)malloc (p + 1);
376			strncpy (ret[l], s, p);
377	pcg	1.5	ret[l][p] = '\0';
378	pcg	1.7	rxvt_Str_trim (ret[l]);
379	pcg	1.5	s = ++t;
380	pcg	1.1	}
381	root	1.25
382	pcg	1.5	return ret;
383	pcg	1.1	}
384
385	root	1.16	void
386	root	1.36	rxvt_freecommastring (char **cs) NOTHROW
387	root	1.16	{
388			for (int i = 0; cs[i]; ++i)
389			free (cs[i]);
390
391			free (cs);
392			}
393
394	pcg	1.1
395	root	1.28