src/misc.C

   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 #include "misc.intpro"          /* PROTOS for internal routines */
  29
  30 /* EXTPROTO */
  31 char *
  32 rxvt_wcstombs (const wchar_t *str, int len)
  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       int l = wcrtomb (dst, *str++, mbs);
  41       if (l < 0)
  42         *dst++ = '?';
  43       else
  44         dst += l;
  45     }
  46
  47   *dst++ = 0;
  48
  49   return r;
  50 }
  51
  52 /* EXTPROTO */
  53 char *
  54 rxvt_strdup (const char *str)
  55 {
  56   return str ? strdup (str) : 0;
  57 }
  58
  59 /* EXTPROTO */
  60 char *
  61 rxvt_r_basename (const char *str)
  62 {
  63   char *base = STRRCHR (str, '/');
  64
  65   return (char *) (base ? base + 1 : str);
  66 }
  67
  68 /*
  69  * Print an error message
  70  */
  71 /* EXTPROTO */
  72 void
  73 rxvt_vlog (const char *fmt, va_list arg_ptr)
  74 {
  75   char msg[1024];
  76
  77   vsnprintf (msg, sizeof msg, fmt, arg_ptr);
  78
  79   if (GET_R && GET_R->log_hook)
  80     (*GET_R->log_hook) (msg);
  81   else
  82     write (STDOUT_FILENO, msg, strlen (msg));
  83 }
  84
  85 /* EXTPROTO */
  86 void
  87 rxvt_log (const char *fmt,...)
  88 {
  89   va_list arg_ptr;
  90
  91   va_start (arg_ptr, fmt);
  92   rxvt_vlog (fmt, arg_ptr);
  93   va_end (arg_ptr);
  94 }
  95
  96 /*
  97  * Print an error message
  98  */
  99 /* EXTPROTO */
 100 void
 101 rxvt_warn (const char *fmt,...)
 102 {
 103   va_list arg_ptr;
 104
 105   rxvt_log ("%s: ", RESNAME);
 106
 107   va_start (arg_ptr, fmt);
 108   rxvt_vlog (fmt, arg_ptr);
 109   va_end (arg_ptr);
 110 }
 111
 112 /* EXTPROTO */
 113 void
 114 rxvt_fatal (const char *fmt,...)
 115 {
 116   va_list arg_ptr;
 117
 118   rxvt_log ("%s: ", RESNAME);
 119
 120   va_start (arg_ptr, fmt);
 121   rxvt_vlog (fmt, arg_ptr);
 122   va_end (arg_ptr);
 123
 124   rxvt_exit_failure ();
 125 }
 126
 127 class rxvt_failure_exception rxvt_failure_exception;
 128
 129 /* EXTPROTO */
 130 void
 131 rxvt_exit_failure ()
 132 {
 133   throw (rxvt_failure_exception);
 134 }
 135
 136 /*
 137  * check that the first characters of S1 match S2
 138  *
 139  * No Match
 140  *      return: 0
 141  * Match
 142  *      return: STRLEN (S2)
 143  */
 144 /* EXTPROTO */
 145 int
 146 rxvt_Str_match (const char *s1, const char *s2)
 147 {
 148   int n = STRLEN (s2);
 149
 150   return ((STRNCMP (s1, s2, n) == 0) ? n : 0);
 151 }
 152
 153 /* EXTPROTO */
 154 const char *
 155 rxvt_Str_skip_space (const char *str)
 156 {
 157   if (str)
 158     while (*str && isspace (*str))
 159       str++;
 160
 161   return str;
 162 }
 163
 164 /*
 165  * remove leading/trailing space and strip-off leading/trailing quotes.
 166  * in place.
 167  */
 168 /* EXTPROTO */
 169 char           *
 170 rxvt_Str_trim (char *str)
 171 {
 172   char *r, *s;
 173   int n;
 174
 175   if (!str || !*str)            /* shortcut */
 176     return str;
 177
 178   /* skip leading spaces */
 179   for (s = str; *s && isspace (*s); s++) ;
 180   /* goto end of string */
 181   for (n = 0, r = s; *r++; n++) ;
 182   r -= 2;
 183   /* dump return */
 184   if (n > 0 && *r == '\n')
 185     n--, r--;
 186   /* backtrack along trailing spaces */
 187   for (; n > 0 && isspace (*r); r--, n--) ;
 188   /* skip matching leading/trailing quotes */
 189   if (*s == '"' && *r == '"' && n > 1)
 190     {
 191       s++;
 192       n -= 2;
 193     }
 194
 195   /* copy back over: forwards copy */
 196   for (r = str; n; n--)
 197     *r++ = *s++;
 198   *r = '\0';
 199
 200   return str;
 201 }
 202
 203 /*
 204  * in-place interpretation of string:
 205  *
 206  *      backslash-escaped:      "\a\b\E\e\n\r\t", "\octal"
 207  *      Ctrl chars:     ^@ .. ^_, ^?
 208  *
 209  *      Emacs-style:    "M-" prefix
 210  *
 211  * Also,
 212  *      "M-x" prefixed strings, append "\r" if needed
 213  *      "\E]" prefixed strings (XTerm escape sequence) append ST if needed
 214  *
 215  * returns the converted string length
 216  */
 217 /* EXTPROTO */
 218 int
 219 rxvt_Str_escaped (char *str)
 220 {
 221   char            ch, *s, *d;
 222   int             i, num, append = 0;
 223
 224   if (!str || !*str)
 225     return 0;
 226
 227   d = s = str;
 228
 229   if (*s == 'M' && s[1] == '-')
 230     {
 231       /* Emacs convenience, replace leading `M-..' with `\E..' */
 232       *d++ = C0_ESC;
 233       s += 2;
 234       if (toupper (*s) == 'X')
 235         /* append carriage-return for `M-xcommand' */
 236         for (*d++ = 'x', append = '\r', s++; isspace (*s); s++) ;
 237     }
 238   for (; (ch = *s++);)
 239     {
 240       if (ch == '\\')
 241         {
 242           ch = *s++;
 243           if (ch >= '0' && ch <= '7')
 244             {   /* octal */
 245               num = ch - '0';
 246               for (i = 0; i < 2; i++, s++)
 247                 {
 248                   ch = *s;
 249                   if (ch < '0' || ch > '7')
 250                     break;
 251                   num = num * 8 + ch - '0';
 252                 }
 253               ch = (char)num;
 254             }
 255           else if (ch == 'a')
 256             ch = C0_BEL;        /* bell */
 257           else if (ch == 'b')
 258             ch = C0_BS; /* backspace */
 259           else if (ch == 'E' || ch == 'e')
 260             ch = C0_ESC;        /* escape */
 261           else if (ch == 'n')
 262             ch = '\n';  /* newline */
 263           else if (ch == 'r')
 264             ch = '\r';  /* carriage-return */
 265           else if (ch == 't')
 266             ch = C0_HT; /* tab */
 267         }
 268       else if (ch == '^')
 269         {
 270           ch = *s++;
 271           ch = toupper (ch);
 272           ch = (ch == '?' ? 127 : (ch - '@'));
 273         }
 274       *d++ = ch;
 275     }
 276
 277   /* ESC] is an XTerm escape sequence, must be terminated */
 278   if (*str == '\0' && str[1] == C0_ESC && str[2] == ']')
 279     append = CHAR_ST;
 280
 281   /* add trailing character as required */
 282   if (append && d[-1] != append)
 283     *d++ = append;
 284   *d = '\0';
 285
 286   return (d - str);
 287 }
 288
 289 /*
 290  * Split a comma-separated string into an array, stripping leading and
 291  * trailing spaces (and paired quotes) from each entry.  Empty strings
 292  * are properly returned
 293  * Caller should free each entry and array when done
 294  */
 295 /* EXTPROTO */
 296 char          **
 297 rxvt_splitcommastring (const char *cs)
 298 {
 299   int             l, n, p;
 300   const char     *s, *t;
 301   char          **ret;
 302
 303   if ((s = cs) == NULL)
 304     s = "";
 305
 306   for (n = 1, t = s; *t; t++)
 307     if (*t == ',')
 308       n++;
 309   ret = (char **)malloc ((n + 1) * sizeof (char *));
 310   ret[n] = NULL;
 311
 312   for (l = 0, t = s; l < n; l++)
 313     {
 314       for ( ; *t && *t != ','; t++) ;
 315       p = t - s;
 316       ret[l] = (char *)malloc (p + 1);
 317       strncpy (ret[l], s, p);
 318       ret[l][p] = '\0';
 319       rxvt_Str_trim (ret[l]);
 320       s = ++t;
 321     }
 322   return ret;
 323 }
 324
 325 /*----------------------------------------------------------------------*
 326  * file searching
 327  */
 328
 329 /* #define DEBUG_SEARCH_PATH */
 330
 331 #if defined (XPM_BACKGROUND) || (MENUBAR_MAX)
 332 /*
 333  * search for FILE in the current working directory, and within the
 334  * colon-delimited PATHLIST, adding the file extension EXT if required.
 335  *
 336  * FILE is either semi-colon or zero terminated
 337  */
 338 /* INTPROTO */
 339 char           *
 340 rxvt_File_search_path (const char *pathlist, const char *file, const char *ext)
 341 {
 342   int             maxpath, len;
 343   const char     *p, *path;
 344   char            name[256];
 345
 346   if (!access (file, R_OK))     /* found (plain name) in current directory */
 347     return STRDUP (file);
 348
 349   /* semi-colon delimited */
 350   if ((p = STRCHR (file, ';')))
 351     len = (p - file);
 352   else
 353     len = STRLEN (file);
 354
 355 #ifdef DEBUG_SEARCH_PATH
 356   getcwd (name, sizeof (name));
 357   fprintf (stderr, "pwd: \"%s\"\n", name);
 358   fprintf (stderr, "find: \"%.*s\"\n", len, file);
 359 #endif
 360
 361   /* leave room for an extra '/' and trailing '\0' */
 362   maxpath = sizeof (name) - (len + (ext ? STRLEN (ext) : 0) + 2);
 363   if (maxpath <= 0)
 364     return NULL;
 365
 366   /* check if we can find it now */
 367   STRNCPY (name, file, len);
 368   name[len] = '\0';
 369
 370   if (!access (name, R_OK))
 371     return STRDUP (name);
 372   if (ext)
 373     {
 374       STRCAT (name, ext);
 375       if (!access (name, R_OK))
 376         return STRDUP (name);
 377     }
 378   for (path = pathlist; path != NULL && *path != '\0'; path = p)
 379     {
 380       int             n;
 381
 382       /* colon delimited */
 383       if ((p = STRCHR (path, ':')) == NULL)
 384         p = STRCHR (path, '\0');
 385
 386       n = (p - path);
 387       if (*p != '\0')
 388         p++;
 389
 390       if (n > 0 && n <= maxpath)
 391         {
 392           STRNCPY (name, path, n);
 393           if (name[n - 1] != '/')
 394             name[n++] = '/';
 395           name[n] = '\0';
 396           STRNCAT (name, file, len);
 397
 398           if (!access (name, R_OK))
 399             return STRDUP (name);
 400           if (ext)
 401             {
 402               STRCAT (name, ext);
 403               if (!access (name, R_OK))
 404                 return STRDUP (name);
 405             }
 406         }
 407     }
 408   return NULL;
 409 }
 410
 411 /* EXTPROTO */
 412 char           *
 413 rxvt_File_find (const char *file, const char *ext, const char *path)
 414 {
 415   char           *f;
 416
 417   if (file == NULL || *file == '\0')
 418     return NULL;
 419
 420   /* search environment variables here too */
 421   if ((f = rxvt_File_search_path (path, file, ext)) == NULL)
 422 #ifdef PATH_ENV
 423     if ((f = rxvt_File_search_path (getenv (PATH_ENV), file, ext)) == NULL)
 424 #endif
 425       f = rxvt_File_search_path (getenv ("PATH"), file, ext);
 426
 427 #ifdef DEBUG_SEARCH_PATH
 428   if (f)
 429     fprintf (stderr, "found: \"%s\"\n", f);
 430 #endif
 431
 432   return f;
 433 }
 434 #endif                          /* defined (XPM_BACKGROUND) || (MENUBAR_MAX) */
 435
 436 /*----------------------------------------------------------------------*
 437  * miscellaneous drawing routines
 438  */
 439
 440 /*
 441  * Draw top/left and bottom/right border shadows around windows
 442  */
 443 #if defined(RXVT_SCROLLBAR) || defined(MENUBAR)
 444 /* EXTPROTO */
 445 void
 446 rxvt_Draw_Shadow (Display *display, Window win, GC topShadow, GC botShadow, int x, int y, int w, int h)
 447 {
 448   int             shadow;
 449
 450   shadow = (w == 0 || h == 0) ? 1 : SHADOW;
 451   w += x - 1;
 452   h += y - 1;
 453   for (; shadow-- > 0; x++, y++, w--, h--)
 454     {
 455       XDrawLine (display, win, topShadow, x, y, w, y);
 456       XDrawLine (display, win, topShadow, x, y, x, h);
 457       XDrawLine (display, win, botShadow, w, h, w, y + 1);
 458       XDrawLine (display, win, botShadow, w, h, x + 1, h);
 459     }
 460 }
 461 #endif
 462
 463 /* button shapes */
 464 #ifdef MENUBAR
 465 /* EXTPROTO */
 466 void
 467 rxvt_Draw_Triangle (Display *display, Window win, GC topShadow, GC botShadow, int x, int y, int w, int type)
 468 {
 469   switch (type)
 470     {
 471       case 'r':                 /* right triangle */
 472         XDrawLine (display, win, topShadow, x, y, x, y + w);
 473         XDrawLine (display, win, topShadow, x, y, x + w, y + w / 2);
 474         XDrawLine (display, win, botShadow, x, y + w, x + w, y + w / 2);
 475         break;
 476
 477       case 'l':                 /* left triangle */
 478         XDrawLine (display, win, botShadow, x + w, y + w, x + w, y);
 479         XDrawLine (display, win, botShadow, x + w, y + w, x, y + w / 2);
 480         XDrawLine (display, win, topShadow, x, y + w / 2, x + w, y);
 481         break;
 482
 483       case 'd':                 /* down triangle */
 484         XDrawLine (display, win, topShadow, x, y, x + w / 2, y + w);
 485         XDrawLine (display, win, topShadow, x, y, x + w, y);
 486         XDrawLine (display, win, botShadow, x + w, y, x + w / 2, y + w);
 487         break;
 488
 489       case 'u':                 /* up triangle */
 490         XDrawLine (display, win, botShadow, x + w, y + w, x + w / 2, y);
 491         XDrawLine (display, win, botShadow, x + w, y + w, x, y + w);
 492         XDrawLine (display, win, topShadow, x, y + w, x + w / 2, y);
 493         break;
 494 #if 0
 495       case 's':                 /* square */
 496         XDrawLine (display, win, topShadow, x + w, y, x, y);
 497         XDrawLine (display, win, topShadow, x, y, x, y + w);
 498         XDrawLine (display, win, botShadow, x, y + w, x + w, y + w);
 499         XDrawLine (display, win, botShadow, x + w, y + w, x + w, y);
 500         break;
 501 #endif
 502
 503     }
 504 }
 505 #endif
 506 /*----------------------- end-of-file (C source) -----------------------*/