StaticStrings

Functions
TRIO_STRING_PUBLIC char *trio_create	TRIO_ARGS1 ((size), size_t size)
TRIO_STRING_PUBLIC void trio_destroy	TRIO_ARGS1 ((string), char *string)
TRIO_STRING_PUBLIC size_t trio_length	TRIO_ARGS1 ((string), TRIO_CONST char *string)
TRIO_STRING_PUBLIC int trio_append	TRIO_ARGS2 ((target, source), char *target, TRIO_CONST char *source)
TRIO_STRING_PUBLIC int trio_append_max	TRIO_ARGS3 ((target, max, source), char *target, size_t max, TRIO_CONST char *source)
TRIO_STRING_PUBLIC int trio_contains	TRIO_ARGS2 ((string, substring), TRIO_CONST char *string, TRIO_CONST char *substring)
TRIO_STRING_PRIVATE char *TrioDuplicateMax	TRIO_ARGS2 ((source, size), TRIO_CONST char *source, size_t size)
TRIO_STRING_PUBLIC char *trio_duplicate	TRIO_ARGS1 ((source), TRIO_CONST char *source)
TRIO_STRING_PUBLIC char *trio_duplicate_max	TRIO_ARGS2 ((source, max), TRIO_CONST char *source, size_t max)
TRIO_STRING_PUBLIC int trio_equal	TRIO_ARGS2 ((first, second), TRIO_CONST char *first, TRIO_CONST char *second)
TRIO_STRING_PUBLIC int trio_equal_case_max	TRIO_ARGS3 ((first, max, second), TRIO_CONST char *first, size_t max, TRIO_CONST char *second)
TRIO_STRING_PUBLIC TRIO_CONST char *trio_error	TRIO_ARGS1 ((error_number), int error_number)
TRIO_STRING_PUBLIC size_t trio_format_date_max	TRIO_ARGS4 ((target, max, format, datetime), char *target, size_t max, TRIO_CONST char *format, TRIO_CONST struct tm *datetime)
TRIO_STRING_PUBLIC unsigned long trio_hash	TRIO_ARGS2 ((string, type), TRIO_CONST char *string, int type)
TRIO_STRING_PUBLIC char *trio_index	TRIO_ARGS2 ((string, character), TRIO_CONST char *string, int character)
TRIO_STRING_PUBLIC int trio_lower	TRIO_ARGS1 ((target), char *target)
TRIO_STRING_PUBLIC int trio_match	TRIO_ARGS2 ((string, pattern), TRIO_CONST char *string, TRIO_CONST char *pattern)
TRIO_STRING_PUBLIC size_t trio_span_function	TRIO_ARGS3 ((target, source, Function), char *target, TRIO_CONST char *source, int(*Function) TRIO_PROTO((int)))
TRIO_STRING_PUBLIC char *trio_substring_max	TRIO_ARGS3 ((string, max, substring), TRIO_CONST char *string, size_t max, TRIO_CONST char *substring)
TRIO_STRING_PUBLIC char *trio_tokenize	TRIO_ARGS2 ((string, delimiters), char *string, TRIO_CONST char *delimiters)
TRIO_STRING_PUBLIC trio_long_double_t trio_to_long_double	TRIO_ARGS2 ((source, endp), TRIO_CONST char *source, char **endp)
TRIO_STRING_PUBLIC long trio_to_long	TRIO_ARGS3 ((string, endp, base), TRIO_CONST char *string, char **endp, int base)
TRIO_STRING_PUBLIC int trio_to_lower	TRIO_ARGS1 ((source), int source)

Detailed Description

Function Documentation

TRIO_ARGS1() [1/7]

TRIO_STRING_PUBLIC TRIO_CONST char *trio_error TRIO_ARGS1	(	(error_number)	,
		int	error_number
	)

Provide a textual description of an error code (errno).

Parameters

error_number

Error number.

Returns

Textual description of error_number.

Definition at line 563 of file triostr.c.

{
#if defined(USE_STRERROR)
 
  return strerror(error_number);
 
#elif defined(USE_SYS_ERRLIST)
 
  extern char *sys_errlist[];
  extern int sys_nerr;
 
  return ((error_number < 0) || (error_number >= sys_nerr))
    ? "unknown"
    : sys_errlist[error_number];
 
#else
 
  return "unknown";
 
#endif
}

TRIO_ARGS1() [2/7]

TRIO_STRING_PUBLIC char *trio_create TRIO_ARGS1	(	(size)	,
		size_t	size
	)

Create new string.

Parameters

size	Size of new string.

Returns

Pointer to string, or NULL if allocation failed.

Definition at line 132 of file triostr.c.

{
  return (char *)TRIO_MALLOC(size);
}

TRIO_ARGS1() [3/7]

TRIO_STRING_PUBLIC int trio_to_upper TRIO_ARGS1	(	(source)	,
		int	source
	)

Convert one alphabetic letter to lower-case.

Parameters

source

The letter to be converted.

Returns

The converted letter.

Convert one alphabetic letter to upper-case.

Parameters

source

The letter to be converted.

Returns

The converted letter.

Definition at line 1169 of file triostr.c.

{
#if defined(USE_TOLOWER)
 
  return tolower(source);
 
#else
 
  /* Does not handle locales or non-contiguous alphabetic characters */
  return ((source >= (int)'A') && (source <= (int)'Z'))
    ? source - 'A' + 'a'
    : source;
 
#endif
}

TRIO_ARGS1() [4/7]

TRIO_STRING_PUBLIC char *trio_duplicate TRIO_ARGS1	(	(source)	,
		TRIO_CONST char *	source
	)

Duplicate source.

Parameters

source

Source string.

Returns

A copy of the source string.

Postcondition

target will be zero terminated.

Definition at line 353 of file triostr.c.

{
  return TrioDuplicateMax(source, trio_length(source));
}

TRIO_ARGS1() [5/7]

TRIO_STRING_PUBLIC void trio_destroy TRIO_ARGS1	(	(string)	,
		char *	string
	)

Destroy string.

Parameters

string

String to be freed.

Definition at line 146 of file triostr.c.

{
  if (string)
    {
      TRIO_FREE(string);
    }
}

TRIO_ARGS1() [6/7]

TRIO_STRING_PUBLIC size_t trio_length TRIO_ARGS1	(	(string)	,
		TRIO_CONST char *	string
	)

Count the number of characters in a string.

Parameters

string

String to measure.

Returns

Number of characters in @string.

Definition at line 164 of file triostr.c.

{
  return strlen(string);
}

TRIO_ARGS1() [7/7]

TRIO_STRING_PUBLIC int trio_upper TRIO_ARGS1	(	(target)	,
		char *	target
	)

Convert the alphabetic letters in the string to lower-case.

Parameters

target

String to be converted.

Returns

Number of processed characters (converted or not).

Convert the alphabetic letters in the string to upper-case.

Parameters

target

The string to be converted.

Returns

The number of processed characters (converted or not).

Definition at line 709 of file triostr.c.

{
  assert(target);
 
  return trio_span_function(target, target, trio_to_lower);
}

TRIO_ARGS2() [1/10]

TRIO_STRING_PUBLIC int trio_equal_locale TRIO_ARGS2	(	(first, second)	,
		TRIO_CONST char *	first,
		TRIO_CONST char *	second
	)

Compare if two strings are equal.

Parameters

first	First string.
second	Second string.

Returns

Boolean indicating whether the two strings are equal or not.

Case-insensitive comparison.

Compare if two strings are equal.

Parameters

first	First string.
second	Second string.

Returns

Boolean indicating whether the two strings are equal or not.

Case-sensitive comparison.

Compare if two strings are equal.

Parameters

first	First string.
second	Second string.

Returns

Boolean indicating whether the two strings are equal or not.

Collating characters are considered equal.

Definition at line 401 of file triostr.c.

{
  assert(first);
  assert(second);
 
  if ((first != NULL) && (second != NULL))
    {
#if defined(USE_STRCASECMP)
      return (0 == strcasecmp(first, second));
#else
      while ((*first != NIL) && (*second != NIL))
    {
      if (trio_to_upper(*first) != trio_to_upper(*second))
        {
          break;
        }
      first++;
      second++;
    }
      return ((*first == NIL) && (*second == NIL));
#endif
    }
  return FALSE;
}

TRIO_ARGS2() [2/10]

TRIO_STRING_PUBLIC float trio_to_float TRIO_ARGS2	(	(source, endp)	,
		TRIO_CONST char *	source,
		char **	endp
	)

Convert string to floating-point number.

Parameters

source	String to be converted.
endp	Pointer to end of the converted string.

Returns

A floating-point number.

The following Extended Backus-Naur form is used

double        ::= [ <sign> ]
                  ( <number> |
                    <number> <decimal_point> <number> |
                    <decimal_point> <number> )
                  [ <exponential> [ <sign> ] <number> ]
number        ::= 1*( <digit> )
digit         ::= ( '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' )
exponential   ::= ( 'e' | 'E' )
sign          ::= ( '-' | '+' )
decimal_point ::= '.'

Convert string to floating-point number.

Parameters

source	String to be converted.
endp	Pointer to end of the converted string.

Returns

A floating-point number.

See trio_to_long_double.

Definition at line 968 of file triostr.c.

{
#if defined(USE_STRTOLD)
  return strtold(source, endp);
#else
  int isNegative = FALSE;
  int isExponentNegative = FALSE;
  trio_long_double_t integer = 0.0;
  trio_long_double_t fraction = 0.0;
  unsigned long exponent = 0;
  trio_long_double_t base;
  trio_long_double_t fracdiv = 1.0;
  trio_long_double_t value = 0.0;
 
  /* First try hex-floats */
  if ((source[0] == '0') && ((source[1] == 'x') || (source[1] == 'X')))
    {
      base = 16.0;
      source += 2;
      while (isxdigit((int)*source))
    {
      integer *= base;
      integer += (isdigit((int)*source)
              ? (*source - '0')
              : 10 + (trio_to_upper((int)*source) - 'A'));
      source++;
    }
      if (*source == '.')
    {
      source++;
      while (isxdigit((int)*source))
        {
          fracdiv /= base;
          fraction += fracdiv * (isdigit((int)*source)
                     ? (*source - '0')
                     : 10 + (trio_to_upper((int)*source) - 'A'));
          source++;
        }
      if ((*source == 'p') || (*source == 'P'))
        {
          source++;
          if ((*source == '+') || (*source == '-'))
        {
          isExponentNegative = (*source == '-');
          source++;
        }
          while (isdigit((int)*source))
        {
          exponent *= 10;
          exponent += (*source - '0');
          source++;
        }
        }
    }
      /* For later use with exponent */
      base = 2.0;
    }
  else /* Then try normal decimal floats */
    {
      base = 10.0;
      isNegative = (*source == '-');
      /* Skip sign */
      if ((*source == '+') || (*source == '-'))
    source++;
 
      /* Integer part */
      while (isdigit((int)*source))
    {
      integer *= base;
      integer += (*source - '0');
      source++;
    }
 
      if (*source == '.')
    {
      source++; /* skip decimal point */
      while (isdigit((int)*source))
        {
          fracdiv /= base;
          fraction += (*source - '0') * fracdiv;
          source++;
        }
    }
      if ((*source == 'e')
      || (*source == 'E')
#if TRIO_MICROSOFT
      || (*source == 'd')
      || (*source == 'D')
#endif
      )
    {
      source++; /* Skip exponential indicator */
      isExponentNegative = (*source == '-');
      if ((*source == '+') || (*source == '-'))
        source++;
      while (isdigit((int)*source))
        {
          exponent *= (int)base;
          exponent += (*source - '0');
          source++;
        }
    }
    }
 
  value = integer + fraction;
  if (exponent != 0)
    {
      if (isExponentNegative)
    value /= pow(base, (double)exponent);
      else
    value *= pow(base, (double)exponent);
    }
  if (isNegative)
    value = -value;
 
  if (endp)
    *endp = (char *)source;
  return value;
#endif
}

TRIO_ARGS2() [3/10]

TRIO_STRING_PUBLIC char *trio_duplicate_max TRIO_ARGS2	(	(source, max)	,
		TRIO_CONST char *	source,
		size_t	max
	)

Duplicate at most max characters of source.

Parameters

source	Source string.
max	Maximum number of characters to duplicate.

Returns

A copy of the source string.

Postcondition

target will be zero terminated.

Definition at line 371 of file triostr.c.

{
  size_t length;
 
  assert(source);
  assert(max > 0);
 
  length = trio_length(source);
  if (length > max)
    {
      length = max;
    }
  return TrioDuplicateMax(source, length);
}

TRIO_ARGS2() [4/10]

TRIO_STRING_PRIVATE char *TrioDuplicateMax TRIO_ARGS2	(	(source, size)	,
		TRIO_CONST char *	source,
		size_t	size
	)

Definition at line 324 of file triostr.c.

{
  char *target;
 
  assert(source);
 
  /* Make room for string plus a terminating zero */
  size++;
  target = trio_create(size);
  if (target)
    {
      trio_copy_max(target, size, source);
    }
  return target;
}

TRIO_ARGS2() [5/10]

TRIO_STRING_PUBLIC char *trio_index_last TRIO_ARGS2	(	(string, character)	,
		TRIO_CONST char *	string,
		int	character
	)

Find first occurrence of a character in a string.

Parameters

string	String to be searched.
character	Character to be found.
A	pointer to the found character, or NULL if character was not found.

Find last occurrence of a character in a string.

Parameters

string	String to be searched.
character	Character to be found.
A	pointer to the found character, or NULL if character was not found.

Definition at line 668 of file triostr.c.

{
  assert(string);
 
  return strchr(string, character);
}

TRIO_ARGS2() [6/10]

TRIO_STRING_PUBLIC char *trio_tokenize TRIO_ARGS2	(	(string, delimiters)	,
		char *	string,
		TRIO_CONST char *	delimiters
	)

Tokenize string.

Parameters

string	String to be tokenized.
tokens	String containing list of delimiting characters.

Returns

Start of new token.

Warning

string will be destroyed.

Definition at line 933 of file triostr.c.

{
  assert(delimiters);
 
  return strtok(string, delimiters);
}

TRIO_ARGS2() [7/10]

TRIO_STRING_PUBLIC int trio_match_case TRIO_ARGS2	(	(string, pattern)	,
		TRIO_CONST char *	string,
		TRIO_CONST char *	pattern
	)

Compare two strings using wildcards.

Parameters

string	String to be searched.
pattern	Pattern, including wildcards, to search for.

Returns

Boolean value indicating success or failure.

Case-insensitive comparison.

The following wildcards can be used

• * Match any number of characters.
• ? Match a single character.

Compare two strings using wildcards.

Parameters

string	String to be searched.
pattern	Pattern, including wildcards, to search for.

Returns

Boolean value indicating success or failure.

Case-sensitive comparison.

The following wildcards can be used

• * Match any number of characters.
• ? Match a single character.

Definition at line 735 of file triostr.c.

{
  assert(string);
  assert(pattern);
 
  for (; ('*' != *pattern); ++pattern, ++string)
    {
      if (NIL == *string)
    {
      return (NIL == *pattern);
    }
      if ((trio_to_upper((int)*string) != trio_to_upper((int)*pattern))
      && ('?' != *pattern))
    {
      return FALSE;
    }
    }
  /* two-line patch to prevent *too* much recursiveness: */
  while ('*' == pattern[1])
    pattern++;
 
  do
    {
      if ( trio_match(string, &pattern[1]) )
    {
      return TRUE;
    }
    }
  while (*string++);
 
  return FALSE;
}

TRIO_ARGS2() [8/10]

TRIO_STRING_PUBLIC char *trio_substring TRIO_ARGS2	(	(string, substring)	,
		TRIO_CONST char *	string,
		TRIO_CONST char *	substring
	)

Determine if a string contains a substring.

Parameters

string	String to be searched.
substring	String to be found.

Returns

Boolean value indicating success or failure.

Search for a substring in a string.

Parameters

string	String to be searched.
substring	String to be found.

Returns

Pointer to first occurrence of substring in string, or NULL if no match was found.

Definition at line 247 of file triostr.c.

{
  assert(string);
  assert(substring);
 
  return (0 != strstr(string, substring));
}

TRIO_ARGS2() [9/10]

TRIO_STRING_PUBLIC unsigned long trio_hash TRIO_ARGS2	(	(string, type)	,
		TRIO_CONST char *	string,
		int	type
	)

Calculate a hash value for a string.

Parameters

string	String to be calculated on.
type	Hash function.

Returns

Calculated hash value.

type can be one of the following

• TRIO_HASH_PLAIN Plain hash function.

Definition at line 631 of file triostr.c.

{
  unsigned long value = 0L;
  char ch;
 
  assert(string);
 
  switch (type)
    {
    case TRIO_HASH_PLAIN:
      while ( (ch = *string++) != NIL )
    {
      value *= 31;
      value += (unsigned long)ch;
    }
      break;
    default:
      assert(FALSE);
      break;
    }
  return value;
}

TRIO_ARGS2() [10/10]

TRIO_STRING_PUBLIC int trio_copy TRIO_ARGS2	(	(target, source)	,
		char *	target,
		TRIO_CONST char *	source
	)

Append source at the end of target.

Parameters

target	Target string.
source	Source string.

Returns

Boolean value indicating success or failure.

Precondition

target must point to a memory chunk with sufficient room to contain the target string and source string.

No boundary checking is performed, so insufficient memory will result in a buffer overrun.

Postcondition

target will be zero terminated.

Copy source to target.

Parameters

target	Target string.
source	Source string.

Returns

Boolean value indicating success or failure.

Precondition

target must point to a memory chunk with sufficient room to contain the source string.

No boundary checking is performed, so insufficient memory will result in a buffer overrun.

Postcondition

target will be zero terminated.

Definition at line 187 of file triostr.c.

{
  assert(target);
  assert(source);
 
  return (strcat(target, source) != NULL);
}

TRIO_ARGS3() [1/5]

TRIO_STRING_PUBLIC int trio_equal_max TRIO_ARGS3	(	(first, max, second)	,
		TRIO_CONST char *	first,
		size_t	max,
		TRIO_CONST char *	second
	)

Compare if two strings up until the first max characters are equal.

Parameters

first	First string.
max	Maximum number of characters to compare.
second	Second string.

Returns

Boolean indicating whether the two strings are equal or not.

Case-sensitive comparison.

Compare if two strings up until the first max characters are equal.

Parameters

first	First string.
max	Maximum number of characters to compare.
second	Second string.

Returns

Boolean indicating whether the two strings are equal or not.

Case-insensitive comparison.

Definition at line 468 of file triostr.c.

{
  assert(first);
  assert(second);
 
  if ((first != NULL) && (second != NULL))
    {
      return (0 == strncmp(first, second, max));
    }
  return FALSE;
}

TRIO_ARGS3() [2/5]

TRIO_STRING_PUBLIC unsigned long trio_to_unsigned_long TRIO_ARGS3	(	(string, endp, base)	,
		TRIO_CONST char *	string,
		char **	endp,
		int	base
	)

Convert string to signed integer.

Parameters

string	String to be converted.
endp	Pointer to end of converted string.
base	Radix number of number.

Convert string to unsigned integer.

Parameters

string	String to be converted.
endp	Pointer to end of converted string.
base	Radix number of number.

Definition at line 1148 of file triostr.c.

{
  assert(string);
  assert((base >= 2) && (base <= 36));
 
  return strtol(string, endp, base);
}

TRIO_ARGS3() [3/5]

TRIO_STRING_PUBLIC char *trio_substring_max TRIO_ARGS3	(	(string, max, substring)	,
		TRIO_CONST char *	string,
		size_t	max,
		TRIO_CONST char *	substring
	)

Search for a substring in the first max characters of a string.

Parameters

string	String to be searched.
max	Maximum characters to be searched.
substring	String to be found.

Returns

Pointer to first occurrence of substring in string, or NULL if no match was found.

Definition at line 892 of file triostr.c.

{
  size_t count;
  size_t size;
  char *result = NULL;
 
  assert(string);
  assert(substring);
 
  size = trio_length(substring);
  if (size <= max)
    {
      for (count = 0; count <= max - size; count++)
    {
      if (trio_equal_max(substring, size, &string[count]))
        {
          result = (char *)&string[count];
          break;
        }
    }
    }
  return result;
}

TRIO_ARGS3() [4/5]

TRIO_STRING_PUBLIC int trio_copy_max TRIO_ARGS3	(	(target, max, source)	,
		char *	target,
		size_t	max,
		TRIO_CONST char *	source
	)

Append at most max characters from source to target.

Parameters

target	Target string.
max	Maximum number of characters to append.
source	Source string.

Returns

Boolean value indicating success or failure.

Precondition

target must point to a memory chuck with sufficient room to contain the target string and the source string (at most max characters).

No boundary checking is performed, so insufficient memory will result in a buffer overrun.

Postcondition

target will be zero terminated.

Copy at most max characters from source to target.

Parameters

target	Target string.
max	Maximum number of characters to append.
source	Source string.

Returns

Boolean value indicating success or failure.

Precondition

target must point to a memory chunk with sufficient room to contain the source string (at most max characters).

No boundary checking is performed, so insufficient memory will result in a buffer overrun.

Postcondition

target will be zero terminated.

Definition at line 216 of file triostr.c.

{
  size_t length;
 
  assert(target);
  assert(source);
 
  length = trio_length(target);
 
  if (max > length)
    {
      strncat(target, source, max - length - 1);
    }
  return TRUE;
}

TRIO_ARGS3() [5/5]

TRIO_STRING_PUBLIC size_t trio_span_function TRIO_ARGS3	(	(target, source, Function)	,
		char *	target,
		TRIO_CONST char *	source,
		int *Function	TRIO_PROTO(int)
	)

Execute a function on each character in string.

Parameters

target	Target string.
source	Source string.
Function	Function to be executed.

Returns

Number of processed characters.

Definition at line 836 of file triostr.c.

{
  size_t count = 0;
 
  assert(target);
  assert(source);
  assert(Function);
 
  while (*source != NIL)
    {
      *target++ = Function(*source++);
      count++;
    }
  return count;
}

TRIO_ARGS4()

TRIO_STRING_PUBLIC size_t trio_format_date_max TRIO_ARGS4	(	(target, max, format, datetime)	,
		char *	target,
		size_t	max,
		TRIO_CONST char *	format,
		TRIO_CONST struct tm *	datetime
	)

Format the date/time according to format.

Parameters

target	Target string.
max	Maximum number of characters to format.
format	Formatting string.
datetime	Date/time structure.

Returns

Number of formatted characters.

The formatting string accepts the same specifiers as the standard C function strftime.

Definition at line 602 of file triostr.c.

{
  assert(target);
  assert(format);
  assert(datetime);
  assert(max > 0);
 
  return strftime(target, max, format, datetime);
}