/*************************************************************************
*
* $Id: triostr.c 3600 2007-04-17 12:44:58Z veillard $
*
* Copyright (C) 2001 Bjorn Reese and Daniel Stenberg.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
* MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
* CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
*
************************************************************************/
/*************************************************************************
* Include files
*/
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include "triodef.h"
#include "triostr.h"
/*************************************************************************
* Definitions
*/
#if !defined(TRIO_STRING_PUBLIC)
#endif
#if !defined(TRIO_STRING_PRIVATE)
#endif
#if !defined(NULL)
# define NULL 0
#endif
#if !defined(NIL)
# define NIL ((char)0)
#endif
#if !defined(FALSE)
#endif
#if !defined(BOOLEAN_T)
# define BOOLEAN_T int
#endif
#if defined(TRIO_COMPILER_SUPPORTS_C99)
# define USE_STRTOD
# define USE_STRTOF
#elif defined(TRIO_COMPILER_MSVC)
# define USE_STRTOD
#endif
#if defined(TRIO_PLATFORM_UNIX)
# define USE_STRCASECMP
# define USE_STRNCASECMP
# if defined(TRIO_PLATFORM_SUNOS)
# define USE_SYS_ERRLIST
# else
# define USE_STRERROR
# endif
# if defined(TRIO_PLATFORM_QNX)
# endif
#elif defined(TRIO_PLATFORM_WIN32)
# define USE_STRCASECMP
# if defined(_WIN32_WCE)
# else
# endif
#endif
#if !(defined(TRIO_PLATFORM_SUNOS))
# define USE_TOLOWER
# define USE_TOUPPER
#endif
/*************************************************************************
* Structures
*/
struct _trio_string_t
{
char *content;
};
/*************************************************************************
* Constants
*/
#if !defined(TRIO_MINIMAL)
#endif
/*************************************************************************
* Static String Functions
*/
#if defined(TRIO_DOCUMENTATION)
# include "doc/doc_static.h"
#endif
/** @addtogroup StaticStrings
@{
*/
/**
Create new string.
@param size Size of new string.
@return Pointer to string, or NULL if allocation failed.
*/
TRIO_STRING_PUBLIC char *
TRIO_ARGS1((size),
{
return (char *)TRIO_MALLOC(size);
}
/**
Destroy string.
@param string String to be freed.
*/
TRIO_STRING_PUBLIC void
TRIO_ARGS1((string),
char *string)
{
if (string)
{
}
}
/**
Count the number of characters in a string.
@param string String to measure.
@return Number of characters in @string.
*/
TRIO_ARGS1((string),
TRIO_CONST char *string)
{
}
#if !defined(TRIO_MINIMAL)
/**
Append @p source at the end of @p target.
@param target Target string.
@param source Source string.
@return Boolean value indicating success or failure.
@pre @p target must point to a memory chunk with sufficient room to
contain the @p target string and @p source string.
@pre No boundary checking is performed, so insufficient memory will
result in a buffer overrun.
@post @p target will be zero terminated.
*/
char *target,
TRIO_CONST char *source)
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/**
Append at most @p max characters from @p source to @p target.
@param target Target string.
@param max Maximum number of characters to append.
@param source Source string.
@return Boolean value indicating success or failure.
@pre @p target must point to a memory chuck with sufficient room to
contain the @p target string and the @p source string (at most @p max
characters).
@pre No boundary checking is performed, so insufficient memory will
result in a buffer overrun.
@post @p target will be zero terminated.
*/
char *target,
TRIO_CONST char *source)
{
{
}
return TRUE;
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/**
Determine if a string contains a substring.
@param string String to be searched.
@param substring String to be found.
@return Boolean value indicating success or failure.
*/
TRIO_CONST char *string,
TRIO_CONST char *substring)
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/**
Copy @p source to @p target.
@param target Target string.
@param source Source string.
@return Boolean value indicating success or failure.
@pre @p target must point to a memory chunk with sufficient room to
contain the @p source string.
@pre No boundary checking is performed, so insufficient memory will
result in a buffer overrun.
@post @p target will be zero terminated.
*/
char *target,
TRIO_CONST char *source)
{
return TRUE;
}
#endif /* !defined(TRIO_MINIMAL) */
/**
Copy at most @p max characters from @p source to @p target.
@param target Target string.
@param max Maximum number of characters to append.
@param source Source string.
@return Boolean value indicating success or failure.
@pre @p target must point to a memory chunk with sufficient room to
contain the @p source string (at most @p max characters).
@pre No boundary checking is performed, so insufficient memory will
result in a buffer overrun.
@post @p target will be zero terminated.
*/
char *target,
TRIO_CONST char *source)
{
return TRUE;
}
/*
* TrioDuplicateMax
*/
TRIO_STRING_PRIVATE char *
TRIO_CONST char *source,
{
char *target;
/* Make room for string plus a terminating zero */
size++;
if (target)
{
}
return target;
}
/**
Duplicate @p source.
@param source Source string.
@return A copy of the @p source string.
@post @p target will be zero terminated.
*/
TRIO_STRING_PUBLIC char *
TRIO_ARGS1((source),
TRIO_CONST char *source)
{
}
#if !defined(TRIO_MINIMAL)
/**
Duplicate at most @p max characters of @p source.
@param source Source string.
@param max Maximum number of characters to duplicate.
@return A copy of the @p source string.
@post @p target will be zero terminated.
*/
TRIO_STRING_PUBLIC char *
TRIO_CONST char *source,
{
{
}
}
#endif /* !defined(TRIO_MINIMAL) */
/**
Compare if two strings are equal.
@param first First string.
@param second Second string.
@return Boolean indicating whether the two strings are equal or not.
Case-insensitive comparison.
*/
TRIO_CONST char *first,
TRIO_CONST char *second)
{
{
#if defined(USE_STRCASECMP)
#else
{
{
break;
}
first++;
second++;
}
#endif
}
return FALSE;
}
/**
Compare if two strings are equal.
@param first First string.
@param second Second string.
@return Boolean indicating whether the two strings are equal or not.
Case-sensitive comparison.
*/
TRIO_CONST char *first,
TRIO_CONST char *second)
{
{
}
return FALSE;
}
#if !defined(TRIO_MINIMAL)
/**
Compare if two strings up until the first @p max characters are equal.
@param first First string.
@param max Maximum number of characters to compare.
@param second Second string.
@return Boolean indicating whether the two strings are equal or not.
Case-sensitive comparison.
*/
TRIO_CONST char *first,
TRIO_CONST char *second)
{
{
}
return FALSE;
}
#endif /* !defined(TRIO_MINIMAL) */
/**
Compare if two strings are equal.
@param first First string.
@param second Second string.
@return Boolean indicating whether the two strings are equal or not.
Collating characters are considered equal.
*/
TRIO_CONST char *first,
TRIO_CONST char *second)
{
#if defined(LC_COLLATE)
#else
#endif
}
/**
Compare if two strings up until the first @p max characters are equal.
@param first First string.
@param max Maximum number of characters to compare.
@param second Second string.
@return Boolean indicating whether the two strings are equal or not.
Case-insensitive comparison.
*/
TRIO_CONST char *first,
TRIO_CONST char *second)
{
{
#if defined(USE_STRNCASECMP)
#else
/* Not adequately tested yet */
{
{
break;
}
first++;
second++;
cnt++;
}
#endif
}
return FALSE;
}
/**
Provide a textual description of an error code (errno).
@param error_number Error number.
@return Textual description of @p error_number.
*/
TRIO_STRING_PUBLIC TRIO_CONST char *
int error_number)
{
#if defined(USE_STRERROR)
return strerror(error_number);
#elif defined(USE_SYS_ERRLIST)
extern char *sys_errlist[];
extern int sys_nerr;
? "unknown"
#else
return "unknown";
#endif
}
#if !defined(TRIO_MINIMAL) && !defined(_WIN32_WCE)
/**
@param target Target string.
@param max Maximum number of characters to format.
@param format Formatting string.
@return Number of formatted characters.
The formatting string accepts the same specifiers as the standard C
function strftime.
*/
char *target,
TRIO_CONST char *format,
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/**
Calculate a hash value for a string.
@param string String to be calculated on.
@param type Hash function.
@return Calculated hash value.
@p type can be one of the following
@li @c TRIO_HASH_PLAIN Plain hash function.
*/
TRIO_STRING_PUBLIC unsigned long
TRIO_CONST char *string,
int type)
{
unsigned long value = 0L;
char ch;
switch (type)
{
case TRIO_HASH_PLAIN:
{
value *= 31;
}
break;
default:
break;
}
return value;
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/**
Find first occurrence of a character in a string.
@param string String to be searched.
@param character Character to be found.
@param A pointer to the found character, or NULL if character was not found.
*/
TRIO_STRING_PUBLIC char *
TRIO_CONST char *string,
int character)
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/**
Find last occurrence of a character in a string.
@param string String to be searched.
@param character Character to be found.
@param A pointer to the found character, or NULL if character was not found.
*/
TRIO_STRING_PUBLIC char *
TRIO_CONST char *string,
int character)
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/**
Convert the alphabetic letters in the string to lower-case.
@param target String to be converted.
@return Number of processed characters (converted or not).
*/
TRIO_ARGS1((target),
char *target)
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/**
Compare two strings using wildcards.
@param string String to be searched.
@param pattern Pattern, including wildcards, to search for.
@return Boolean value indicating success or failure.
Case-insensitive comparison.
The following wildcards can be used
@li @c * Match any number of characters.
@li @c ? Match a single character.
*/
TRIO_CONST char *string,
TRIO_CONST char *pattern)
{
{
{
}
&& ('?' != *pattern))
{
return FALSE;
}
}
/* two-line patch to prevent *too* much recursiveness: */
pattern++;
do
{
{
return TRUE;
}
}
while (*string++);
return FALSE;
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/**
Compare two strings using wildcards.
@param string String to be searched.
@param pattern Pattern, including wildcards, to search for.
@return Boolean value indicating success or failure.
Case-sensitive comparison.
The following wildcards can be used
@li @c * Match any number of characters.
@li @c ? Match a single character.
*/
TRIO_CONST char *string,
TRIO_CONST char *pattern)
{
{
{
}
&& ('?' != *pattern))
{
return FALSE;
}
}
/* two-line patch to prevent *too* much recursiveness: */
pattern++;
do
{
{
return TRUE;
}
}
while (*string++);
return FALSE;
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/**
Execute a function on each character in string.
@param target Target string.
@param source Source string.
@param Function Function to be executed.
@return Number of processed characters.
*/
char *target,
TRIO_CONST char *source,
int (*Function) TRIO_PROTO((int)))
{
{
count++;
}
return count;
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/**
Search for a substring in a string.
@param string String to be searched.
@param substring String to be found.
@return Pointer to first occurrence of @p substring in @p string, or NULL
if no match was found.
*/
TRIO_STRING_PUBLIC char *
TRIO_CONST char *string,
TRIO_CONST char *substring)
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/**
Search for a substring in the first @p max characters of a string.
@param string String to be searched.
@param max Maximum characters to be searched.
@param substring String to be found.
@return Pointer to first occurrence of @p substring in @p string, or NULL
if no match was found.
*/
TRIO_STRING_PUBLIC char *
TRIO_CONST char *string,
TRIO_CONST char *substring)
{
{
{
{
break;
}
}
}
return result;
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/**
Tokenize string.
@param string String to be tokenized.
@param tokens String containing list of delimiting characters.
@return Start of new token.
@warning @p string will be destroyed.
*/
TRIO_STRING_PUBLIC char *
char *string,
TRIO_CONST char *delimiters)
{
}
#endif /* !defined(TRIO_MINIMAL) */
/**
Convert string to floating-point number.
@param source String to be converted.
@param endp Pointer to end of the converted string.
@return A floating-point number.
The following Extended Backus-Naur form is used
@verbatim
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 ::= '.'
@endverbatim
*/
/* FIXME: Add EBNF for hex-floats */
TRIO_CONST char *source,
char **endp)
{
#if defined(USE_STRTOLD)
#else
int isNegative = FALSE;
int isExponentNegative = FALSE;
unsigned long exponent = 0;
/* First try hex-floats */
{
base = 16.0;
source += 2;
{
? (*source - '0')
source++;
}
if (*source == '.')
{
source++;
{
? (*source - '0')
source++;
}
{
source++;
{
source++;
}
{
exponent *= 10;
source++;
}
}
}
/* For later use with exponent */
base = 2.0;
}
else /* Then try normal decimal floats */
{
base = 10.0;
/* Skip sign */
source++;
/* Integer part */
{
source++;
}
if (*source == '.')
{
source++; /* skip decimal point */
{
source++;
}
}
if ((*source == 'e')
|| (*source == 'E')
#if TRIO_MICROSOFT
|| (*source == 'd')
|| (*source == 'D')
#endif
)
{
source++; /* Skip exponential indicator */
source++;
{
source++;
}
}
}
if (exponent != 0)
{
if (isExponentNegative)
else
}
if (isNegative)
if (endp)
return value;
#endif
}
/**
Convert string to floating-point number.
@param source String to be converted.
@param endp Pointer to end of the converted string.
@return A floating-point number.
See @ref trio_to_long_double.
*/
TRIO_STRING_PUBLIC double
TRIO_CONST char *source,
char **endp)
{
#if defined(USE_STRTOD)
#else
#endif
}
#if !defined(TRIO_MINIMAL)
/**
Convert string to floating-point number.
@param source String to be converted.
@param endp Pointer to end of the converted string.
@return A floating-point number.
See @ref trio_to_long_double.
*/
TRIO_STRING_PUBLIC float
TRIO_CONST char *source,
char **endp)
{
#if defined(USE_STRTOF)
#else
#endif
}
#endif /* !defined(TRIO_MINIMAL) */
/**
Convert string to signed integer.
@param string String to be converted.
@param endp Pointer to end of converted string.
@param base Radix number of number.
*/
TRIO_STRING_PUBLIC long
TRIO_CONST char *string,
char **endp,
int base)
{
}
#if !defined(TRIO_MINIMAL)
/**
Convert one alphabetic letter to lower-case.
@param source The letter to be converted.
@return The converted letter.
*/
TRIO_ARGS1((source),
int source)
{
#if defined(USE_TOLOWER)
#else
/* Does not handle locales or non-contiguous alphabetic characters */
: source;
#endif
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/**
Convert string to unsigned integer.
@param string String to be converted.
@param endp Pointer to end of converted string.
@param base Radix number of number.
*/
TRIO_STRING_PUBLIC unsigned long
TRIO_CONST char *string,
char **endp,
int base)
{
}
#endif /* !defined(TRIO_MINIMAL) */
/**
Convert one alphabetic letter to upper-case.
@param source The letter to be converted.
@return The converted letter.
*/
TRIO_ARGS1((source),
int source)
{
#if defined(USE_TOUPPER)
#else
/* Does not handle locales or non-contiguous alphabetic characters */
: source;
#endif
}
#if !defined(TRIO_MINIMAL)
/**
Convert the alphabetic letters in the string to upper-case.
@param target The string to be converted.
@return The number of processed characters (converted or not).
*/
TRIO_ARGS1((target),
char *target)
{
}
#endif /* !defined(TRIO_MINIMAL) */
/** @} End of StaticStrings */
/*************************************************************************
* Dynamic String Functions
*/
#if defined(TRIO_DOCUMENTATION)
# include "doc/doc_dynamic.h"
#endif
/** @addtogroup DynamicStrings
@{
*/
/*
* TrioStringAlloc
*/
{
if (self)
{
}
return self;
}
/*
* TrioStringGrow
*
* The size of the string will be increased by 'delta' characters. If
* 'delta' is zero, the size will be doubled.
*/
{
char *new_content;
if (new_content)
{
}
return status;
}
#if !defined(TRIO_MINIMAL)
/*
* TrioStringGrowTo
*
* The size of the string will be increased to 'length' plus one characters.
* If 'length' is less than the original size, the original size will be
* used (that is, the size of the string is never decreased).
*/
{
length++; /* Room for terminating zero */
: TRUE;
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/**
Create a new dynamic string.
@param initial_size Initial size of the buffer.
@return Newly allocated dynamic string, or NULL if memory allocation failed.
*/
int initial_size)
{
self = TrioStringAlloc();
if (self)
{
if (TrioStringGrow(self,
{
}
else
{
}
}
return self;
}
#endif /* !defined(TRIO_MINIMAL) */
/**
Deallocate the dynamic string and its contents.
@param self Dynamic string
*/
TRIO_STRING_PUBLIC void
TRIO_ARGS1((self),
{
if (self)
{
}
}
#if !defined(TRIO_MINIMAL)
/**
Get a pointer to the content.
@param self Dynamic string.
@param offset Offset into content.
@return Pointer to the content.
@p Offset can be zero, positive, or negative. If @p offset is zero,
then the start of the content will be returned. If @p offset is positive,
then a pointer to @p offset number of characters from the beginning of the
content is returned. If @p offset is negative, then a pointer to @p offset
number of characters from the ending of the string, starting at the
terminating zero, is returned.
*/
TRIO_STRING_PUBLIC char *
int offset)
{
{
{
(void)trio_string_length(self);
}
if (offset >= 0)
{
{
}
}
else
{
if (offset < 0)
{
offset = 0;
}
}
}
return result;
}
#endif /* !defined(TRIO_MINIMAL) */
/**
Extract the content.
@param self Dynamic String
@return Content of dynamic string.
The content is removed from the dynamic string. This enables destruction
of the dynamic string without deallocation of the content.
*/
TRIO_STRING_PUBLIC char *
TRIO_ARGS1((self),
{
char *result;
/* FIXME: Allocate new empty buffer? */
return result;
}
#if !defined(TRIO_MINIMAL)
/**
Set the content of the dynamic string.
@param self Dynamic String
@param buffer The new content.
Sets the content of the dynamic string to a copy @p buffer.
An existing content will be deallocated first, if necessary.
@remark
This function will make a copy of @p buffer.
You are responsible for deallocating @p buffer yourself.
*/
TRIO_STRING_PUBLIC void
char *buffer)
{
}
#endif /* !defined(TRIO_MINIMAL) */
/*
* trio_string_size
*/
TRIO_ARGS1((self),
{
}
/*
* trio_string_terminate
*/
TRIO_STRING_PUBLIC void
TRIO_ARGS1((self),
{
}
#if !defined(TRIO_MINIMAL)
/**
Append the second string to the first.
@param self Dynamic string to be modified.
@param other Dynamic string to copy from.
@return Boolean value indicating success or failure.
*/
{
goto error;
return TRUE;
return FALSE;
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_xstring_append
*/
TRIO_CONST char *other)
{
goto error;
return TRUE;
return FALSE;
}
#endif /* !defined(TRIO_MINIMAL) */
/*
* trio_xstring_append_char
*/
char character)
{
{
if (!TrioStringGrow(self, 0))
goto error;
}
return TRUE;
return FALSE;
}
#if !defined(TRIO_MINIMAL)
/**
Search for the first occurrence of second parameter in the first.
@param self Dynamic string to be modified.
@param other Dynamic string to copy from.
@return Boolean value indicating success or failure.
*/
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_xstring_contains
*/
TRIO_CONST char *other)
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_string_copy
*/
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_xstring_copy
*/
TRIO_CONST char *other)
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_string_duplicate
*/
TRIO_ARGS1((other),
{
self = TrioStringAlloc();
if (self)
{
{
}
else
{
}
}
return self;
}
#endif /* !defined(TRIO_MINIMAL) */
/*
* trio_xstring_duplicate
*/
TRIO_ARGS1((other),
TRIO_CONST char *other)
{
self = TrioStringAlloc();
if (self)
{
{
}
else
{
}
}
return self;
}
#if !defined(TRIO_MINIMAL)
/*
* trio_string_equal
*/
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_xstring_equal
*/
TRIO_CONST char *other)
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_string_equal_max
*/
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_xstring_equal_max
*/
TRIO_CONST char *other)
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_string_equal_case
*/
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_xstring_equal_case
*/
TRIO_CONST char *other)
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_string_equal_case_max
*/
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_xstring_equal_case_max
*/
TRIO_CONST char *other)
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL) && !defined(_WIN32_WCE)
/*
* trio_string_format_data_max
*/
TRIO_CONST char *format,
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_string_index
*/
TRIO_STRING_PUBLIC char *
int character)
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_string_index_last
*/
TRIO_STRING_PUBLIC char *
int character)
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_string_length
*/
TRIO_ARGS1((self),
{
{
}
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_string_lower
*/
TRIO_ARGS1((self),
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_string_match
*/
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_xstring_match
*/
TRIO_CONST char *other)
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_string_match_case
*/
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_xstring_match_case
*/
TRIO_CONST char *other)
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_string_substring
*/
TRIO_STRING_PUBLIC char *
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_xstring_substring
*/
TRIO_STRING_PUBLIC char *
TRIO_CONST char *other)
{
}
#endif /* !defined(TRIO_MINIMAL) */
#if !defined(TRIO_MINIMAL)
/*
* trio_string_upper
*/
TRIO_ARGS1((self),
{
}
#endif /* !defined(TRIO_MINIMAL) */
/** @} End of DynamicStrings */