git.sesse.net Git - ffmpeg/blob - libavutil/avstring.c

   1 /*
   2  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   3  * Copyright (c) 2007 Mans Rullgard
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * Libav 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 GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <stdarg.h>
  23 #include <stdint.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <ctype.h>
  27
  28 #include "config.h"
  29 #include "common.h"
  30 #include "mem.h"
  31 #include "avstring.h"
  32
  33 int av_strstart(const char *str, const char *pfx, const char **ptr)
  34 {
  35     while (*pfx && *pfx == *str) {
  36         pfx++;
  37         str++;
  38     }
  39     if (!*pfx && ptr)
  40         *ptr = str;
  41     return !*pfx;
  42 }
  43
  44 int av_stristart(const char *str, const char *pfx, const char **ptr)
  45 {
  46     while (*pfx && toupper((unsigned)*pfx) == toupper((unsigned)*str)) {
  47         pfx++;
  48         str++;
  49     }
  50     if (!*pfx && ptr)
  51         *ptr = str;
  52     return !*pfx;
  53 }
  54
  55 char *av_stristr(const char *s1, const char *s2)
  56 {
  57     if (!*s2)
  58         return s1;
  59
  60     do
  61         if (av_stristart(s1, s2, NULL))
  62             return s1;
  63     while (*s1++);
  64
  65     return NULL;
  66 }
  67
  68 char *av_strnstr(const char *haystack, const char *needle, size_t hay_length)
  69 {
  70     size_t needle_len = strlen(needle);
  71     if (!needle_len)
  72         return haystack;
  73     while (hay_length >= needle_len) {
  74         hay_length--;
  75         if (!memcmp(haystack, needle, needle_len))
  76             return haystack;
  77         haystack++;
  78     }
  79     return NULL;
  80 }
  81
  82 size_t av_strlcpy(char *dst, const char *src, size_t size)
  83 {
  84     size_t len = 0;
  85     while (++len < size && *src)
  86         *dst++ = *src++;
  87     if (len <= size)
  88         *dst = 0;
  89     return len + strlen(src) - 1;
  90 }
  91
  92 size_t av_strlcat(char *dst, const char *src, size_t size)
  93 {
  94     size_t len = strlen(dst);
  95     if (size <= len + 1)
  96         return len + strlen(src);
  97     return len + av_strlcpy(dst + len, src, size - len);
  98 }
  99
 100 size_t av_strlcatf(char *dst, size_t size, const char *fmt, ...)
 101 {
 102     int len = strlen(dst);
 103     va_list vl;
 104
 105     va_start(vl, fmt);
 106     len += vsnprintf(dst + len, size > len ? size - len : 0, fmt, vl);
 107     va_end(vl);
 108
 109     return len;
 110 }
 111
 112 char *av_d2str(double d)
 113 {
 114     char *str = av_malloc(16);
 115     if (str)
 116         snprintf(str, 16, "%f", d);
 117     return str;
 118 }
 119
 120 #define WHITESPACES " \n\t"
 121
 122 char *av_get_token(const char **buf, const char *term)
 123 {
 124     char *out     = av_malloc(strlen(*buf) + 1);
 125     char *ret     = out, *end = out;
 126     const char *p = *buf;
 127     if (!out)
 128         return NULL;
 129     p += strspn(p, WHITESPACES);
 130
 131     while (*p && !strspn(p, term)) {
 132         char c = *p++;
 133         if (c == '\\' && *p) {
 134             *out++ = *p++;
 135             end    = out;
 136         } else if (c == '\'') {
 137             while (*p && *p != '\'')
 138                 *out++ = *p++;
 139             if (*p) {
 140                 p++;
 141                 end = out;
 142             }
 143         } else {
 144             *out++ = c;
 145         }
 146     }
 147
 148     do
 149         *out-- = 0;
 150     while (out >= end && strspn(out, WHITESPACES));
 151
 152     *buf = p;
 153
 154     return ret;
 155 }
 156
 157 int av_strcasecmp(const char *a, const char *b)
 158 {
 159     uint8_t c1, c2;
 160     do {
 161         c1 = av_tolower(*a++);
 162         c2 = av_tolower(*b++);
 163     } while (c1 && c1 == c2);
 164     return c1 - c2;
 165 }
 166
 167 int av_strncasecmp(const char *a, const char *b, size_t n)
 168 {
 169     const char *end = a + n;
 170     uint8_t c1, c2;
 171     do {
 172         c1 = av_tolower(*a++);
 173         c2 = av_tolower(*b++);
 174     } while (a < end && c1 && c1 == c2);
 175     return c1 - c2;
 176 }
 177
 178 const char *av_basename(const char *path)
 179 {
 180     char *p = strrchr(path, '/');
 181
 182 #if HAVE_DOS_PATHS
 183     char *q = strrchr(path, '\\');
 184     char *d = strchr(path, ':');
 185
 186     p = FFMAX3(p, q, d);
 187 #endif
 188
 189     if (!p)
 190         return path;
 191
 192     return p + 1;
 193 }
 194
 195 const char *av_dirname(char *path)
 196 {
 197     char *p = strrchr(path, '/');
 198
 199 #if HAVE_DOS_PATHS
 200     char *q = strrchr(path, '\\');
 201     char *d = strchr(path, ':');
 202
 203     d = d ? d + 1 : d;
 204
 205     p = FFMAX3(p, q, d);
 206 #endif
 207
 208     if (!p)
 209         return ".";
 210
 211     *p = '\0';
 212
 213     return path;
 214 }
 215
 216 int av_isdigit(int c)
 217 {
 218     return c >= '0' && c <= '9';
 219 }
 220
 221 int av_isgraph(int c)
 222 {
 223     return c > 32 && c < 127;
 224 }
 225
 226 int av_isspace(int c)
 227 {
 228     return c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' ||
 229            c == '\v';
 230 }
 231
 232 int av_isxdigit(int c)
 233 {
 234     c = av_tolower(c);
 235     return av_isdigit(c) || (c >= 'a' && c <= 'z');
 236 }
 237
 238 #ifdef TEST
 239
 240 int main(void)
 241 {
 242     int i;
 243     const char *strings[] = {
 244         "''",
 245         "",
 246         ":",
 247         "\\",
 248         "'",
 249         "    ''    :",
 250         "    ''  ''  :",
 251         "foo   '' :",
 252         "'foo'",
 253         "foo     ",
 254         "  '  foo  '  ",
 255         "foo\\",
 256         "foo':  blah:blah",
 257         "foo\\:  blah:blah",
 258         "foo\'",
 259         "'foo :  '  :blahblah",
 260         "\\ :blah",
 261         "     foo",
 262         "      foo       ",
 263         "      foo     \\ ",
 264         "foo ':blah",
 265         " foo   bar    :   blahblah",
 266         "\\f\\o\\o",
 267         "'foo : \\ \\  '   : blahblah",
 268         "'\\fo\\o:': blahblah",
 269         "\\'fo\\o\\:':  foo  '  :blahblah"
 270     };
 271
 272     printf("Testing av_get_token()\n");
 273     for (i = 0; i < FF_ARRAY_ELEMS(strings); i++) {
 274         const char *p = strings[i], *q;
 275         printf("|%s|", p);
 276         q = av_get_token(&p, ":");
 277         printf(" -> |%s|", q);
 278         printf(" + |%s|\n", p);
 279         av_free(q);
 280     }
 281
 282     return 0;
 283 }
 284
 285 #endif /* TEST */