1 /*

     2  * Copyright (c) 2007 Mans Rullgard

     3  *

     4  * This file is part of Libav.

     5  *

     6  * Libav is free software; you can redistribute it and/or

     7  * modify it under the terms of the GNU Lesser General Public

     8  * License as published by the Free Software Foundation; either

     9  * version 2.1 of the License, or (at your option) any later version.

    10  *

    11  * Libav is distributed in the hope that it will be useful,

    12  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    14  * Lesser General Public License for more details.

    15  *

    16  * You should have received a copy of the GNU Lesser General Public

    17  * License along with Libav; if not, write to the Free Software

    18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

    19  */

    20 

    21 #ifndef AVUTIL_AVSTRING_H

    22 #define AVUTIL_AVSTRING_H

    23 

    24 #include <stddef.h>

    25 #include "attributes.h"

    26 

    27 /**

    28  * @addtogroup lavu_string

    29  * @{

    30  */

    31 

    32 /**

    33  * Return non-zero if pfx is a prefix of str. If it is, *ptr is set to

    34  * the address of the first character in str after the prefix.

    35  *

    36  * @param str input string

    37  * @param pfx prefix to test

    38  * @param ptr updated if the prefix is matched inside str

    39  * @return non-zero if the prefix matches, zero otherwise

    40  */

    41 int av_strstart(const char *str, const char *pfx, const char **ptr);

    42 

    43 /**

    44  * Return non-zero if pfx is a prefix of str independent of case. If

    45  * it is, *ptr is set to the address of the first character in str

    46  * after the prefix.

    47  *

    48  * @param str input string

    49  * @param pfx prefix to test

    50  * @param ptr updated if the prefix is matched inside str

    51  * @return non-zero if the prefix matches, zero otherwise

    52  */

    53 int av_stristart(const char *str, const char *pfx, const char **ptr);

    54 

    55 /**

    56  * Locate the first case-independent occurrence in the string haystack

    57  * of the string needle.  A zero-length string needle is considered to

    58  * match at the start of haystack.

    59  *

    60  * This function is a case-insensitive version of the standard strstr().

    61  *

    62  * @param haystack string to search in

    63  * @param needle   string to search for

    64  * @return         pointer to the located match within haystack

    65  *                 or a null pointer if no match

    66  */

    67 char *av_stristr(const char *haystack, const char *needle);

    68 

    69 /**

    70  * Copy the string src to dst, but no more than size - 1 bytes, and

    71  * null-terminate dst.

    72  *

    73  * This function is the same as BSD strlcpy().

    74  *

    75  * @param dst destination buffer

    76  * @param src source string

    77  * @param size size of destination buffer

    78  * @return the length of src

    79  *

    80  * @warning since the return value is the length of src, src absolutely

    81  * _must_ be a properly 0-terminated string, otherwise this will read beyond

    82  * the end of the buffer and possibly crash.

    83  */

    84 size_t av_strlcpy(char *dst, const char *src, size_t size);

    85 

    86 /**

    87  * Append the string src to the string dst, but to a total length of

    88  * no more than size - 1 bytes, and null-terminate dst.

    89  *

    90  * This function is similar to BSD strlcat(), but differs when

    91  * size <= strlen(dst).

    92  *

    93  * @param dst destination buffer

    94  * @param src source string

    95  * @param size size of destination buffer

    96  * @return the total length of src and dst

    97  *

    98  * @warning since the return value use the length of src and dst, these

    99  * absolutely _must_ be a properly 0-terminated strings, otherwise this

   100  * will read beyond the end of the buffer and possibly crash.

   101  */

   102 size_t av_strlcat(char *dst, const char *src, size_t size);

   103 

   104 /**

   105  * Append output to a string, according to a format. Never write out of

   106  * the destination buffer, and always put a terminating 0 within

   107  * the buffer.

   108  * @param dst destination buffer (string to which the output is

   109  *  appended)

   110  * @param size total size of the destination buffer

   111  * @param fmt printf-compatible format string, specifying how the

   112  *  following parameters are used

   113  * @return the length of the string that would have been generated

   114  *  if enough space had been available

   115  */

   116 size_t av_strlcatf(char *dst, size_t size, const char *fmt, ...) av_printf_format(3, 4);

   117 

   118 /**

   119  * Convert a number to a av_malloced string.

   120  */

   121 char *av_d2str(double d);

   122 

   123 /**

   124  * Unescape the given string until a non escaped terminating char,

   125  * and return the token corresponding to the unescaped string.

   126  *

   127  * The normal \ and ' escaping is supported. Leading and trailing

   128  * whitespaces are removed, unless they are escaped with '\' or are

   129  * enclosed between ''.

   130  *

   131  * @param buf the buffer to parse, buf will be updated to point to the

   132  * terminating char

   133  * @param term a 0-terminated list of terminating chars

   134  * @return the malloced unescaped string, which must be av_freed by

   135  * the user, NULL in case of allocation failure

   136  */

   137 char *av_get_token(const char **buf, const char *term);

   138 

   139 /**

   140  * Locale-independent conversion of ASCII characters to uppercase.

   141  */

   142 static inline int av_toupper(int c)

   143 {

   144     if (c >= 'a' && c <= 'z')

   145         c ^= 0x20;

   146     return c;

   147 }

   148 

   149 /**

   150  * Locale-independent conversion of ASCII characters to lowercase.

   151  */

   152 static inline int av_tolower(int c)

   153 {

   154     if (c >= 'A' && c <= 'Z')

   155         c ^= 0x20;

   156     return c;

   157 }

   158 

   159 /*

   160  * Locale-independent case-insensitive compare.

   161  * @note This means only ASCII-range characters are case-insensitive

   162  */

   163 int av_strcasecmp(const char *a, const char *b);

   164 

   165 /**

   166  * Locale-independent case-insensitive compare.

   167  * @note This means only ASCII-range characters are case-insensitive

   168  */

   169 int av_strncasecmp(const char *a, const char *b, size_t n);

   170 

   171 /**

   172  * @}

   173  */

   174 

   175 #endif /* AVUTIL_AVSTRING_H */