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 /* INTPROTO */
  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 /* INTPROTO */
  53 char *
  54 rxvt_strdup (const char *str)
  55 {
  56   return str ? strdup (str) : 0;
  57 }
  58
  59 /* INTPROTO */
  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 /* INTPROTO */
  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 /* INTPROTO */
  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 /* INTPROTO */
 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 /* INTPROTO */
 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 /* INTPROTO */
 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 /* INTPROTO */
 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 /* INTPROTO */
 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 /* INTPROTO */
 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 /* INTPROTO */
 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 /* INTPROTO */
 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 void
 326 rxvt_freecommastring (char **cs)
 327 {
 328   for (int i = 0; cs[i]; ++i)
 329     free (cs[i]);
 330
 331   free (cs);
 332 }
 333
 334 /*----------------------------------------------------------------------*
 335  * file searching
 336  */
 337
 338 /* #define DEBUG_SEARCH_PATH */
 339
 340 #if defined (XPM_BACKGROUND) || (MENUBAR_MAX)
 341 /*
 342  * search for FILE in the current working directory, and within the
 343  * colon-delimited PATHLIST, adding the file extension EXT if required.
 344  *
 345  * FILE is either semi-colon or zero terminated
 346  */
 347 /* INTPROTO */
 348 char           *
 349 rxvt_File_search_path (const char *pathlist, const char *file, const char *ext)
 350 {
 351   int             maxpath, len;
 352   const char     *p, *path;
 353   char            name[256];
 354
 355   if (!access (file, R_OK))     /* found (plain name) in current directory */
 356     return strdup (file);
 357
 358   /* semi-colon delimited */
 359   if ((p = strchr (file, ';')))
 360     len = (p - file);
 361   else
 362     len = strlen (file);
 363
 364 #ifdef DEBUG_SEARCH_PATH
 365   getcwd (name, sizeof (name));
 366   fprintf (stderr, "pwd: \"%s\"\n", name);
 367   fprintf (stderr, "find: \"%.*s\"\n", len, file);
 368 #endif
 369
 370   /* leave room for an extra '/' and trailing '\0' */
 371   maxpath = sizeof (name) - (len + (ext ? strlen (ext) : 0) + 2);
 372   if (maxpath <= 0)
 373     return NULL;
 374
 375   /* check if we can find it now */
 376   strncpy (name, file, len);
 377   name[len] = '\0';
 378
 379   if (!access (name, R_OK))
 380     return strdup (name);
 381   if (ext)
 382     {
 383       strcat (name, ext);
 384       if (!access (name, R_OK))
 385         return strdup (name);
 386     }
 387   for (path = pathlist; path != NULL && *path != '\0'; path = p)
 388     {
 389       int             n;
 390
 391       /* colon delimited */
 392       if ((p = strchr (path, ':')) == NULL)
 393         p = strchr (path, '\0');
 394
 395       n = (p - path);
 396       if (*p != '\0')
 397         p++;
 398
 399       if (n > 0 && n <= maxpath)
 400         {
 401           strncpy (name, path, n);
 402           if (name[n - 1] != '/')
 403             name[n++] = '/';
 404           name[n] = '\0';
 405           strncat (name, file, len);
 406
 407           if (!access (name, R_OK))
 408             return strdup (name);
 409           if (ext)
 410             {
 411               strcat (name, ext);
 412               if (!access (name, R_OK))
 413                 return strdup (name);
 414             }
 415         }
 416     }
 417   return NULL;
 418 }
 419
 420 /* INTPROTO */
 421 char           *
 422 rxvt_File_find (const char *file, const char *ext, const char *path)
 423 {
 424   char           *f;
 425
 426   if (file == NULL || *file == '\0')
 427     return NULL;
 428
 429   /* search environment variables here too */
 430   if ((f = rxvt_File_search_path (path, file, ext)) == NULL)
 431 #ifdef PATH_ENV
 432     if ((f = rxvt_File_search_path (getenv (PATH_ENV), file, ext)) == NULL)
 433 #endif
 434       f = rxvt_File_search_path (getenv ("PATH"), file, ext);
 435
 436 #ifdef DEBUG_SEARCH_PATH
 437   if (f)
 438     fprintf (stderr, "found: \"%s\"\n", f);
 439 #endif
 440
 441   return f;
 442 }
 443 #endif                          /* defined (XPM_BACKGROUND) || (MENUBAR_MAX) */
 444
 445 /*----------------------------------------------------------------------*
 446  * miscellaneous drawing routines
 447  */
 448
 449 /*
 450  * Draw top/left and bottom/right border shadows around windows
 451  */
 452 #if defined(RXVT_SCROLLBAR) || defined(MENUBAR)
 453 /* INTPROTO */
 454 void
 455 rxvt_Draw_Shadow (Display *display, Window win, GC topShadow, GC botShadow, int x, int y, int w, int h)
 456 {
 457   int             shadow;
 458
 459   shadow = (w == 0 || h == 0) ? 1 : SHADOW;
 460   w += x - 1;
 461   h += y - 1;
 462   for (; shadow-- > 0; x++, y++, w--, h--)
 463     {
 464       XDrawLine (display, win, topShadow, x, y, w, y);
 465       XDrawLine (display, win, topShadow, x, y, x, h);
 466       XDrawLine (display, win, botShadow, w, h, w, y + 1);
 467       XDrawLine (display, win, botShadow, w, h, x + 1, h);
 468     }
 469 }
 470 #endif
 471
 472 /* button shapes */
 473 #ifdef MENUBAR
 474 /* INTPROTO */
 475 void
 476 rxvt_Draw_Triangle (Display *display, Window win, GC topShadow, GC botShadow, int x, int y, int w, int type)
 477 {
 478   switch (type)
 479     {
 480       case 'r':                 /* right triangle */
 481         XDrawLine (display, win, topShadow, x, y, x, y + w);
 482         XDrawLine (display, win, topShadow, x, y, x + w, y + w / 2);
 483         XDrawLine (display, win, botShadow, x, y + w, x + w, y + w / 2);
 484         break;
 485
 486       case 'l':                 /* left triangle */
 487         XDrawLine (display, win, botShadow, x + w, y + w, x + w, y);
 488         XDrawLine (display, win, botShadow, x + w, y + w, x, y + w / 2);
 489         XDrawLine (display, win, topShadow, x, y + w / 2, x + w, y);
 490         break;
 491
 492       case 'd':                 /* down triangle */
 493         XDrawLine (display, win, topShadow, x, y, x + w / 2, y + w);
 494         XDrawLine (display, win, topShadow, x, y, x + w, y);
 495         XDrawLine (display, win, botShadow, x + w, y, x + w / 2, y + w);
 496         break;
 497
 498       case 'u':                 /* up triangle */
 499         XDrawLine (display, win, botShadow, x + w, y + w, x + w / 2, y);
 500         XDrawLine (display, win, botShadow, x + w, y + w, x, y + w);
 501         XDrawLine (display, win, topShadow, x, y + w, x + w / 2, y);
 502         break;
 503 #if 0
 504       case 's':                 /* square */
 505         XDrawLine (display, win, topShadow, x + w, y, x, y);
 506         XDrawLine (display, win, topShadow, x, y, x, y + w);
 507         XDrawLine (display, win, botShadow, x, y + w, x + w, y + w);
 508         XDrawLine (display, win, botShadow, x + w, y + w, x + w, y);
 509         break;
 510 #endif
 511
 512     }
 513 }
 514 #endif
 515 /*----------------------- end-of-file (C source) -----------------------*/