rxvt-unicode/src/misc.C

/*--------------------------------*-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-2004 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_strdup (const char *str)
{
  return str ? strdup (str) : 0;
}

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

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

/*
 * Print an error message
 */
void
rxvt_vlog (const char *fmt, va_list arg_ptr)
{
  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,...)
{
  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,...)
{
  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,...)
{
  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 ();
}

class rxvt_failure_exception rxvt_failure_exception;

void
rxvt_exit_failure ()
{
  throw (rxvt_failure_exception);
}

/*
 * check that the first characters of S1 match S2
 *
 * No Match
 *      return: 0
 * Match
 *      return: strlen (S2)
 */
int
rxvt_Str_match (const char *s1, const char *s2)
{
  int n = strlen (s2);

  return ((strncmp (s1, s2, n) == 0) ? n : 0);
}

const char *
rxvt_Str_skip_space (const char *str)
{
  if (str)
    while (*str && isspace (*str))
      str++;

  return str;
}

/*
 * remove leading/trailing space and strip-off leading/trailing quotes.
 * in place.
 */
char           *
rxvt_Str_trim (char *str)
{
  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--;

#if 0
  /* skip matching leading/trailing quotes */
  if (*s == '"' && *r == '"' && n > 1)
    {
      s++;
      n -= 2;
    }
#endif

  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)
{
  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)
{
  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)
{
  for (int i = 0; cs[i]; ++i)
    free (cs[i]);

  free (cs);
}

/*----------------------------------------------------------------------*
 * file searching
 */

/* #define DEBUG_SEARCH_PATH */

#if defined (XPM_BACKGROUND) || (MENUBAR_MAX)
/*
 * search for FILE in the current working directory, and within the
 * colon-delimited PATHLIST, adding the file extension EXT if required.
 *
 * FILE is either semi-colon or zero terminated
 */
char           *
rxvt_File_search_path (const char *pathlist, const char *file, const char *ext)
{
  int             maxpath, len;
  const char     *p, *path;
  char            name[256];

  if (!access (file, R_OK))     /* found (plain name) in current directory */
    return strdup (file);

  /* semi-colon delimited */
  if ((p = strchr (file, ';')))
    len = (p - file);
  else
    len = strlen (file);

#ifdef DEBUG_SEARCH_PATH
  getcwd (name, sizeof (name));
  fprintf (stderr, "pwd: \"%s\"\n", name);
  fprintf (stderr, "find: \"%.*s\"\n", len, file);
#endif

  /* leave room for an extra '/' and trailing '\0' */
  maxpath = sizeof (name) - (len + (ext ? strlen (ext) : 0) + 2);
  if (maxpath <= 0)
    return NULL;

  /* check if we can find it now */
  strncpy (name, file, len);
  name[len] = '\0';

  if (!access (name, R_OK))
    return strdup (name);
  if (ext)
    {
      strcat (name, ext);
      if (!access (name, R_OK))
        return strdup (name);
    }
  for (path = pathlist; path != NULL && *path != '\0'; path = p)
    {
      int             n;

      /* colon delimited */
      if ((p = strchr (path, ':')) == NULL)
        p = strchr (path, '\0');

      n = (p - path);
      if (*p != '\0')
        p++;

      if (n > 0 && n <= maxpath)
        {
          strncpy (name, path, n);
          if (name[n - 1] != '/')
            name[n++] = '/';
          name[n] = '\0';
          strncat (name, file, len);

          if (!access (name, R_OK))
            return strdup (name);
          if (ext)
            {
              strcat (name, ext);
              if (!access (name, R_OK))
                return strdup (name);
            }
        }
    }
  return NULL;
}

char           *
rxvt_File_find (const char *file, const char *ext, const char *path)
{
  char           *f;

  if (file == NULL || *file == '\0')
    return NULL;

  /* search environment variables here too */
  if ((f = rxvt_File_search_path (path, file, ext)) == NULL)
#ifdef PATH_ENV
    if ((f = rxvt_File_search_path (getenv (PATH_ENV), file, ext)) == NULL)
#endif
      f = rxvt_File_search_path (getenv ("PATH"), file, ext);

#ifdef DEBUG_SEARCH_PATH
  if (f)
    fprintf (stderr, "found: \"%s\"\n", f);
#endif

  return f;
}
#endif                          /* defined (XPM_BACKGROUND) || (MENUBAR_MAX) */

/*----------------------------------------------------------------------*
 * miscellaneous drawing routines
 */

/*
 * Draw top/left and bottom/right border shadows around windows
 */
#if defined(RXVT_SCROLLBAR) || defined(MENUBAR)
void
rxvt_Draw_Shadow (Display *display, Window win, GC topShadow, GC botShadow, int x, int y, int w, int h)
{
  int             shadow;

  shadow = (w == 0 || h == 0) ? 1 : MENU_SHADOW;
  w += x - 1;
  h += y - 1;
  for (; shadow-- > 0; x++, y++, w--, h--)
    {
      XDrawLine (display, win, topShadow, x, y, w, y);
      XDrawLine (display, win, topShadow, x, y, x, h);
      XDrawLine (display, win, botShadow, w, h, w, y + 1);
      XDrawLine (display, win, botShadow, w, h, x + 1, h);
    }
}
#endif

/* button shapes */
#ifdef MENUBAR
void
rxvt_Draw_Triangle (Display *display, Window win, GC topShadow, GC botShadow, int x, int y, int w, int type)
{
  switch (type)
    {
      case 'r':                 /* right triangle */
        XDrawLine (display, win, topShadow, x, y, x, y + w);
        XDrawLine (display, win, topShadow, x, y, x + w, y + w / 2);
        XDrawLine (display, win, botShadow, x, y + w, x + w, y + w / 2);
        break;

      case 'l':                 /* left triangle */
        XDrawLine (display, win, botShadow, x + w, y + w, x + w, y);
        XDrawLine (display, win, botShadow, x + w, y + w, x, y + w / 2);
        XDrawLine (display, win, topShadow, x, y + w / 2, x + w, y);
        break;

      case 'd':                 /* down triangle */
        XDrawLine (display, win, topShadow, x, y, x + w / 2, y + w);
        XDrawLine (display, win, topShadow, x, y, x + w, y);
        XDrawLine (display, win, botShadow, x + w, y, x + w / 2, y + w);
        break;

      case 'u':                 /* up triangle */
        XDrawLine (display, win, botShadow, x + w, y + w, x + w / 2, y);
        XDrawLine (display, win, botShadow, x + w, y + w, x, y + w);
        XDrawLine (display, win, topShadow, x, y + w, x + w / 2, y);
        break;
#if 0
      case 's':                 /* square */
        XDrawLine (display, win, topShadow, x + w, y, x, y);
        XDrawLine (display, win, topShadow, x, y, x, y + w);
        XDrawLine (display, win, botShadow, x, y + w, x + w, y + w);
        XDrawLine (display, win, botShadow, x + w, y + w, x + w, y);
        break;
#endif

    }
}
#endif

// should not be used in interactive programs, for obvious reasons
void rxvt_usleep (int usecs)
{
#if HAVE_NANOSLEEP
  struct timespec ts;

  ts.tv_sec = 0;
  ts.tv_nsec = usecs * 1000;
  nanosleep (&ts, NULL);
#else                 
  /* use select for timing */
  struct timeval  tv;

  tv.tv_sec = 0;
  tv.tv_usec = usecs;
  select (0, NULL, NULL, NULL, &tv);
#endif                
}

/*----------------------- end-of-file (C source) -----------------------*/

Revision:	1.31
Committed:	Fri Jan 6 20:50:58 2006 UTC (18 years, 4 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.30:	+1 -0 lines
Log Message:	* empty log message *
#	Content
1	/---------------------------------C----------------------------------
2	* File: misc.C
3	----------------------------------------------------------------------
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	* Copyright (c) 2003-2004 Marc Lehmann <pcg@goof.com>
10	*
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	char *
30	rxvt_wcstombs (const wchar_t *str, int len)
31	{
32	if (len < 0) len = wcslen (str);
33
34	mbstate mbs;
35	char r = (char )rxvt_malloc (len * MB_CUR_MAX + 1);
36
37	char *dst = r;
38	while (len--)
39	{
40	ssize_t l = wcrtomb (dst, *str++, mbs);
41
42	if (l < 0)
43	*dst++ = '?';
44	else
45	dst += l;
46	}
47
48	*dst++ = 0;
49
50	return (char *)rxvt_realloc (r, dst - r);
51	}
52
53	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	if ((ssize_t)mbstowcs (r, str, len + 1) < 0)
61	*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	unicode_t w = *str++ & UNICODE_MASK;
77
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	*p++ = 0;
97
98	return (char *)rxvt_realloc (r, p - r);
99	}
100
101	wchar_t *
102	rxvt_utf8towcs (const char *str, int len)
103	{
104	if (len < 0) len = strlen (str);
105
106	wchar_t r = (wchar_t )rxvt_malloc ((len + 1) * sizeof (wchar_t)),
107	*p = r;
108
109	unsigned char s = (unsigned char )str,
110	*e = s + len;
111
112	for (;;)
113	{
114	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	&& s[0] >= 0xc2 && s[0] <= 0xdf
122	&& (s[1] & 0xc0) == 0x80)
123	{
124	*p++ = ((s[0] & 0x1f) << 6)
125	\| (s[1] & 0x3f);
126	s += 2;
127	}
128	else if (len >= 3
129	&& ( (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	s += 3;
140	}
141	else if (len >= 4
142	&& ( (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	s += 4;
154	}
155	else
156	{
157	*p++ = 0xfffd;
158	s++;
159	}
160	}
161
162	*p = 0;
163
164	return r;
165	}
166
167	char *
168	rxvt_strdup (const char *str)
169	{
170	return str ? strdup (str) : 0;
171	}
172
173	char *
174	rxvt_r_basename (const char *str)
175	{
176	char *base = strrchr (str, '/');
177
178	return (char *) (base ? base + 1 : str);
179	}
180
181	/*
182	* Print an error message
183	*/
184	void
185	rxvt_vlog (const char *fmt, va_list arg_ptr)
186	{
187	char msg[1024];
188
189	vsnprintf (msg, sizeof msg, fmt, arg_ptr);
190
191	if (GET_R && GET_R->log_hook)
192	(*GET_R->log_hook) (msg);
193	else
194	write (STDOUT_FILENO, msg, strlen (msg));
195	}
196
197	void
198	rxvt_log (const char *fmt,...)
199	{
200	va_list arg_ptr;
201
202	va_start (arg_ptr, fmt);
203	rxvt_vlog (fmt, arg_ptr);
204	va_end (arg_ptr);
205	}
206
207	/*
208	* Print an error message
209	*/
210	void
211	rxvt_warn (const char *fmt,...)
212	{
213	va_list arg_ptr;
214
215	rxvt_log ("%s: ", RESNAME);
216
217	va_start (arg_ptr, fmt);
218	rxvt_vlog (fmt, arg_ptr);
219	va_end (arg_ptr);
220	}
221
222	void
223	rxvt_fatal (const char *fmt,...)
224	{
225	va_list arg_ptr;
226
227	rxvt_log ("%s: ", RESNAME);
228
229	va_start (arg_ptr, fmt);
230	rxvt_vlog (fmt, arg_ptr);
231	va_end (arg_ptr);
232
233	rxvt_exit_failure ();
234	}
235
236	class rxvt_failure_exception rxvt_failure_exception;
237
238	void
239	rxvt_exit_failure ()
240	{
241	throw (rxvt_failure_exception);
242	}
243
244	/*
245	* check that the first characters of S1 match S2
246	*
247	* No Match
248	* return: 0
249	* Match
250	* return: strlen (S2)
251	*/
252	int
253	rxvt_Str_match (const char s1, const char s2)
254	{
255	int n = strlen (s2);
256
257	return ((strncmp (s1, s2, n) == 0) ? n : 0);
258	}
259
260	const char *
261	rxvt_Str_skip_space (const char *str)
262	{
263	if (str)
264	while (str && isspace (str))
265	str++;
266
267	return str;
268	}
269
270	/*
271	* remove leading/trailing space and strip-off leading/trailing quotes.
272	* in place.
273	*/
274	char *
275	rxvt_Str_trim (char *str)
276	{
277	char r, s;
278
279	if (!str \|\| !str) / shortcut */
280	return str;
281
282	/* skip leading spaces */
283	for (s = str; s && isspace (s); s++) ;
284
285	/* goto end of string */
286	r = s + strlen (s) - 1;
287
288	/* dump return and other trailing whitespace */
289	while (r > s && isspace (*r))
290	r--;
291
292	#if 0
293	/* skip matching leading/trailing quotes */
294	if (s == '"' && r == '"' && n > 1)
295	{
296	s++;
297	n -= 2;
298	}
299	#endif
300
301	memmove (str, s, r + 1 - s);
302	str[r + 1 - s] = 0;
303
304	return str;
305	}
306
307	/*
308	* in-place interpretation of string:
309	*
310	* backslash-escaped: "\a\b\E\e\n\r\t", "\octal"
311	* Ctrl chars: ^@ .. ^_, ^?
312	*
313	* Emacs-style: "M-" prefix
314	*
315	* Also,
316	* "M-x" prefixed strings, append "\r" if needed
317	* "\E]" prefixed strings (XTerm escape sequence) append ST if needed
318	*
319	* returns the converted string length
320	*/
321	int
322	rxvt_Str_escaped (char *str)
323	{
324	char ch, s, d;
325	int i, num, append = 0;
326
327	if (!str \|\| !*str)
328	return 0;
329
330	d = s = str;
331
332	if (*s == 'M' && s[1] == '-')
333	{
334	/* Emacs convenience, replace leading `M-..' with `\E..' */
335	*d++ = C0_ESC;
336	s += 2;
337	if (toupper (*s) == 'X')
338	/* append carriage-return for `M-xcommand' */
339	for (d++ = 'x', append = '\r', s++; isspace (s); s++) ;
340	}
341	for (; (ch = *s++);)
342	{
343	if (ch == '\\')
344	{
345	ch = *s++;
346	if (ch >= '0' && ch <= '7')
347	{ /* octal */
348	num = ch - '0';
349	for (i = 0; i < 2; i++, s++)
350	{
351	ch = *s;
352	if (ch < '0' \|\| ch > '7')
353	break;
354	num = num * 8 + ch - '0';
355	}
356	ch = (char)num;
357	}
358	else if (ch == 'a')
359	ch = C0_BEL; /* bell */
360	else if (ch == 'b')
361	ch = C0_BS; /* backspace */
362	else if (ch == 'E' \|\| ch == 'e')
363	ch = C0_ESC; /* escape */
364	else if (ch == 'n')
365	ch = '\n'; /* newline */
366	else if (ch == 'r')
367	ch = '\r'; /* carriage-return */
368	else if (ch == 't')
369	ch = C0_HT; /* tab */
370	}
371	else if (ch == '^')
372	{
373	ch = *s++;
374	ch = toupper (ch);
375	ch = (ch == '?' ? 127 : (ch - '@'));
376	}
377	*d++ = ch;
378	}
379
380	/* ESC] is an XTerm escape sequence, must be terminated */
381	if (*str == '\0' && str[1] == C0_ESC && str[2] == ']')
382	append = CHAR_ST;
383
384	/* add trailing character as required */
385	if (append && d[-1] != append)
386	*d++ = append;
387	*d = '\0';
388
389	return (d - str);
390	}
391
392	/*
393	* Split a comma-separated string into an array, stripping leading and
394	* trailing spaces from each entry. Empty strings are properly returned
395	* Caller should free each entry and array when done
396	*/
397	char **
398	rxvt_splitcommastring (const char *cs)
399	{
400	int l, n, p;
401	const char s, t;
402	char **ret;
403
404	if ((s = cs) == NULL)
405	s = "";
406
407	for (n = 1, t = s; *t; t++)
408	if (*t == ',')
409	n++;
410
411	ret = (char *)malloc ((n + 1) sizeof (char *));
412	ret[n] = NULL;
413
414	for (l = 0, t = s; l < n; l++)
415	{
416	for ( ; t && t != ','; t++) ;
417	p = t - s;
418	ret[l] = (char *)malloc (p + 1);
419	strncpy (ret[l], s, p);
420	ret[l][p] = '\0';
421	rxvt_Str_trim (ret[l]);
422	s = ++t;
423	}
424
425	return ret;
426	}
427
428	void
429	rxvt_freecommastring (char **cs)
430	{
431	for (int i = 0; cs[i]; ++i)
432	free (cs[i]);
433
434	free (cs);
435	}
436
437	/----------------------------------------------------------------------
438	* file searching
439	*/
440
441	/* #define DEBUG_SEARCH_PATH */
442
443	#if defined (XPM_BACKGROUND) \|\| (MENUBAR_MAX)
444	/*
445	* search for FILE in the current working directory, and within the
446	* colon-delimited PATHLIST, adding the file extension EXT if required.
447	*
448	* FILE is either semi-colon or zero terminated
449	*/
450	char *
451	rxvt_File_search_path (const char pathlist, const char file, const char *ext)
452	{
453	int maxpath, len;
454	const char p, path;
455	char name[256];
456
457	if (!access (file, R_OK)) /* found (plain name) in current directory */
458	return strdup (file);
459
460	/* semi-colon delimited */
461	if ((p = strchr (file, ';')))
462	len = (p - file);
463	else
464	len = strlen (file);
465
466	#ifdef DEBUG_SEARCH_PATH
467	getcwd (name, sizeof (name));
468	fprintf (stderr, "pwd: \"%s\"\n", name);
469	fprintf (stderr, "find: \"%.*s\"\n", len, file);
470	#endif
471
472	/* leave room for an extra '/' and trailing '\0' */
473	maxpath = sizeof (name) - (len + (ext ? strlen (ext) : 0) + 2);
474	if (maxpath <= 0)
475	return NULL;
476
477	/* check if we can find it now */
478	strncpy (name, file, len);
479	name[len] = '\0';
480
481	if (!access (name, R_OK))
482	return strdup (name);
483	if (ext)
484	{
485	strcat (name, ext);
486	if (!access (name, R_OK))
487	return strdup (name);
488	}
489	for (path = pathlist; path != NULL && *path != '\0'; path = p)
490	{
491	int n;
492
493	/* colon delimited */
494	if ((p = strchr (path, ':')) == NULL)
495	p = strchr (path, '\0');
496
497	n = (p - path);
498	if (*p != '\0')
499	p++;
500
501	if (n > 0 && n <= maxpath)
502	{
503	strncpy (name, path, n);
504	if (name[n - 1] != '/')
505	name[n++] = '/';
506	name[n] = '\0';
507	strncat (name, file, len);
508
509	if (!access (name, R_OK))
510	return strdup (name);
511	if (ext)
512	{
513	strcat (name, ext);
514	if (!access (name, R_OK))
515	return strdup (name);
516	}
517	}
518	}
519	return NULL;
520	}
521
522	char *
523	rxvt_File_find (const char file, const char ext, const char *path)
524	{
525	char *f;
526
527	if (file == NULL \|\| *file == '\0')
528	return NULL;
529
530	/* search environment variables here too */
531	if ((f = rxvt_File_search_path (path, file, ext)) == NULL)
532	#ifdef PATH_ENV
533	if ((f = rxvt_File_search_path (getenv (PATH_ENV), file, ext)) == NULL)
534	#endif
535	f = rxvt_File_search_path (getenv ("PATH"), file, ext);
536
537	#ifdef DEBUG_SEARCH_PATH
538	if (f)
539	fprintf (stderr, "found: \"%s\"\n", f);
540	#endif
541
542	return f;
543	}
544	#endif /* defined (XPM_BACKGROUND) \|\| (MENUBAR_MAX) */
545
546	/----------------------------------------------------------------------
547	* miscellaneous drawing routines
548	*/
549
550	/*
551	* Draw top/left and bottom/right border shadows around windows
552	*/
553	#if defined(RXVT_SCROLLBAR) \|\| defined(MENUBAR)
554	void
555	rxvt_Draw_Shadow (Display *display, Window win, GC topShadow, GC botShadow, int x, int y, int w, int h)
556	{
557	int shadow;
558
559	shadow = (w == 0 \|\| h == 0) ? 1 : MENU_SHADOW;
560	w += x - 1;
561	h += y - 1;
562	for (; shadow-- > 0; x++, y++, w--, h--)
563	{
564	XDrawLine (display, win, topShadow, x, y, w, y);
565	XDrawLine (display, win, topShadow, x, y, x, h);
566	XDrawLine (display, win, botShadow, w, h, w, y + 1);
567	XDrawLine (display, win, botShadow, w, h, x + 1, h);
568	}
569	}
570	#endif
571
572	/* button shapes */
573	#ifdef MENUBAR
574	void
575	rxvt_Draw_Triangle (Display *display, Window win, GC topShadow, GC botShadow, int x, int y, int w, int type)
576	{
577	switch (type)
578	{
579	case 'r': /* right triangle */
580	XDrawLine (display, win, topShadow, x, y, x, y + w);
581	XDrawLine (display, win, topShadow, x, y, x + w, y + w / 2);
582	XDrawLine (display, win, botShadow, x, y + w, x + w, y + w / 2);
583	break;
584
585	case 'l': /* left triangle */
586	XDrawLine (display, win, botShadow, x + w, y + w, x + w, y);
587	XDrawLine (display, win, botShadow, x + w, y + w, x, y + w / 2);
588	XDrawLine (display, win, topShadow, x, y + w / 2, x + w, y);
589	break;
590
591	case 'd': /* down triangle */
592	XDrawLine (display, win, topShadow, x, y, x + w / 2, y + w);
593	XDrawLine (display, win, topShadow, x, y, x + w, y);
594	XDrawLine (display, win, botShadow, x + w, y, x + w / 2, y + w);
595	break;
596
597	case 'u': /* up triangle */
598	XDrawLine (display, win, botShadow, x + w, y + w, x + w / 2, y);
599	XDrawLine (display, win, botShadow, x + w, y + w, x, y + w);
600	XDrawLine (display, win, topShadow, x, y + w, x + w / 2, y);
601	break;
602	#if 0
603	case 's': /* square */
604	XDrawLine (display, win, topShadow, x + w, y, x, y);
605	XDrawLine (display, win, topShadow, x, y, x, y + w);
606	XDrawLine (display, win, botShadow, x, y + w, x + w, y + w);
607	XDrawLine (display, win, botShadow, x + w, y + w, x + w, y);
608	break;
609	#endif
610
611	}
612	}
613	#endif
614
615	// should not be used in interactive programs, for obvious reasons
616	void rxvt_usleep (int usecs)
617	{
618	#if HAVE_NANOSLEEP
619	struct timespec ts;
620
621	ts.tv_sec = 0;
622	ts.tv_nsec = usecs * 1000;
623	nanosleep (&ts, NULL);
624	#else
625	/* use select for timing */
626	struct timeval tv;
627
628	tv.tv_sec = 0;
629	tv.tv_usec = usecs;
630	select (0, NULL, NULL, NULL, &tv);
631	#endif
632	}
633
634	/----------------------- end-of-file (C source) -----------------------/
635