common/util.c

   1 /*
   2  * util.c - useful functions
   3  *
   4  * Copyright © 2007-2008 Julien Danjou <julien@danjou.info>
   5  * Copyright © 2006 Pierre Habouzit <madcoder@debian.org>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  */
  22
  23 #include <stdarg.h>
  24 #include <sys/wait.h>
  25 #include <unistd.h>
  26 #include <limits.h>
  27 #include <fcntl.h>
  28
  29 #include "common/util.h"
  30 #include "common/tokenize.h"
  31
  32 /** Print error and exit with EXIT_FAILURE code.
  33  */
  34 void
  35 _fatal(int line, const char *fct, const char *fmt, ...)
  36 {
  37     va_list ap;
  38
  39     va_start(ap, fmt);
  40     fprintf(stderr, "E: awesome: %s:%d: ", fct, line);
  41     vfprintf(stderr, fmt, ap);
  42     va_end(ap);
  43     fprintf(stderr, "\n");
  44     exit(EXIT_FAILURE);
  45 }
  46
  47 /** Print error message on stderr.
  48  */
  49 void
  50 _warn(int line, const char *fct, const char *fmt, ...)
  51 {
  52     va_list ap;
  53     va_start(ap, fmt);
  54     fprintf(stderr, "W: awesome: %s:%d: ", fct, line);
  55     vfprintf(stderr, fmt, ap);
  56     va_end(ap);
  57     fprintf(stderr, "\n");
  58 }
  59
  60 /** Get a position type from a string.
  61  * \param pos The position.
  62  * \param len The string length, -1 if unknown.
  63  * \return A position.
  64  */
  65 position_t
  66 position_fromstr(const char *pos, ssize_t len)
  67 {
  68     switch(a_tokenize(pos, len))
  69     {
  70       default:
  71         return Top;
  72       case A_TK_BOTTOM:
  73         return Bottom;
  74       case A_TK_RIGHT:
  75         return Right;
  76       case A_TK_LEFT:
  77         return Left;
  78     }
  79 }
  80
  81 /** Convert a position type to a string.
  82  * \param p The position.
  83  * \return A position string.
  84  */
  85 const char *
  86 position_tostr(position_t p)
  87 {
  88     switch(p)
  89     {
  90       case Top:      return "top";
  91       case Bottom:   return "bottom";
  92       case Right:    return "right";
  93       case Left:     return "left";
  94       default:       return NULL;
  95     }
  96 }
  97
  98 /** Get a orientation type from a string.
  99  * \param pos The orientation.
 100  * \param len The string length, -1 if unknown.
 101  * \return A orientation.
 102  */
 103 orientation_t
 104 orientation_fromstr(const char *pos, ssize_t len)
 105 {
 106     switch(a_tokenize(pos, len))
 107     {
 108       default:
 109         return North;
 110       case A_TK_SOUTH:
 111         return South;
 112       case A_TK_EAST:
 113         return East;
 114     }
 115 }
 116
 117 /** Convert a orientation type to a string.
 118  * \param p The orientation.
 119  * \return A orientation string.
 120  */
 121 const char *
 122 orientation_tostr(orientation_t p)
 123 {
 124     switch(p)
 125     {
 126       case North: return "north";
 127       case South: return "south";
 128       case East:  return "east";
 129       default:    return NULL;
 130     }
 131 }
 132
 133 /** \brief safe limited strcpy.
 134  *
 135  * Copies at most min(<tt>n-1</tt>, \c l) characters from \c src into \c dst,
 136  * always adding a final \c \\0 in \c dst.
 137  *
 138  * \param[in]  dst      destination buffer.
 139  * \param[in]  n        size of the buffer. Negative sizes are allowed.
 140  * \param[in]  src      source string.
 141  * \param[in]  l        maximum number of chars to copy.
 142  *
 143  * \return minimum of  \c src \e length and \c l.
 144 */
 145 ssize_t
 146 a_strncpy(char *dst, ssize_t n, const char *src, ssize_t l)
 147 {
 148     ssize_t len = MIN(a_strlen(src), l);
 149
 150     if (n > 0)
 151     {
 152         ssize_t dlen = MIN(n - 1, len);
 153         memcpy(dst, src, dlen);
 154         dst[dlen] = '\0';
 155     }
 156
 157     return len;
 158 }
 159
 160 /** \brief safe strcpy.
 161  *
 162  * Copies at most <tt>n-1</tt> characters from \c src into \c dst, always
 163  * adding a final \c \\0 in \c dst.
 164  *
 165  * \param[in]  dst      destination buffer.
 166  * \param[in]  n        size of the buffer. Negative sizes are allowed.
 167  * \param[in]  src      source string.
 168  * \return \c src \e length. If this value is \>= \c n then the copy was
 169  *         truncated.
 170  */
 171 ssize_t
 172 a_strcpy(char *dst, ssize_t n, const char *src)
 173 {
 174     ssize_t len = a_strlen(src);
 175
 176     if (n > 0)
 177     {
 178         ssize_t dlen = MIN(n - 1, len);
 179         memcpy(dst, src, dlen);
 180         dst[dlen] = '\0';
 181     }
 182
 183     return len;
 184 }
 185
 186 /** Execute a command and replace the current process.
 187  * \param cmd The command to execute.
 188  */
 189 void
 190 a_exec(const char *cmd)
 191 {
 192     static const char *shell = NULL;
 193
 194     if(!shell && !(shell = getenv("SHELL")))
 195         shell = "/bin/sh";
 196
 197     execl(shell, shell, "-c", cmd, NULL);
 198 }
 199
 200 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80