string.c File Reference

String manipulation functions. More...

#include "config.h"
#include <ctype.h>
#include <errno.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include "exit.h"
#include "logging2.h"
#include "memory.h"
#include "string2.h"

Include dependency graph for string.c:

Go to the source code of this file.

Data Structures
struct	SysExits
	Lookup table of error messages. More...

Macros
#define	IS_INBOX(s)   (mutt_istrn_equal(s, "inbox", 5) && !isalnum((s)[5]))
#define	CMP_INBOX(a, b)   (IS_INBOX(b) - IS_INBOX(a))

Functions
static char *	strcasestr (const char *haystack, const char *needle)
	Find the first occurrence of needle in haystack, ignoring case.
static char *	strsep (char **stringp, const char *delim)
	Extract a token from a string.
const char *	mutt_str_sysexit (int err_num)
	Return a string matching an error code.
char *	mutt_str_sep (char **stringp, const char *delim)
	Find first occurrence of any of delim characters in *stringp.
static size_t	startswith (const char *str, const char *prefix, bool match_case)
	Check whether a string starts with a prefix.
size_t	mutt_str_startswith (const char *str, const char *prefix)
	Check whether a string starts with a prefix.
size_t	mutt_istr_startswith (const char *str, const char *prefix)
	Check whether a string starts with a prefix, ignoring case.
char *	mutt_str_dup (const char *str)
	Copy a string, safely.
char *	mutt_str_replace (char **p, const char *s)
	Replace one string with another.
void	mutt_str_adjust (char **ptr)
	Shrink-to-fit a string.
char *	mutt_str_lower (char *str)
	Convert all characters in the string to lowercase.
char *	mutt_str_upper (char *str)
	Convert all characters in the string to uppercase.
char *	mutt_strn_copy (char *dest, const char *src, size_t len, size_t dsize)
	Copy a sub-string into a buffer.
char *	mutt_strn_dup (const char *begin, size_t len)
	Duplicate a sub-string.
int	mutt_str_cmp (const char *a, const char *b)
	Compare two strings, safely.
int	mutt_istr_cmp (const char *a, const char *b)
	Compare two strings ignoring case, safely.
bool	mutt_strn_equal (const char *a, const char *b, size_t num)
	Check for equality of two strings (to a maximum), safely.
int	mutt_istrn_cmp (const char *a, const char *b, size_t num)
	Compare two strings ignoring case (to a maximum), safely.
bool	mutt_istrn_equal (const char *a, const char *b, size_t num)
	Check for equality of two strings ignoring case (to a maximum), safely.
const char *	mutt_istrn_rfind (const char *haystack, size_t haystack_length, const char *needle)
	Find last instance of a substring, ignoring case.
size_t	mutt_str_len (const char *a)
	Calculate the length of a string, safely.
int	mutt_str_coll (const char *a, const char *b)
	Collate two strings (compare using locale), safely.
const char *	mutt_istr_find (const char *haystack, const char *needle)
	Find first occurrence of string (ignoring case)
char *	mutt_str_skip_whitespace (const char *p)
	Find the first non-whitespace character in a string.
void	mutt_str_remove_trailing_ws (char *s)
	Trim trailing whitespace from a string.
size_t	mutt_str_copy (char *dest, const char *src, size_t dsize)
	Copy a string into a buffer (guaranteeing NUL-termination)
char *	mutt_str_skip_email_wsp (const char *s)
	Skip over whitespace as defined by RFC5322.
size_t	mutt_str_lws_len (const char *s, size_t n)
	Measure the linear-white-space at the beginning of a string.
bool	mutt_str_equal (const char *a, const char *b)
	Compare two strings.
bool	mutt_istr_equal (const char *a, const char *b)
	Compare two strings, ignoring case.
bool	mutt_str_is_ascii (const char *str, size_t len)
	Is a string ASCII (7-bit)?
const char *	mutt_str_find_word (const char *src)
	Find the end of a word (non-space)
const char *	mutt_str_getenv (const char *name)
	Get an environment variable.
int	mutt_istr_remall (char *str, const char *target)
	Remove all occurrences of substring, ignoring case.
int	mutt_str_asprintf (char **strp, const char *fmt,...)
void	mutt_str_hyphenate (char *buf, size_t buflen, const char *str)
	Hyphenate a snake-case string.
int	mutt_str_inbox_cmp (const char *a, const char *b)
	Do two folders share the same path and one is an inbox -.

Variables
static const struct SysExits	SysExits []
	Lookup table of error messages.

Detailed Description

String manipulation functions.

Authors

• Richard Russon
• Pietro Cerutti
• Austin Ray
• Claes Nästén

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file string.c.

Macro Definition Documentation

IS_INBOX

#define IS_INBOX

(

s

)

(mutt_istrn_equal(s, "inbox", 5) && !isalnum((s)[5]))

CMP_INBOX

#define CMP_INBOX	(		a,
			b
	)		(IS_INBOX(b) - IS_INBOX(a))

Function Documentation

strcasestr()

static char * strcasestr ( const char *  haystack, const char *  needle  )

static

Find the first occurrence of needle in haystack, ignoring case.

Parameters

haystack	String to search
needle	String to find

Return values

ptr	Matched string, or NULL on failure

Definition at line 56 of file string.c.

{
  size_t haystackn = strlen(haystack);
  size_t needlen = strlen(needle);
 
  const char *p = haystack;
  while (haystackn >= needlen)
  {
    if (strncasecmp(p, needle, needlen) == 0)
      return (char *) p;
    p++;
    haystackn--;
  }
  return NULL;
}

Here is the caller graph for this function:

strsep()

static char * strsep ( char **  stringp, const char *  delim  )

static

Extract a token from a string.

Parameters

stringp	String to be split up
delim	Characters to split stringp at

Return values

ptr	Next token, or NULL if the no more tokens

Note

The pointer stringp will be moved and NULs inserted into it

Definition at line 82 of file string.c.

{
  if (!*stringp)
    return NULL;
 
  char *start = *stringp;
  for (char *p = *stringp; *p != '\0'; p++)
  {
    for (const char *s = delim; *s != '\0'; s++)
    {
      if (*p == *s)
      {
        *p = '\0';
        *stringp = p + 1;
        return start;
      }
    }
  }
  *stringp = NULL;
  return start;
}

Here is the caller graph for this function:

mutt_str_sysexit()

const char * mutt_str_sysexit

(

int

err_num

)

Return a string matching an error code.

Parameters

err_num

Error code, e.g. EX_NOPERM

Return values

ptr	string representing the error code

Definition at line 169 of file string.c.

{
  for (size_t i = 0; i < mutt_array_size(SysExits); i++)
  {
    if (err_num == SysExits[i].err_num)
      return SysExits[i].err_str;
  }
 
  return NULL;
}

Here is the caller graph for this function:

mutt_str_sep()

char * mutt_str_sep	(	char **	stringp,
		const char *	delim
	)

Find first occurrence of any of delim characters in *stringp.

Parameters

stringp	Pointer to string to search for delim, updated with position of after delim if found else NULL
delim	String with characters to search for in *stringp

Return values

ptr	Input value of *stringp

Definition at line 186 of file string.c.

{
  if (!stringp || !*stringp || !delim)
    return NULL;
  return strsep(stringp, delim);
}

Here is the call graph for this function:

Here is the caller graph for this function:

startswith()

static size_t startswith ( const char *  str, const char *  prefix, bool  match_case  )

static

Check whether a string starts with a prefix.

Parameters

str	String to check
prefix	Prefix to match
match_case	True if case needs to match

Return values

num	Length of prefix if str starts with prefix
0	str does not start with prefix

Definition at line 201 of file string.c.

{
  if (!str || (str[0] == '\0') || !prefix || (prefix[0] == '\0'))
  {
    return 0;
  }
 
  const char *saved_prefix = prefix;
  for (; *str && *prefix; str++, prefix++)
  {
    if (*str == *prefix)
      continue;
 
    if (!match_case && tolower(*str) == tolower(*prefix))
      continue;
 
    return 0;
  }
 
  return (*prefix == '\0') ? (prefix - saved_prefix) : 0;
}

Here is the caller graph for this function:

mutt_str_startswith()

size_t mutt_str_startswith	(	const char *	str,
		const char *	prefix
	)

Check whether a string starts with a prefix.

Parameters

str	String to check
prefix	Prefix to match

Return values

num	Length of prefix if str starts with prefix
0	str does not start with prefix

Definition at line 230 of file string.c.

{
  return startswith(str, prefix, true);
}

Here is the call graph for this function:

mutt_istr_startswith()

size_t mutt_istr_startswith	(	const char *	str,
		const char *	prefix
	)

Check whether a string starts with a prefix, ignoring case.

Parameters

str	String to check
prefix	Prefix to match

Return values

num	Length of prefix if str starts with prefix
0	str does not start with prefix

Definition at line 242 of file string.c.

{
  return startswith(str, prefix, false);
}

Here is the call graph for this function:

mutt_str_dup()

char * mutt_str_dup

(

const char *

str

)

Copy a string, safely.

Parameters

str	String to copy

Return values

ptr	Copy of the string
NULL	str was NULL or empty

Definition at line 253 of file string.c.

{
  if (!str || (*str == '\0'))
    return NULL;
 
  char *p = strdup(str);
  if (!p)
  {
    mutt_error("%s", strerror(errno)); // LCOV_EXCL_LINE
    mutt_exit(1);                      // LCOV_EXCL_LINE
  }
  return p;
}

Here is the call graph for this function:

mutt_str_replace()

char * mutt_str_replace	(	char **	p,
		const char *	s
	)

Replace one string with another.

Parameters

[out]	p	String to replace
[in]	s	New string

Return values

ptr	Replaced string

This function free()s the original string, strdup()s the new string and overwrites the pointer to the first string.

This function alters the pointer of the caller.

Note

Free *p afterwards to handle the case that *p and s reference the same memory

Definition at line 280 of file string.c.

{
  if (!p)
    return NULL;
  const char *tmp = *p;
  *p = mutt_str_dup(s);
  FREE(&tmp);
  return *p;
}

Here is the call graph for this function:

mutt_str_adjust()

void mutt_str_adjust

(

char **

ptr

)

Shrink-to-fit a string.

Parameters

[out]

ptr

String to alter

Take a string which is allocated on the heap, find its length and reallocate the memory to be exactly the right size.

This function alters the pointer of the caller.

Definition at line 299 of file string.c.

{
  if (!ptr || !*ptr)
    return;
  MUTT_MEM_REALLOC(ptr, strlen(*ptr) + 1, char);
}

Here is the caller graph for this function:

mutt_str_lower()

char * mutt_str_lower

(

char *

str

)

Convert all characters in the string to lowercase.

Parameters

str	String to lowercase

Return values

ptr	Lowercase string

The string is transformed in place.

Definition at line 313 of file string.c.

{
  if (!str)
    return NULL;
 
  char *p = str;
 
  while (*p)
  {
    *p = tolower((unsigned char) *p);
    p++;
  }
 
  return str;
}

Here is the caller graph for this function:

mutt_str_upper()

char * mutt_str_upper

(

char *

str

)

Convert all characters in the string to uppercase.

Parameters

str	String to uppercase

Return values

ptr	Uppercase string

The string is transformed in place.

Definition at line 336 of file string.c.

{
  if (!str)
    return NULL;
 
  char *p = str;
 
  while (*p)
  {
    *p = toupper((unsigned char) *p);
    p++;
  }
 
  return str;
}

Here is the caller graph for this function:

mutt_strn_copy()

char * mutt_strn_copy	(	char *	dest,
		const char *	src,
		size_t	len,
		size_t	dsize
	)

Copy a sub-string into a buffer.

Parameters

dest	Buffer for the result
src	Start of the string to copy
len	Length of the string to copy
dsize	Destination buffer size

Return values

ptr	Destination buffer

Definition at line 360 of file string.c.

{
  if (!src || !dest || (len == 0) || (dsize == 0))
    return dest;
 
  if (len > (dsize - 1))
    len = dsize - 1;
  memcpy(dest, src, len);
  dest[len] = '\0';
  return dest;
}

Here is the caller graph for this function:

mutt_strn_dup()

char * mutt_strn_dup	(	const char *	begin,
		size_t	len
	)

Duplicate a sub-string.

Parameters

begin	Start of the string to copy
len	Length of string to copy

Return values

ptr	New string

The caller must free the returned string.

Definition at line 380 of file string.c.

{
  if (!begin)
    return NULL;
 
  char *p = MUTT_MEM_MALLOC(len + 1, char);
  memcpy(p, begin, len);
  p[len] = '\0';
  return p;
}

Here is the caller graph for this function:

mutt_str_cmp()

int mutt_str_cmp	(	const char *	a,
		const char *	b
	)

Compare two strings, safely.

Parameters

a	First string to compare
b	Second string to compare

Return values

-1	a precedes b
0	a and b are identical
1	b precedes a

Definition at line 399 of file string.c.

{
  return strcmp(NONULL(a), NONULL(b));
}

Here is the caller graph for this function:

mutt_istr_cmp()

int mutt_istr_cmp	(	const char *	a,
		const char *	b
	)

Compare two strings ignoring case, safely.

Parameters

a	First string to compare
b	Second string to compare

Return values

-1	a precedes b
0	a and b are identical
1	b precedes a

Definition at line 412 of file string.c.

{
  return strcasecmp(NONULL(a), NONULL(b));
}

Here is the caller graph for this function:

mutt_strn_equal()

bool mutt_strn_equal	(	const char *	a,
		const char *	b,
		size_t	num
	)

Check for equality of two strings (to a maximum), safely.

Parameters

a	First string to compare
b	Second string to compare
num	Maximum number of bytes to compare

Return values

true	First num chars of both strings are equal
false	First num chars of both strings not equal

Definition at line 425 of file string.c.

{
  return strncmp(NONULL(a), NONULL(b), num) == 0;
}

Here is the caller graph for this function:

mutt_istrn_cmp()

int mutt_istrn_cmp	(	const char *	a,
		const char *	b,
		size_t	num
	)

Compare two strings ignoring case (to a maximum), safely.

Parameters

a	First string to compare
b	Second string to compare
num	Maximum number of bytes to compare

Return values

-1	a precedes b
0	a and b are identical
1	b precedes a

Definition at line 439 of file string.c.

{
  return strncasecmp(NONULL(a), NONULL(b), num);
}

Here is the caller graph for this function:

mutt_istrn_equal()

bool mutt_istrn_equal	(	const char *	a,
		const char *	b,
		size_t	num
	)

Check for equality of two strings ignoring case (to a maximum), safely.

Parameters

a	First string to compare
b	Second string to compare
num	Maximum number of bytes to compare

Return values

-1	a precedes b
true	First num chars of both strings are equal, ignoring case
false	First num chars of both strings not equal, ignoring case

Definition at line 453 of file string.c.

{
  return strncasecmp(NONULL(a), NONULL(b), num) == 0;
}

Here is the caller graph for this function:

mutt_istrn_rfind()

const char * mutt_istrn_rfind	(	const char *	haystack,
		size_t	haystack_length,
		const char *	needle
	)

Find last instance of a substring, ignoring case.

Parameters

haystack	String to search through
haystack_length	Length of the string
needle	String to find

Return values

NULL	String not found
ptr	Location of string

Return the last instance of needle in the haystack, or NULL. Like strcasestr(), only backwards, and for a limited haystack length.

Definition at line 469 of file string.c.

{
  if (!haystack || (haystack_length == 0) || !needle)
    return NULL;
 
  int needle_length = strlen(needle);
  const char *haystack_end = haystack + haystack_length - needle_length;
 
  for (const char *p = haystack_end; p >= haystack; --p)
  {
    for (size_t i = 0; i < needle_length; i++)
    {
      if ((tolower((unsigned char) p[i]) != tolower((unsigned char) needle[i])))
        goto next;
    }
    return p;
 
  next:;
  }
  return NULL;
}

Here is the caller graph for this function:

mutt_str_len()

size_t mutt_str_len

(

const char *

a

)

Calculate the length of a string, safely.

Parameters

a	String to measure

Return values

num	Length in bytes

Definition at line 496 of file string.c.

{
  return a ? strlen(a) : 0;
}

mutt_str_coll()

int mutt_str_coll	(	const char *	a,
		const char *	b
	)

Collate two strings (compare using locale), safely.

Parameters

a	First string to compare
b	Second string to compare

Return values

<0	a precedes b
0	a and b are identical
>0	b precedes a

Definition at line 509 of file string.c.

{
  return strcoll(NONULL(a), NONULL(b));
}

Here is the caller graph for this function:

mutt_istr_find()

const char * mutt_istr_find	(	const char *	haystack,
		const char *	needle
	)

Find first occurrence of string (ignoring case)

Parameters

haystack	String to search through
needle	String to find

Return values

ptr	First match of the search string
NULL	No match, or an error

Definition at line 521 of file string.c.

{
  if (!haystack)
    return NULL;
  if (!needle)
    return haystack;
 
  const char *p = NULL, *q = NULL;
 
  while (*(p = haystack))
  {
    for (q = needle;
         *p && *q && (tolower((unsigned char) *p) == tolower((unsigned char) *q));
         p++, q++)
    {
    }
    if ((*q == '\0'))
      return haystack;
    haystack++;
  }
  return NULL;
}

Here is the caller graph for this function:

mutt_str_skip_whitespace()

char * mutt_str_skip_whitespace

(

const char *

p

)

Find the first non-whitespace character in a string.

Parameters

p	String to search

Return values

ptr	First non-whitespace character Terminating NUL character, if the string was entirely whitespace

Definition at line 551 of file string.c.

{
  if (!p)
    return NULL;
  SKIPWS(p);
  return (char *) p;
}

Here is the caller graph for this function:

mutt_str_remove_trailing_ws()

void mutt_str_remove_trailing_ws

(

char *

s

)

Trim trailing whitespace from a string.

Parameters

s	String to trim

The string is modified in place.

Definition at line 565 of file string.c.

{
  if (!s)
    return;
 
  for (char *p = s + mutt_str_len(s) - 1; (p >= s) && isspace(*p); p--)
    *p = '\0';
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_str_copy()

size_t mutt_str_copy	(	char *	dest,
		const char *	src,
		size_t	dsize
	)

Copy a string into a buffer (guaranteeing NUL-termination)

Parameters

dest	Buffer for the result
src	String to copy
dsize	Destination buffer size

Return values

num	Destination string length

Definition at line 581 of file string.c.

{
  if (!dest || (dsize == 0))
    return 0;
  if (!src)
  {
    dest[0] = '\0';
    return 0;
  }
 
  char *dest0 = dest;
  while ((--dsize > 0) && (*src != '\0'))
    *dest++ = *src++;
 
  *dest = '\0';
  return dest - dest0;
}

mutt_str_skip_email_wsp()

char * mutt_str_skip_email_wsp

(

const char *

s

)

Skip over whitespace as defined by RFC5322.

Parameters

s	String to search

Return values

ptr	First non-whitespace character Terminating NUL character, if the string was entirely whitespace

This is used primarily for parsing header fields.

Definition at line 608 of file string.c.

{
  if (!s)
    return NULL;
 
  for (; mutt_str_is_email_wsp(*s); s++)
    ; // Do nothing
 
  return (char *) s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_str_lws_len()

size_t mutt_str_lws_len	(	const char *	s,
		size_t	n
	)

Measure the linear-white-space at the beginning of a string.

Parameters

s	String to check
n	Maximum number of characters to check

Return values

num	Count of whitespace characters

Count the number of whitespace characters at the beginning of a string. They can be <space>, <tab>, <cr> or <lf>.

Definition at line 628 of file string.c.

{
  if (!s)
    return 0;
 
  const char *p = s;
  size_t len = n;
 
  if (n == 0)
    return 0;
 
  for (; p < (s + n); p++)
  {
    if (!strchr(" \t\r\n", *p))
    {
      len = p - s;
      break;
    }
  }
 
  if ((len != 0) && strchr("\r\n", *(p - 1))) /* LWS doesn't end with CRLF */
    len = 0;
  return len;
}

Here is the caller graph for this function:

mutt_str_equal()

bool mutt_str_equal	(	const char *	a,
		const char *	b
	)

Compare two strings.

Parameters

a	First string
b	Second string

Return values

true	The strings are equal
false	The strings are not equal

Definition at line 660 of file string.c.

{
  return (a == b) || (mutt_str_cmp(a, b) == 0);
}

Here is the call graph for this function:

mutt_istr_equal()

bool mutt_istr_equal	(	const char *	a,
		const char *	b
	)

Compare two strings, ignoring case.

Parameters

a	First string
b	Second string

Return values

true	The strings are equal
false	The strings are not equal

Definition at line 672 of file string.c.

{
  return (a == b) || (mutt_istr_cmp(a, b) == 0);
}

Here is the call graph for this function:

mutt_str_is_ascii()

bool mutt_str_is_ascii	(	const char *	str,
		size_t	len
	)

Is a string ASCII (7-bit)?

Parameters

str	String to examine
len	Length of string to examine

Return values

true	There are no 8-bit chars

Definition at line 683 of file string.c.

{
  if (!str)
    return true;
 
  for (; (*str != '\0') && (len > 0); str++, len--)
    if ((*str & 0x80) != 0)
      return false;
 
  return true;
}

Here is the caller graph for this function:

mutt_str_find_word()

const char * mutt_str_find_word

(

const char *

src

)

Find the end of a word (non-space)

Parameters

src	String to search

Return values

ptr	End of the word

Skip to the end of the current word. Skip past any whitespace characters.

Note

If there aren't any more words, this will return a pointer to the final NUL character.

Definition at line 706 of file string.c.

{
  if (!src)
    return NULL;
 
  while (*src && strchr(" \t\n", *src))
    src++;
  while (*src && !strchr(" \t\n", *src))
    src++;
  return src;
}

Here is the caller graph for this function:

mutt_str_getenv()

const char * mutt_str_getenv

(

const char *

name

)

Get an environment variable.

Parameters

name	Environment variable to get

Return values

ptr	Value of variable
NULL	Variable isn't set, or is empty

Warning

The caller must not free the returned pointer.

Definition at line 726 of file string.c.

{
  if (!name)
    return NULL;
 
  const char *val = getenv(name);
  if (val && (val[0] != '\0'))
    return val;
 
  return NULL;
}

Here is the caller graph for this function:

mutt_istr_remall()

int mutt_istr_remall	(	char *	str,
		const char *	target
	)

Remove all occurrences of substring, ignoring case.

Parameters

str	String containing the substring
target	Target substring for removal

Return values

0	String contained substring and substring was removed successfully
1	String did not contain substring

Definition at line 745 of file string.c.

{
  int rc = 1;
  if (!str || !target)
    return rc;
 
  // Look through an ensure all instances of the substring are gone.
  while ((str = (char *) strcasestr(str, target)))
  {
    size_t target_len = mutt_str_len(target);
    memmove(str, str + target_len, 1 + strlen(str + target_len));
    rc = 0; // If we got here, then a substring existed and has been removed.
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_str_asprintf()

int mutt_str_asprintf	(	char **	strp,
		const char *	fmt,
			...
	)

Definition at line 803 of file string.c.

{
  if (!strp || !fmt)
    return -1;
 
  int rlen = 256;
 
  *strp = MUTT_MEM_MALLOC(rlen, char);
  while (true)
  {
    va_list ap;
    va_start(ap, fmt);
    const int n = vsnprintf(*strp, rlen, fmt, ap);
    va_end(ap);
    if (n < 0)
    {
      FREE(strp);
      return n;
    }
 
    if (n < rlen)
    {
      /* reduce space to just that which was used.  note that 'n' does not
       * include the terminal nul char.  */
      if (n == 0) /* convention is to use NULL for zero-length strings. */
        FREE(strp);
      else if (n != rlen - 1)
        MUTT_MEM_REALLOC(strp, n + 1, char);
      return n;
    }
    /* increase size and try again */
    rlen = n + 1;
    MUTT_MEM_REALLOC(strp, rlen, char);
  }
  /* not reached */
}

Here is the caller graph for this function:

mutt_str_hyphenate()

void mutt_str_hyphenate	(	char *	buf,
		size_t	buflen,
		const char *	str
	)

Hyphenate a snake-case string.

Parameters

buf	Buffer for the result
buflen	Length of the buffer
str	String to convert

Replace underscores (_) with hyphens -`).

Definition at line 849 of file string.c.

{
  if (!buf || (buflen == 0) || !str)
    return;
 
  mutt_str_copy(buf, str, buflen);
  for (; *buf != '\0'; buf++)
  {
    if (*buf == '_')
      *buf = '-';
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

SysExits

const struct SysExits SysExits[]

static

Lookup table of error messages.

Definition at line 115 of file string.c.