string2.h File Reference

String manipulation functions. More...

#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>

Include dependency graph for string2.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	STR_COMMAND   8192
	Enough space for a long command line.
#define	NONULL(x)   ((x) ? (x) : "")
#define	S_ERR   127
#define	S_BKG   126
#define	SKIPWS(ch)
#define	terminate_string(str, strlen, buflen)    (str)[MIN((strlen), (buflen))] = '\0'
#define	terminate_buffer(str, strlen)    terminate_string(str, strlen, sizeof(str) - 1)

Functions
void	mutt_str_adjust (char **ptr)
	Shrink-to-fit a string.
int	mutt_str_asprintf (char **strp, const char *fmt,...) __attribute__((__format__(__printf__
int int	mutt_str_coll (const char *a, const char *b)
	Collate two strings (compare using locale), safely.
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.
void	mutt_str_hyphenate (char *buf, size_t buflen, const char *str)
	Hyphenate a snake-case string.
bool	mutt_str_is_ascii (const char *str, size_t len)
	Is a string ASCII (7-bit)?
size_t	mutt_str_len (const char *a)
	Calculate the length of a string, safely.
char *	mutt_str_lower (char *str)
	Convert all characters in the string to lowercase.
size_t	mutt_str_lws_len (const char *s, size_t n)
	Measure the linear-white-space at the beginning of a string.
void	mutt_str_remove_trailing_ws (char *s)
	Trim trailing whitespace from a string.
char *	mutt_str_replace (char **p, const char *s)
	Replace one string with another.
char *	mutt_str_sep (char **stringp, const char *delim)
	Find first occurrence of any of delim characters in *stringp.
char *	mutt_str_skip_email_wsp (const char *s)
	Skip over whitespace as defined by RFC5322.
char *	mutt_str_skip_whitespace (const char *p)
	Find the first non-whitespace character in a string.
const char *	mutt_str_sysexit (int e)
	Return a string matching an error code.
char *	mutt_str_upper (char *str)
	Convert all characters in the string to uppercase.
int	mutt_str_cmp (const char *a, const char *b)
	Compare two strings, safely.
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_dup (const char *str)
	Copy a string, safely.
bool	mutt_str_equal (const char *a, const char *b)
	Compare two strings.
size_t	mutt_str_startswith (const char *str, const char *prefix)
	Check whether a string starts with a prefix.
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 l)
	Duplicate a sub-string.
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_istr_cmp (const char *a, const char *b)
	Compare two strings ignoring case, safely.
bool	mutt_istr_equal (const char *a, const char *b)
	Compare two strings, ignoring case.
const char *	mutt_istr_find (const char *haystack, const char *needle)
	Find first occurrence of string (ignoring case)
int	mutt_istr_remall (char *str, const char *target)
	Remove all occurrences of substring, ignoring case.
size_t	mutt_istr_startswith (const char *str, const char *prefix)
	Check whether a string starts with a prefix, ignoring case.
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.
static bool	mutt_str_is_email_wsp (char c)
	Is this a whitespace character (for an email header)

Detailed Description

String manipulation functions.

Authors

• Richard Russon
• Pietro Cerutti

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 string2.h.

Macro Definition Documentation

STR_COMMAND

#define STR_COMMAND   8192

Enough space for a long command line.

Definition at line 35 of file string2.h.

NONULL

#define NONULL

(

x

)

((x) ? (x) : "")

Definition at line 37 of file string2.h.

S_ERR

#define S_ERR   127

Definition at line 40 of file string2.h.

S_BKG

#define S_BKG   126

Definition at line 41 of file string2.h.

SKIPWS

#define SKIPWS

(

ch

)

Value:

  while (*(ch) && isspace((unsigned char) *(ch)))                              \
    ch++;

Definition at line 45 of file string2.h.

terminate_string

#define terminate_string	(		str,
			strlen,
			buflen
	)		(str)[MIN((strlen), (buflen))] = '\0'

Definition at line 49 of file string2.h.

terminate_buffer

#define terminate_buffer	(		str,
			strlen
	)		terminate_string(str, strlen, sizeof(str) - 1)

Definition at line 52 of file string2.h.

Function Documentation

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);
}

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,
			...
	)

mutt_str_coll()

int 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_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_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:

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_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_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_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_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_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_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:

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_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_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_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_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_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_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_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_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_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);
  memcpy(p, begin, len);
  p[len] = '\0';
  return p;
}

Here is the call graph for this function:

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_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_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_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_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_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_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_is_email_wsp()

static bool mutt_str_is_email_wsp ( char  c )

inlinestatic

Is this a whitespace character (for an email header)

Parameters

c	Character to test

Return values

true	It is whitespace

Definition at line 103 of file string2.h.

{
  return (c == ' ') || (c == '\t') || (c == '\r') || (c == '\n');
}

Here is the caller graph for this function: