\hypertarget{group__str}{
\section{str: Dynamically allocated string library.}
\label{group__str}\index{str: Dynamically allocated string library.@{str: Dynamically allocated string library.}}
}
\subsection*{Data Structures}
\begin{CompactItemize}
\item 
struct \hyperlink{structstr}{str}
\item 
struct \hyperlink{structstr__sortentry}{str\_\-sortentry}
\end{CompactItemize}
\subsection*{Overhead Functions}
\begin{CompactItemize}
\item 
\#define \hyperlink{group__str_g5130cf1a57c497bab66091fbdb9fd6d3}{str\_\-ready}(S, SZ)~str\_\-alloc(S,SZ,0)
\item 
\#define \hyperlink{group__str_g05c5854c9d40dbe953625279b5deb5c7}{str\_\-realloc}(S, SZ)~str\_\-alloc(S,SZ,1)
\item 
int \hyperlink{group__str_g49aec9c56d91c2a8a18bf4677b5e8a5b}{str\_\-init} (\hyperlink{structstr}{str} $\ast$s)
\item 
int \hyperlink{group__str_gca368420555c886139b10d887df45941}{str\_\-alloc} (\hyperlink{structstr}{str} $\ast$s, unsigned size, int copy)
\item 
void \hyperlink{group__str_ga45f56943ecb5e8705e041ff6b70df95}{str\_\-free} (\hyperlink{structstr}{str} $\ast$s)
\item 
int \hyperlink{group__str_g174d1bf12ba03f33d6bfe98c566fec4e}{str\_\-truncate} (\hyperlink{structstr}{str} $\ast$s, unsigned len)
\end{CompactItemize}
\subsection*{In-place Modification Functions}
\begin{CompactItemize}
\item 
\hypertarget{group__str_ga09ac31a610a1a52a332668efeb65098}{
\#define \textbf{str\_\-strip}(S)~(str\_\-rstrip(S), str\_\-lstrip(S))}
\label{group__str_ga09ac31a610a1a52a332668efeb65098}

\item 
void \hyperlink{group__str_gb338bac7017bdd4759f6a876fa3c1b36}{str\_\-lower} (\hyperlink{structstr}{str} $\ast$s)
\item 
void \hyperlink{group__str_g1b08b4fba3b7ea32ced0109a50ef7d06}{str\_\-upper} (\hyperlink{structstr}{str} $\ast$s)
\item 
long \hyperlink{group__str_g7aa699416198667b7b2198591ee1811f}{str\_\-subst} (\hyperlink{structstr}{str} $\ast$s, char from, char to)
\item 
void \hyperlink{group__str_g97329d0205007c89bf197446f30c75de}{str\_\-lstrip} (\hyperlink{structstr}{str} $\ast$s)
\item 
void \hyperlink{group__str_g095c8adc8d7a7279e8c71746a5974ee6}{str\_\-rstrip} (\hyperlink{structstr}{str} $\ast$s)
\item 
void \hyperlink{group__str_g369b7dda6ed587477dde663240cf175f}{str\_\-lcut} (\hyperlink{structstr}{str} $\ast$s, unsigned count)
\item 
void \hyperlink{group__str_gb12e6ee45d534e52ef16f4d3f0d54390}{str\_\-rcut} (\hyperlink{structstr}{str} $\ast$s, unsigned count)
\item 
int \hyperlink{group__str_g1185bbfed7209ff269342cea523de7dd}{str\_\-sort} (\hyperlink{structstr}{str} $\ast$s, char sep, long count, int($\ast$fn)(const \hyperlink{structstr__sortentry}{str\_\-sortentry} $\ast$a, const \hyperlink{structstr__sortentry}{str\_\-sortentry} $\ast$b))
\item 
\hypertarget{group__str_g5ec7d27f578d2ea17f7be976acb3b214}{
int \textbf{str\_\-splice} (\hyperlink{structstr}{str} $\ast$s, unsigned start, unsigned len, const \hyperlink{structstr}{str} $\ast$r)}
\label{group__str_g5ec7d27f578d2ea17f7be976acb3b214}

\item 
\hypertarget{group__str_g9e8aad09dbf83c86642761c1ed7547bf}{
int \textbf{str\_\-splices} (\hyperlink{structstr}{str} $\ast$s, unsigned start, unsigned len, const char $\ast$r)}
\label{group__str_g9e8aad09dbf83c86642761c1ed7547bf}

\item 
\hypertarget{group__str_gcc492d40b0c7c80df98cc0ecf88607f6}{
int \textbf{str\_\-spliceb} (\hyperlink{structstr}{str} $\ast$s, unsigned start, unsigned len, const char $\ast$r, unsigned rlen)}
\label{group__str_gcc492d40b0c7c80df98cc0ecf88607f6}

\item 
long \hyperlink{group__str_g46b3436a55500d66b1343ff7c8122831}{str\_\-xlate} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$from, const char $\ast$to, unsigned nchars)
\end{CompactItemize}
\subsection*{Searching Functions}
\begin{CompactItemize}
\item 
\hypertarget{group__str_gcafe63caac1303c441db7c110be027fa}{
\#define \textbf{str\_\-findfirst}(S, C)~str\_\-findnext(S,C,0)}
\label{group__str_gcafe63caac1303c441db7c110be027fa}

\item 
\hypertarget{group__str_g7a0a2b90aa7d8d6205eaea575fdfd1d0}{
\#define \textbf{str\_\-findfirstof}(S, L)~str\_\-findnextof(S,L,0)}
\label{group__str_g7a0a2b90aa7d8d6205eaea575fdfd1d0}

\item 
\hypertarget{group__str_g9cf04df9caf73233932f12d804e84267}{
\#define \textbf{str\_\-findfirstnot}(S, L)~str\_\-findnextnot(S,L,0)}
\label{group__str_g9cf04df9caf73233932f12d804e84267}

\item 
\hypertarget{group__str_g86dc14ff56c94ae7eab5c60fc0ef2c82}{
\#define \textbf{str\_\-findlast}(S, C)~str\_\-findprev(S,C,-1)}
\label{group__str_g86dc14ff56c94ae7eab5c60fc0ef2c82}

\item 
\hypertarget{group__str_g7ac5797d7f29eaf3117e7a1a25865acc}{
\#define \textbf{str\_\-findlastof}(S, L)~str\_\-findprevof(S,L,-1)}
\label{group__str_g7ac5797d7f29eaf3117e7a1a25865acc}

\item 
\hypertarget{group__str_gd4f15c8af11ced1540e121be2ca5645f}{
\#define \textbf{str\_\-findlastnot}(S, L)~str\_\-findprevof(S,L,-1)}
\label{group__str_gd4f15c8af11ced1540e121be2ca5645f}

\item 
void \hyperlink{group__str_g8eaf81912158733331aa9a8b8f92bd7c}{str\_\-buildmap} (int map\mbox{[}256\mbox{]}, const char $\ast$list)
\item 
unsigned \hyperlink{group__str_g54f4ff27f4a2ee0eb842a44b1b16b600}{str\_\-count} (const \hyperlink{structstr}{str} $\ast$s, char ch)
\item 
unsigned \hyperlink{group__str_g3ce731047986d72c5514d83876d259f4}{str\_\-countof} (const \hyperlink{structstr}{str} $\ast$s, const char $\ast$list)
\item 
int \hyperlink{group__str_g192b55272495861b19f9928a2e677717}{str\_\-findnext} (const \hyperlink{structstr}{str} $\ast$s, char ch, unsigned pos)
\item 
int \hyperlink{group__str_g00a17536de20c68dd23fa8e872f8a713}{str\_\-findnextof} (const \hyperlink{structstr}{str} $\ast$s, const char $\ast$list, unsigned pos)
\item 
int \hyperlink{group__str_g1fd2973086658d66dc34a27b45b43286}{str\_\-findnextnot} (const \hyperlink{structstr}{str} $\ast$s, const char $\ast$list, unsigned pos)
\item 
int \hyperlink{group__str_gd132f32bf7d02f19f86aca10a0c5f1cc}{str\_\-findprev} (const \hyperlink{structstr}{str} $\ast$s, char ch, unsigned pos)
\item 
int \hyperlink{group__str_g34f902a8bd040b4d44802c7f5f2ca24a}{str\_\-findprevof} (const \hyperlink{structstr}{str} $\ast$s, const char $\ast$list, unsigned pos)
\item 
int \hyperlink{group__str_g58db78418ff61c2b7b7e11f7021c9726}{str\_\-findprevnot} (const \hyperlink{structstr}{str} $\ast$s, const char $\ast$list, unsigned pos)
\end{CompactItemize}
\subsection*{Assignment Functions}
\begin{CompactItemize}
\item 
int \hyperlink{group__str_g9156aedd17aac54cd238c8caa6dc6e85}{str\_\-copy} (\hyperlink{structstr}{str} $\ast$s, const \hyperlink{structstr}{str} $\ast$in)
\item 
int \hyperlink{group__str_g100c559e82996e86f9bb9472c0ce9331}{str\_\-copys} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$in)
\item 
int \hyperlink{group__str_g26880681d1ed8fd1a80ccd4e39ce6e61}{str\_\-copyb} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$in, unsigned len)
\item 
int \hyperlink{group__str_ga48f044aa7889f07df12b69a9f9dc081}{str\_\-copyf} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$format,...)
\item 
int \hyperlink{group__str_g6782b26e389f10eaf3ea8a3cb1fe7390}{str\_\-copyfv} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$format, va\_\-list ap)
\item 
int \hyperlink{group__str_g27fcdd2e902c5efac54fce1c2c9f4319}{str\_\-copyns} (\hyperlink{structstr}{str} $\ast$s, unsigned int count,...)
\item 
int \hyperlink{group__str_g0883eb2957281e989efab5d1591c6e94}{str\_\-copy2s} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$a, const char $\ast$b)
\item 
int \hyperlink{group__str_g59d4d0111c25f28598949d4fa3ccb277}{str\_\-copy3s} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$a, const char $\ast$b, const char $\ast$c)
\item 
int \hyperlink{group__str_gd15c9de561eed3870cee0d2993eb1085}{str\_\-copy4s} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$a, const char $\ast$b, const char $\ast$c, const char $\ast$d)
\item 
int \hyperlink{group__str_g4b05822e5ae0fee9491141c268ce2866}{str\_\-copy5s} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$a, const char $\ast$b, const char $\ast$c, const char $\ast$d, const char $\ast$e)
\item 
int \hyperlink{group__str_g16ed7543ffa368a468b00cc4b572e012}{str\_\-copy6s} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$a, const char $\ast$b, const char $\ast$c, const char $\ast$d, const char $\ast$e, const char $\ast$f)
\end{CompactItemize}
\subsection*{Appending Functions}
\begin{CompactItemize}
\item 
int \hyperlink{group__str_g6da816627202e243e6c3b3fdac1ff12d}{str\_\-cat} (\hyperlink{structstr}{str} $\ast$s, const \hyperlink{structstr}{str} $\ast$in)
\item 
int \hyperlink{group__str_g18e74bb0d26292957bf7737b2f497de2}{str\_\-cats} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$in)
\item 
int \hyperlink{group__str_gd684484056b8aa9e5937a7bd5fb1546a}{str\_\-catc} (\hyperlink{structstr}{str} $\ast$s, char in)
\item 
int \hyperlink{group__str_g7d1534a006941bdb22c4ce4b9b305cda}{str\_\-catb} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$in, unsigned len)
\item 
int \hyperlink{group__str_g1cf63dbdaa6703b26d8ce72e6901ffbe}{str\_\-catf} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$format,...)
\item 
int \hyperlink{group__str_g7e35e57a0e6189350eab468449770fd8}{str\_\-catfv} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$format, va\_\-list ap)
\item 
int \hyperlink{group__str_ge7813ee8c5777ac1933667492ae8a678}{str\_\-cati} (\hyperlink{structstr}{str} $\ast$s, long in)
\item 
int \hyperlink{group__str_g3143a40d753401322ef385b3fdbadb16}{str\_\-catiw} (\hyperlink{structstr}{str} $\ast$s, long in, unsigned width, char pad)
\item 
int \hyperlink{group__str_g7f65270d3b4b0fb5c12590094176bc9f}{str\_\-catu} (\hyperlink{structstr}{str} $\ast$s, unsigned long in)
\item 
int \hyperlink{group__str_gd640ad0f22f32ac02d6f9a5468288096}{str\_\-catuw} (\hyperlink{structstr}{str} $\ast$s, unsigned long in, unsigned width, char pad)
\item 
int \hyperlink{group__str_g18708cef8d28920a765ca52cb31384cd}{str\_\-catx} (\hyperlink{structstr}{str} $\ast$s, unsigned long in)
\item 
int \hyperlink{group__str_g046ba4fd6ae781e69c403ac8bdb8a4c0}{str\_\-catxw} (\hyperlink{structstr}{str} $\ast$s, unsigned long in, unsigned width, char pad)
\item 
int \hyperlink{group__str_gfd20d5489dd738b8eb92a50e229c9e6c}{str\_\-catill} (\hyperlink{structstr}{str} $\ast$s, long long in)
\item 
int \hyperlink{group__str_g656f6072b556cea1cc241e569147026e}{str\_\-catiwll} (\hyperlink{structstr}{str} $\ast$s, long long in, unsigned width, char pad)
\item 
int \hyperlink{group__str_g9225e94eba3cd097f75fffced7067309}{str\_\-catull} (\hyperlink{structstr}{str} $\ast$s, unsigned long long in)
\item 
int \hyperlink{group__str_g6d2d541e6d58bf6a66b4384d72e8c637}{str\_\-catuwll} (\hyperlink{structstr}{str} $\ast$s, unsigned long long in, unsigned width, char pad)
\item 
int \hyperlink{group__str_ge0b9b4c32606fee5347462764df26d58}{str\_\-catxll} (\hyperlink{structstr}{str} $\ast$s, unsigned long long in)
\item 
int \hyperlink{group__str_gc34f93772aa9ff884e08b1e9e9af252e}{str\_\-catxwll} (\hyperlink{structstr}{str} $\ast$s, unsigned long long in, unsigned width, char pad)
\item 
int \hyperlink{group__str_geb7177e96cecb7853ecdf9f5e3095304}{str\_\-catsnumw} (\hyperlink{structstr}{str} $\ast$s, long in, unsigned width, char pad, unsigned base, const char $\ast$digits)
\item 
int \hyperlink{group__str_g03abaeebd39c746d305aefd271a5ed67}{str\_\-catunumw} (\hyperlink{structstr}{str} $\ast$s, unsigned long in, unsigned width, char pad, unsigned base, const char $\ast$digits)
\item 
int \hyperlink{group__str_g1d1f106f84cda58651c02b89b1e44096}{str\_\-catsllnumw} (\hyperlink{structstr}{str} $\ast$s, long long in, unsigned width, char pad, unsigned base, const char $\ast$digits)
\item 
int \hyperlink{group__str_gc6568910addff1f7163b5755fcfd4386}{str\_\-catullnumw} (\hyperlink{structstr}{str} $\ast$s, unsigned long long in, unsigned width, char pad, unsigned base, const char $\ast$digits)
\item 
int \hyperlink{group__str_g67112113aa1d19fba4088a1fd7459be5}{str\_\-catns} (\hyperlink{structstr}{str} $\ast$s, unsigned int count,...)
\item 
int \hyperlink{group__str_gf0fddce8535bf2959969ff59e2fe99b4}{str\_\-cat2s} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$a, const char $\ast$b)
\item 
int \hyperlink{group__str_gb4790ea2df2856a08daac7d5277451b0}{str\_\-cat3s} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$a, const char $\ast$b, const char $\ast$c)
\item 
int \hyperlink{group__str_g9e13b2db85a12a2496dc2e55fdd93a08}{str\_\-cat4s} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$a, const char $\ast$b, const char $\ast$c, const char $\ast$d)
\item 
int \hyperlink{group__str_g513f21f2da4a0de972ce4ee7872ad19f}{str\_\-cat5s} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$a, const char $\ast$b, const char $\ast$c, const char $\ast$d, const char $\ast$e)
\item 
int \hyperlink{group__str_gcf819cd99a8b3676c65447447e62dcaa}{str\_\-cat6s} (\hyperlink{structstr}{str} $\ast$s, const char $\ast$a, const char $\ast$b, const char $\ast$c, const char $\ast$d, const char $\ast$e, const char $\ast$f)
\item 
int \hyperlink{group__str_gf76c4c5b41641d9437002d2b299d9580}{str\_\-join} (\hyperlink{structstr}{str} $\ast$s, char sep, const \hyperlink{structstr}{str} $\ast$t)
\item 
int \hyperlink{group__str_g2e8f8918d04489ad5deea5a2322f54b4}{str\_\-joins} (\hyperlink{structstr}{str} $\ast$s, char sep, const char $\ast$in)
\item 
int \hyperlink{group__str_gde075ea52e0a95ac5198b3cb44362f29}{str\_\-joinb} (\hyperlink{structstr}{str} $\ast$s, char sep, const char $\ast$in, unsigned len)
\end{CompactItemize}
\subsection*{Comparison Functions}
\begin{CompactItemize}
\item 
int \hyperlink{group__str_geb74139283badb56982c06173e3a9079}{str\_\-cmp} (const \hyperlink{structstr}{str} $\ast$a, unsigned aoffset, const \hyperlink{structstr}{str} $\ast$b, unsigned boffset)
\item 
int \hyperlink{group__str_g1491b9a90c43057bb3c67c59773214cb}{str\_\-cmps} (const \hyperlink{structstr}{str} $\ast$a, unsigned offset, const char $\ast$b)
\item 
int \hyperlink{group__str_g46acafcb25f47a15c621f04440f8dfd9}{str\_\-cmpb} (const \hyperlink{structstr}{str} $\ast$a, unsigned offset, const char $\ast$b, unsigned len)
\item 
int \hyperlink{group__str_g74a4a36ff6330ef20d06aef6ce435880}{str\_\-diff} (const \hyperlink{structstr}{str} $\ast$a, const \hyperlink{structstr}{str} $\ast$b)
\item 
int \hyperlink{group__str_g47e06bbe9f29fa4ef17c8ed8ce86a254}{str\_\-diffs} (const \hyperlink{structstr}{str} $\ast$a, const char $\ast$b)
\item 
int \hyperlink{group__str_g883a558554aff991f4605481553e95b5}{str\_\-diffb} (const \hyperlink{structstr}{str} $\ast$a, const char $\ast$b, unsigned len)
\item 
int \hyperlink{group__str_gcfb8337b4272957c4c69778aa638abb3}{str\_\-start} (const \hyperlink{structstr}{str} $\ast$a, const \hyperlink{structstr}{str} $\ast$b)
\item 
int \hyperlink{group__str_g30962ec2d9c3c344551d207f60ed1678}{str\_\-starts} (const \hyperlink{structstr}{str} $\ast$a, const char $\ast$b)
\item 
int \hyperlink{group__str_geee63556363e5c44a1f3b6316cc0ac65}{str\_\-startb} (const \hyperlink{structstr}{str} $\ast$a, const char $\ast$b, unsigned len)
\item 
int \hyperlink{group__str_g7a6b0a9d047f8a0e09c26e3e85cad7e5}{str\_\-case\_\-start} (const \hyperlink{structstr}{str} $\ast$a, const \hyperlink{structstr}{str} $\ast$b)
\item 
int \hyperlink{group__str_g8dd1e9b84f7196e52763003e066c447e}{str\_\-case\_\-starts} (const \hyperlink{structstr}{str} $\ast$a, const char $\ast$b)
\item 
int \hyperlink{group__str_g436a9c8d8bed864651729b8956289b2e}{str\_\-case\_\-startb} (const \hyperlink{structstr}{str} $\ast$a, const char $\ast$b, unsigned len)
\end{CompactItemize}
\subsection*{Pattern Matching Functions}
\begin{CompactItemize}
\item 
int \hyperlink{group__str_g4241fa2b3265e698c4f327ac878b5090}{str\_\-match} (const \hyperlink{structstr}{str} $\ast$s, const \hyperlink{structstr}{str} $\ast$pattern)
\item 
int \hyperlink{group__str_gd41f66c803aaaecccbd8f9e5e987d24f}{str\_\-matchb} (const \hyperlink{structstr}{str} $\ast$s, const char $\ast$pptr, unsigned plen)
\item 
int \hyperlink{group__str_g3c70c8b87d7a5bd64d8ac1d6da3e9165}{str\_\-matchs} (const \hyperlink{structstr}{str} $\ast$s, const char $\ast$pattern)
\item 
int \hyperlink{group__str_g1fd18484f9102d187a58f1091aa5bc61}{str\_\-case\_\-match} (const \hyperlink{structstr}{str} $\ast$s, const \hyperlink{structstr}{str} $\ast$pattern)
\item 
int \hyperlink{group__str_g8b1e8bad767b5a420c491d63a1695047}{str\_\-case\_\-matchb} (const \hyperlink{structstr}{str} $\ast$s, const char $\ast$pptr, unsigned plen)
\item 
int \hyperlink{group__str_g8250bc117392792ef3ae306a01f85594}{str\_\-case\_\-matchs} (const \hyperlink{structstr}{str} $\ast$s, const char $\ast$pattern)
\item 
\hypertarget{group__str_g3b4be3810f8daf7cc70746821b259099}{
int \textbf{str\_\-glob} (const \hyperlink{structstr}{str} $\ast$s, const \hyperlink{structstr}{str} $\ast$pattern)}
\label{group__str_g3b4be3810f8daf7cc70746821b259099}

\item 
\hypertarget{group__str_g19331678b1141ae60d39df94abf2db32}{
int \textbf{str\_\-globb} (const \hyperlink{structstr}{str} $\ast$s, const char $\ast$pptr, unsigned plen)}
\label{group__str_g19331678b1141ae60d39df94abf2db32}

\item 
\hypertarget{group__str_g853fcc01b7932506f5b27c1b30a00472}{
int \textbf{str\_\-globs} (const \hyperlink{structstr}{str} $\ast$s, const char $\ast$pattern)}
\label{group__str_g853fcc01b7932506f5b27c1b30a00472}

\item 
\hypertarget{group__str_g4b5f38a048003c512b546137ad26a310}{
int \textbf{str\_\-case\_\-glob} (const \hyperlink{structstr}{str} $\ast$s, const \hyperlink{structstr}{str} $\ast$pattern)}
\label{group__str_g4b5f38a048003c512b546137ad26a310}

\item 
\hypertarget{group__str_g83cd6e57aab22035b4bf568f07e295f4}{
int \textbf{str\_\-case\_\-globb} (const \hyperlink{structstr}{str} $\ast$s, const char $\ast$pptr, unsigned plen)}
\label{group__str_g83cd6e57aab22035b4bf568f07e295f4}

\item 
\hypertarget{group__str_g9259ff806cd84c922bb8658fda8a1308}{
int \textbf{str\_\-case\_\-globs} (const \hyperlink{structstr}{str} $\ast$s, const char $\ast$pattern)}
\label{group__str_g9259ff806cd84c922bb8658fda8a1308}

\end{CompactItemize}
\subsection*{Globals}
\begin{CompactItemize}
\item 
const char \hyperlink{group__str_gb17c3827c0b106c7103a9879751ea843}{str\_\-lcase\_\-digits} \mbox{[}36\mbox{]}
\item 
const char \hyperlink{group__str_g46d474d8d0f88e74ba454722af30ac08}{str\_\-ucase\_\-digits} \mbox{[}36\mbox{]}
\end{CompactItemize}
\subsection*{Defines}
\begin{CompactItemize}
\item 
\#define \hyperlink{group__str_gccab40639d169842336c62cf80d807d8}{STR\_\-BLOCKSIZE}~16
\end{CompactItemize}
\subsection*{Typedefs}
\begin{CompactItemize}
\item 
typedef \hyperlink{structstr}{str} \hyperlink{group__str_g07f60e1f2e898b38cc50a76452b31784}{str}
\item 
typedef \hyperlink{structstr__sortentry}{str\_\-sortentry} \hyperlink{group__str_g689b2adc03eb9a807c497b0b1e7abbb9}{str\_\-sortentry}
\end{CompactItemize}


\subsection{Detailed Description}
\begin{Desc}
\item[Calling Convention]The standard calling convention to {\tt str} functions is to pass the string being examined or modified as the first argument. For most functions, the return value will be {\tt 0} (false) if an error occurred (ie memory allocation failed) and non-zero (true) otherwise. \end{Desc}


\subsection{Define Documentation}
\hypertarget{group__str_gccab40639d169842336c62cf80d807d8}{
\index{str@{str}!STR_BLOCKSIZE@{STR\_\-BLOCKSIZE}}
\index{STR_BLOCKSIZE@{STR\_\-BLOCKSIZE}!str@{str}}
\subsubsection[STR\_\-BLOCKSIZE]{\setlength{\rightskip}{0pt plus 5cm}\#define STR\_\-BLOCKSIZE~16}}
\label{group__str_gccab40639d169842336c62cf80d807d8}


The block size in which string memory is allocated.

{\tt STR\_\-BLOCKSIZE} should be set to at least the size at which the allocator (ie {\tt malloc}) will align the data it returns. String data will be allocated in steps of this number. Values smaller than the alignment will only cause a small amount of space to be wasted, and will not trigger bugs. \hypertarget{group__str_g5130cf1a57c497bab66091fbdb9fd6d3}{
\index{str@{str}!str_ready@{str\_\-ready}}
\index{str_ready@{str\_\-ready}!str@{str}}
\subsubsection[str\_\-ready]{\setlength{\rightskip}{0pt plus 5cm}\#define str\_\-ready(S, SZ)~str\_\-alloc(S,SZ,0)}}
\label{group__str_g5130cf1a57c497bab66091fbdb9fd6d3}


Make sure string S has at least SZ bytes ready (no copy) \hypertarget{group__str_g05c5854c9d40dbe953625279b5deb5c7}{
\index{str@{str}!str_realloc@{str\_\-realloc}}
\index{str_realloc@{str\_\-realloc}!str@{str}}
\subsubsection[str\_\-realloc]{\setlength{\rightskip}{0pt plus 5cm}\#define str\_\-realloc(S, SZ)~str\_\-alloc(S,SZ,1)}}
\label{group__str_g05c5854c9d40dbe953625279b5deb5c7}


Reallocate string S to size SZ bytes, copying the existing string 

\subsection{Typedef Documentation}
\hypertarget{group__str_g07f60e1f2e898b38cc50a76452b31784}{
\index{str@{str}!str@{str}}
\index{str@{str}!str@{str}}
\subsubsection[str]{\setlength{\rightskip}{0pt plus 5cm}typedef struct \hyperlink{structstr}{str} \hyperlink{structstr}{str}}}
\label{group__str_g07f60e1f2e898b38cc50a76452b31784}


String structure typedef. \hypertarget{group__str_g689b2adc03eb9a807c497b0b1e7abbb9}{
\index{str@{str}!str_sortentry@{str\_\-sortentry}}
\index{str_sortentry@{str\_\-sortentry}!str@{str}}
\subsubsection[str\_\-sortentry]{\setlength{\rightskip}{0pt plus 5cm}typedef struct \hyperlink{structstr__sortentry}{str\_\-sortentry} \hyperlink{structstr__sortentry}{str\_\-sortentry}}}
\label{group__str_g689b2adc03eb9a807c497b0b1e7abbb9}


String sort entry typedef. 

\subsection{Function Documentation}
\hypertarget{group__str_gca368420555c886139b10d887df45941}{
\index{str@{str}!str_alloc@{str\_\-alloc}}
\index{str_alloc@{str\_\-alloc}!str@{str}}
\subsubsection[str\_\-alloc]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-alloc (\hyperlink{structstr}{str} $\ast$ {\em s}, unsigned {\em size}, int {\em copy})}}
\label{group__str_gca368420555c886139b10d887df45941}


Allocate storage for a string.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em s}]String to modify. \item[{\em size}]Minimum number of bytes for which to allocate. \item[{\em copy}]If set, the existing string will be copied into the new string.\end{description}
\end{Desc}
The size given is incremented to account for adding a trailing {\tt NUL} byte (to ensure compatibility with C string functions) and is then rounded up to the nearest {\tt STR\_\-BLOCKSIZE} interval. \hypertarget{group__str_g8eaf81912158733331aa9a8b8f92bd7c}{
\index{str@{str}!str_buildmap@{str\_\-buildmap}}
\index{str_buildmap@{str\_\-buildmap}!str@{str}}
\subsubsection[str\_\-buildmap]{\setlength{\rightskip}{0pt plus 5cm}void str\_\-buildmap (int {\em map}\mbox{[}256\mbox{]}, const char $\ast$ {\em list})}}
\label{group__str_g8eaf81912158733331aa9a8b8f92bd7c}


Build a map from the list of characters.

Each byte in the output map contains either {\tt -1} if the corresponding character was not present in the input string, or the offset of the last instance of the character in the list. \hypertarget{group__str_g1fd18484f9102d187a58f1091aa5bc61}{
\index{str@{str}!str_case_match@{str\_\-case\_\-match}}
\index{str_case_match@{str\_\-case\_\-match}!str@{str}}
\subsubsection[str\_\-case\_\-match]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-case\_\-match (const \hyperlink{structstr}{str} $\ast$ {\em s}, const \hyperlink{structstr}{str} $\ast$ {\em pattern})}}
\label{group__str_g1fd18484f9102d187a58f1091aa5bc61}


Simple pattern match on dynamic string pattern. \hypertarget{group__str_g8b1e8bad767b5a420c491d63a1695047}{
\index{str@{str}!str_case_matchb@{str\_\-case\_\-matchb}}
\index{str_case_matchb@{str\_\-case\_\-matchb}!str@{str}}
\subsubsection[str\_\-case\_\-matchb]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-case\_\-matchb (const \hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em pptr}, unsigned {\em plen})}}
\label{group__str_g8b1e8bad767b5a420c491d63a1695047}


Simple but fast (linear time) pattern matching on binary pattern. \hypertarget{group__str_g8250bc117392792ef3ae306a01f85594}{
\index{str@{str}!str_case_matchs@{str\_\-case\_\-matchs}}
\index{str_case_matchs@{str\_\-case\_\-matchs}!str@{str}}
\subsubsection[str\_\-case\_\-matchs]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-case\_\-matchs (const \hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em pattern})}}
\label{group__str_g8250bc117392792ef3ae306a01f85594}


Simple pattern match on C string pattern. \hypertarget{group__str_g7a6b0a9d047f8a0e09c26e3e85cad7e5}{
\index{str@{str}!str_case_start@{str\_\-case\_\-start}}
\index{str_case_start@{str\_\-case\_\-start}!str@{str}}
\subsubsection[str\_\-case\_\-start]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-case\_\-start (const \hyperlink{structstr}{str} $\ast$ {\em a}, const \hyperlink{structstr}{str} $\ast$ {\em b})}}
\label{group__str_g7a6b0a9d047f8a0e09c26e3e85cad7e5}


Match the prefix of the string to another string. \hypertarget{group__str_g436a9c8d8bed864651729b8956289b2e}{
\index{str@{str}!str_case_startb@{str\_\-case\_\-startb}}
\index{str_case_startb@{str\_\-case\_\-startb}!str@{str}}
\subsubsection[str\_\-case\_\-startb]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-case\_\-startb (const \hyperlink{structstr}{str} $\ast$ {\em a}, const char $\ast$ {\em b}, unsigned {\em len})}}
\label{group__str_g436a9c8d8bed864651729b8956289b2e}


Match the prefix of the string to a binary chunk. \hypertarget{group__str_g8dd1e9b84f7196e52763003e066c447e}{
\index{str@{str}!str_case_starts@{str\_\-case\_\-starts}}
\index{str_case_starts@{str\_\-case\_\-starts}!str@{str}}
\subsubsection[str\_\-case\_\-starts]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-case\_\-starts (const \hyperlink{structstr}{str} $\ast$ {\em a}, const char $\ast$ {\em b})}}
\label{group__str_g8dd1e9b84f7196e52763003e066c447e}


Match the prefix of the string to a C string. \hypertarget{group__str_g6da816627202e243e6c3b3fdac1ff12d}{
\index{str@{str}!str_cat@{str\_\-cat}}
\index{str_cat@{str\_\-cat}!str@{str}}
\subsubsection[str\_\-cat]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-cat (\hyperlink{structstr}{str} $\ast$ {\em s}, const \hyperlink{structstr}{str} $\ast$ {\em in})}}
\label{group__str_g6da816627202e243e6c3b3fdac1ff12d}


Append another string \hypertarget{group__str_gf0fddce8535bf2959969ff59e2fe99b4}{
\index{str@{str}!str_cat2s@{str\_\-cat2s}}
\index{str_cat2s@{str\_\-cat2s}!str@{str}}
\subsubsection[str\_\-cat2s]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-cat2s (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em a}, const char $\ast$ {\em b})}}
\label{group__str_gf0fddce8535bf2959969ff59e2fe99b4}


Append 2 C strings \hypertarget{group__str_gb4790ea2df2856a08daac7d5277451b0}{
\index{str@{str}!str_cat3s@{str\_\-cat3s}}
\index{str_cat3s@{str\_\-cat3s}!str@{str}}
\subsubsection[str\_\-cat3s]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-cat3s (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em a}, const char $\ast$ {\em b}, const char $\ast$ {\em c})}}
\label{group__str_gb4790ea2df2856a08daac7d5277451b0}


Append 3 C strings \hypertarget{group__str_g9e13b2db85a12a2496dc2e55fdd93a08}{
\index{str@{str}!str_cat4s@{str\_\-cat4s}}
\index{str_cat4s@{str\_\-cat4s}!str@{str}}
\subsubsection[str\_\-cat4s]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-cat4s (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em a}, const char $\ast$ {\em b}, const char $\ast$ {\em c}, const char $\ast$ {\em d})}}
\label{group__str_g9e13b2db85a12a2496dc2e55fdd93a08}


Append 4 C strings \hypertarget{group__str_g513f21f2da4a0de972ce4ee7872ad19f}{
\index{str@{str}!str_cat5s@{str\_\-cat5s}}
\index{str_cat5s@{str\_\-cat5s}!str@{str}}
\subsubsection[str\_\-cat5s]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-cat5s (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em a}, const char $\ast$ {\em b}, const char $\ast$ {\em c}, const char $\ast$ {\em d}, const char $\ast$ {\em e})}}
\label{group__str_g513f21f2da4a0de972ce4ee7872ad19f}


Append 5 C strings \hypertarget{group__str_gcf819cd99a8b3676c65447447e62dcaa}{
\index{str@{str}!str_cat6s@{str\_\-cat6s}}
\index{str_cat6s@{str\_\-cat6s}!str@{str}}
\subsubsection[str\_\-cat6s]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-cat6s (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em a}, const char $\ast$ {\em b}, const char $\ast$ {\em c}, const char $\ast$ {\em d}, const char $\ast$ {\em e}, const char $\ast$ {\em f})}}
\label{group__str_gcf819cd99a8b3676c65447447e62dcaa}


Append 6 C strings \hypertarget{group__str_g7d1534a006941bdb22c4ce4b9b305cda}{
\index{str@{str}!str_catb@{str\_\-catb}}
\index{str_catb@{str\_\-catb}!str@{str}}
\subsubsection[str\_\-catb]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catb (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em in}, unsigned {\em len})}}
\label{group__str_g7d1534a006941bdb22c4ce4b9b305cda}


Append a binary block \hypertarget{group__str_gd684484056b8aa9e5937a7bd5fb1546a}{
\index{str@{str}!str_catc@{str\_\-catc}}
\index{str_catc@{str\_\-catc}!str@{str}}
\subsubsection[str\_\-catc]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catc (\hyperlink{structstr}{str} $\ast$ {\em s}, char {\em in})}}
\label{group__str_gd684484056b8aa9e5937a7bd5fb1546a}


Append a single character \hypertarget{group__str_g1cf63dbdaa6703b26d8ce72e6901ffbe}{
\index{str@{str}!str_catf@{str\_\-catf}}
\index{str_catf@{str\_\-catf}!str@{str}}
\subsubsection[str\_\-catf]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catf (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em format},  {\em ...})}}
\label{group__str_g1cf63dbdaa6703b26d8ce72e6901ffbe}


Append formatted data using {\tt fmt\_\-multi} from variable arguments \hypertarget{group__str_g7e35e57a0e6189350eab468449770fd8}{
\index{str@{str}!str_catfv@{str\_\-catfv}}
\index{str_catfv@{str\_\-catfv}!str@{str}}
\subsubsection[str\_\-catfv]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catfv (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em format}, va\_\-list {\em ap})}}
\label{group__str_g7e35e57a0e6189350eab468449770fd8}


Append formatted data using {\tt fmt\_\-multi} from a {\tt va\_\-list} \hypertarget{group__str_ge7813ee8c5777ac1933667492ae8a678}{
\index{str@{str}!str_cati@{str\_\-cati}}
\index{str_cati@{str\_\-cati}!str@{str}}
\subsubsection[str\_\-cati]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-cati (\hyperlink{structstr}{str} $\ast$ {\em s}, long {\em in})}}
\label{group__str_ge7813ee8c5777ac1933667492ae8a678}


Append a signed integer in decimal. \hypertarget{group__str_gfd20d5489dd738b8eb92a50e229c9e6c}{
\index{str@{str}!str_catill@{str\_\-catill}}
\index{str_catill@{str\_\-catill}!str@{str}}
\subsubsection[str\_\-catill]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catill (\hyperlink{structstr}{str} $\ast$ {\em s}, long long {\em in})}}
\label{group__str_gfd20d5489dd738b8eb92a50e229c9e6c}


Append a signed long long integer in decimal. \hypertarget{group__str_g3143a40d753401322ef385b3fdbadb16}{
\index{str@{str}!str_catiw@{str\_\-catiw}}
\index{str_catiw@{str\_\-catiw}!str@{str}}
\subsubsection[str\_\-catiw]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catiw (\hyperlink{structstr}{str} $\ast$ {\em s}, long {\em in}, unsigned {\em width}, char {\em pad})}}
\label{group__str_g3143a40d753401322ef385b3fdbadb16}


Append a signed integer in decimal, padded to a minimum width. \hypertarget{group__str_g656f6072b556cea1cc241e569147026e}{
\index{str@{str}!str_catiwll@{str\_\-catiwll}}
\index{str_catiwll@{str\_\-catiwll}!str@{str}}
\subsubsection[str\_\-catiwll]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catiwll (\hyperlink{structstr}{str} $\ast$ {\em s}, long long {\em in}, unsigned {\em width}, char {\em pad})}}
\label{group__str_g656f6072b556cea1cc241e569147026e}


Append a signed long long integer in decimal, padded to a minimum width. \hypertarget{group__str_g67112113aa1d19fba4088a1fd7459be5}{
\index{str@{str}!str_catns@{str\_\-catns}}
\index{str_catns@{str\_\-catns}!str@{str}}
\subsubsection[str\_\-catns]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catns (\hyperlink{structstr}{str} $\ast$ {\em s}, unsigned int {\em count},  {\em ...})}}
\label{group__str_g67112113aa1d19fba4088a1fd7459be5}


Append N C strings \hypertarget{group__str_g18e74bb0d26292957bf7737b2f497de2}{
\index{str@{str}!str_cats@{str\_\-cats}}
\index{str_cats@{str\_\-cats}!str@{str}}
\subsubsection[str\_\-cats]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-cats (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em in})}}
\label{group__str_g18e74bb0d26292957bf7737b2f497de2}


Append a C string \hypertarget{group__str_g1d1f106f84cda58651c02b89b1e44096}{
\index{str@{str}!str_catsllnumw@{str\_\-catsllnumw}}
\index{str_catsllnumw@{str\_\-catsllnumw}!str@{str}}
\subsubsection[str\_\-catsllnumw]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catsllnumw (\hyperlink{structstr}{str} $\ast$ {\em s}, long long {\em in}, unsigned {\em width}, char {\em pad}, unsigned {\em base}, const char $\ast$ {\em digits})}}
\label{group__str_g1d1f106f84cda58651c02b89b1e44096}


Append a signed long long integer, optionally padded to a minimum width \hypertarget{group__str_geb7177e96cecb7853ecdf9f5e3095304}{
\index{str@{str}!str_catsnumw@{str\_\-catsnumw}}
\index{str_catsnumw@{str\_\-catsnumw}!str@{str}}
\subsubsection[str\_\-catsnumw]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catsnumw (\hyperlink{structstr}{str} $\ast$ {\em s}, long {\em in}, unsigned {\em width}, char {\em pad}, unsigned {\em base}, const char $\ast$ {\em digits})}}
\label{group__str_geb7177e96cecb7853ecdf9f5e3095304}


Append a signed integer, optionally padded to a minimum width \hypertarget{group__str_g7f65270d3b4b0fb5c12590094176bc9f}{
\index{str@{str}!str_catu@{str\_\-catu}}
\index{str_catu@{str\_\-catu}!str@{str}}
\subsubsection[str\_\-catu]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catu (\hyperlink{structstr}{str} $\ast$ {\em s}, unsigned long {\em in})}}
\label{group__str_g7f65270d3b4b0fb5c12590094176bc9f}


Append an unsigned integer in decimal, padded to a minimum width. \hypertarget{group__str_g9225e94eba3cd097f75fffced7067309}{
\index{str@{str}!str_catull@{str\_\-catull}}
\index{str_catull@{str\_\-catull}!str@{str}}
\subsubsection[str\_\-catull]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catull (\hyperlink{structstr}{str} $\ast$ {\em s}, unsigned long long {\em in})}}
\label{group__str_g9225e94eba3cd097f75fffced7067309}


Append an unsigned long long integer in decimal. \hypertarget{group__str_gc6568910addff1f7163b5755fcfd4386}{
\index{str@{str}!str_catullnumw@{str\_\-catullnumw}}
\index{str_catullnumw@{str\_\-catullnumw}!str@{str}}
\subsubsection[str\_\-catullnumw]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catullnumw (\hyperlink{structstr}{str} $\ast$ {\em s}, unsigned long long {\em in}, unsigned {\em width}, char {\em pad}, unsigned {\em base}, const char $\ast$ {\em digits})}}
\label{group__str_gc6568910addff1f7163b5755fcfd4386}


Append an unsigned long long integer, optionally padded to a minimum width \hypertarget{group__str_g03abaeebd39c746d305aefd271a5ed67}{
\index{str@{str}!str_catunumw@{str\_\-catunumw}}
\index{str_catunumw@{str\_\-catunumw}!str@{str}}
\subsubsection[str\_\-catunumw]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catunumw (\hyperlink{structstr}{str} $\ast$ {\em s}, unsigned long {\em in}, unsigned {\em width}, char {\em pad}, unsigned {\em base}, const char $\ast$ {\em digits})}}
\label{group__str_g03abaeebd39c746d305aefd271a5ed67}


Append an unsigned integer, optionally padded to a minimum width \hypertarget{group__str_gd640ad0f22f32ac02d6f9a5468288096}{
\index{str@{str}!str_catuw@{str\_\-catuw}}
\index{str_catuw@{str\_\-catuw}!str@{str}}
\subsubsection[str\_\-catuw]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catuw (\hyperlink{structstr}{str} $\ast$ {\em s}, unsigned long {\em in}, unsigned {\em width}, char {\em pad})}}
\label{group__str_gd640ad0f22f32ac02d6f9a5468288096}


Append an unsigned integer in decimal. \hypertarget{group__str_g6d2d541e6d58bf6a66b4384d72e8c637}{
\index{str@{str}!str_catuwll@{str\_\-catuwll}}
\index{str_catuwll@{str\_\-catuwll}!str@{str}}
\subsubsection[str\_\-catuwll]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catuwll (\hyperlink{structstr}{str} $\ast$ {\em s}, unsigned long long {\em in}, unsigned {\em width}, char {\em pad})}}
\label{group__str_g6d2d541e6d58bf6a66b4384d72e8c637}


Append an unsigned long long integer in decimal, padded to a minimum width. \hypertarget{group__str_g18708cef8d28920a765ca52cb31384cd}{
\index{str@{str}!str_catx@{str\_\-catx}}
\index{str_catx@{str\_\-catx}!str@{str}}
\subsubsection[str\_\-catx]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catx (\hyperlink{structstr}{str} $\ast$ {\em s}, unsigned long {\em in})}}
\label{group__str_g18708cef8d28920a765ca52cb31384cd}


Append an unsigned integer in hexadecimal, padded to a minimum width. \hypertarget{group__str_ge0b9b4c32606fee5347462764df26d58}{
\index{str@{str}!str_catxll@{str\_\-catxll}}
\index{str_catxll@{str\_\-catxll}!str@{str}}
\subsubsection[str\_\-catxll]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catxll (\hyperlink{structstr}{str} $\ast$ {\em s}, unsigned long long {\em in})}}
\label{group__str_ge0b9b4c32606fee5347462764df26d58}


Append an unsigned long long integer in hexadecimal. \hypertarget{group__str_g046ba4fd6ae781e69c403ac8bdb8a4c0}{
\index{str@{str}!str_catxw@{str\_\-catxw}}
\index{str_catxw@{str\_\-catxw}!str@{str}}
\subsubsection[str\_\-catxw]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catxw (\hyperlink{structstr}{str} $\ast$ {\em s}, unsigned long {\em in}, unsigned {\em width}, char {\em pad})}}
\label{group__str_g046ba4fd6ae781e69c403ac8bdb8a4c0}


Append an unsigned integer in hexadecimal. \hypertarget{group__str_gc34f93772aa9ff884e08b1e9e9af252e}{
\index{str@{str}!str_catxwll@{str\_\-catxwll}}
\index{str_catxwll@{str\_\-catxwll}!str@{str}}
\subsubsection[str\_\-catxwll]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-catxwll (\hyperlink{structstr}{str} $\ast$ {\em s}, unsigned long long {\em in}, unsigned {\em width}, char {\em pad})}}
\label{group__str_gc34f93772aa9ff884e08b1e9e9af252e}


Append an unsigned long long integer in hexadecimal, padded to a minimum width. \hypertarget{group__str_geb74139283badb56982c06173e3a9079}{
\index{str@{str}!str_cmp@{str\_\-cmp}}
\index{str_cmp@{str\_\-cmp}!str@{str}}
\subsubsection[str\_\-cmp]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-cmp (const \hyperlink{structstr}{str} $\ast$ {\em a}, unsigned {\em aoffset}, const \hyperlink{structstr}{str} $\ast$ {\em b}, unsigned {\em boffset})}}
\label{group__str_geb74139283badb56982c06173e3a9079}


Compare part of two strings.

This function compares two strings, starting at {\tt aoffset} bytes into {\tt a} and {\tt boffset} bytes into {\tt b}. The first non-zero difference is returned. If the portion of {\tt b} is longer than the portion of {\tt a}, the result is positive. \hypertarget{group__str_g46acafcb25f47a15c621f04440f8dfd9}{
\index{str@{str}!str_cmpb@{str\_\-cmpb}}
\index{str_cmpb@{str\_\-cmpb}!str@{str}}
\subsubsection[str\_\-cmpb]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-cmpb (const \hyperlink{structstr}{str} $\ast$ {\em a}, unsigned {\em offset}, const char $\ast$ {\em b}, unsigned {\em len})}}
\label{group__str_g46acafcb25f47a15c621f04440f8dfd9}


Compare a string against a binary block. \hypertarget{group__str_g1491b9a90c43057bb3c67c59773214cb}{
\index{str@{str}!str_cmps@{str\_\-cmps}}
\index{str_cmps@{str\_\-cmps}!str@{str}}
\subsubsection[str\_\-cmps]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-cmps (const \hyperlink{structstr}{str} $\ast$ {\em a}, unsigned {\em offset}, const char $\ast$ {\em b})}}
\label{group__str_g1491b9a90c43057bb3c67c59773214cb}


Compare a string against a C string. \hypertarget{group__str_g9156aedd17aac54cd238c8caa6dc6e85}{
\index{str@{str}!str_copy@{str\_\-copy}}
\index{str_copy@{str\_\-copy}!str@{str}}
\subsubsection[str\_\-copy]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-copy (\hyperlink{structstr}{str} $\ast$ {\em s}, const \hyperlink{structstr}{str} $\ast$ {\em in})}}
\label{group__str_g9156aedd17aac54cd238c8caa6dc6e85}


Copy in a string \hypertarget{group__str_g0883eb2957281e989efab5d1591c6e94}{
\index{str@{str}!str_copy2s@{str\_\-copy2s}}
\index{str_copy2s@{str\_\-copy2s}!str@{str}}
\subsubsection[str\_\-copy2s]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-copy2s (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em a}, const char $\ast$ {\em b})}}
\label{group__str_g0883eb2957281e989efab5d1591c6e94}


Copy in the concatenation of 2 C strings \hypertarget{group__str_g59d4d0111c25f28598949d4fa3ccb277}{
\index{str@{str}!str_copy3s@{str\_\-copy3s}}
\index{str_copy3s@{str\_\-copy3s}!str@{str}}
\subsubsection[str\_\-copy3s]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-copy3s (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em a}, const char $\ast$ {\em b}, const char $\ast$ {\em c})}}
\label{group__str_g59d4d0111c25f28598949d4fa3ccb277}


Copy in the concatenation of 3 C strings \hypertarget{group__str_gd15c9de561eed3870cee0d2993eb1085}{
\index{str@{str}!str_copy4s@{str\_\-copy4s}}
\index{str_copy4s@{str\_\-copy4s}!str@{str}}
\subsubsection[str\_\-copy4s]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-copy4s (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em a}, const char $\ast$ {\em b}, const char $\ast$ {\em c}, const char $\ast$ {\em d})}}
\label{group__str_gd15c9de561eed3870cee0d2993eb1085}


Copy in the concatenation of 4 C strings \hypertarget{group__str_g4b05822e5ae0fee9491141c268ce2866}{
\index{str@{str}!str_copy5s@{str\_\-copy5s}}
\index{str_copy5s@{str\_\-copy5s}!str@{str}}
\subsubsection[str\_\-copy5s]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-copy5s (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em a}, const char $\ast$ {\em b}, const char $\ast$ {\em c}, const char $\ast$ {\em d}, const char $\ast$ {\em e})}}
\label{group__str_g4b05822e5ae0fee9491141c268ce2866}


Copy in the concatenation of 5 C strings \hypertarget{group__str_g16ed7543ffa368a468b00cc4b572e012}{
\index{str@{str}!str_copy6s@{str\_\-copy6s}}
\index{str_copy6s@{str\_\-copy6s}!str@{str}}
\subsubsection[str\_\-copy6s]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-copy6s (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em a}, const char $\ast$ {\em b}, const char $\ast$ {\em c}, const char $\ast$ {\em d}, const char $\ast$ {\em e}, const char $\ast$ {\em f})}}
\label{group__str_g16ed7543ffa368a468b00cc4b572e012}


Copy in the concatenation of 6 C strings \hypertarget{group__str_g26880681d1ed8fd1a80ccd4e39ce6e61}{
\index{str@{str}!str_copyb@{str\_\-copyb}}
\index{str_copyb@{str\_\-copyb}!str@{str}}
\subsubsection[str\_\-copyb]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-copyb (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em in}, unsigned {\em len})}}
\label{group__str_g26880681d1ed8fd1a80ccd4e39ce6e61}


Copy in a binary block \hypertarget{group__str_ga48f044aa7889f07df12b69a9f9dc081}{
\index{str@{str}!str_copyf@{str\_\-copyf}}
\index{str_copyf@{str\_\-copyf}!str@{str}}
\subsubsection[str\_\-copyf]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-copyf (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em format},  {\em ...})}}
\label{group__str_ga48f044aa7889f07df12b69a9f9dc081}


Copy formatted data using {\tt fmt\_\-multi} from variable arguments \hypertarget{group__str_g6782b26e389f10eaf3ea8a3cb1fe7390}{
\index{str@{str}!str_copyfv@{str\_\-copyfv}}
\index{str_copyfv@{str\_\-copyfv}!str@{str}}
\subsubsection[str\_\-copyfv]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-copyfv (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em format}, va\_\-list {\em ap})}}
\label{group__str_g6782b26e389f10eaf3ea8a3cb1fe7390}


Copy formatted data using {\tt fmt\_\-multi} from a {\tt va\_\-list} \hypertarget{group__str_g27fcdd2e902c5efac54fce1c2c9f4319}{
\index{str@{str}!str_copyns@{str\_\-copyns}}
\index{str_copyns@{str\_\-copyns}!str@{str}}
\subsubsection[str\_\-copyns]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-copyns (\hyperlink{structstr}{str} $\ast$ {\em s}, unsigned int {\em count},  {\em ...})}}
\label{group__str_g27fcdd2e902c5efac54fce1c2c9f4319}


Copy in the concatenation of N C strings \hypertarget{group__str_g100c559e82996e86f9bb9472c0ce9331}{
\index{str@{str}!str_copys@{str\_\-copys}}
\index{str_copys@{str\_\-copys}!str@{str}}
\subsubsection[str\_\-copys]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-copys (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em in})}}
\label{group__str_g100c559e82996e86f9bb9472c0ce9331}


Copy in a C string \hypertarget{group__str_g54f4ff27f4a2ee0eb842a44b1b16b600}{
\index{str@{str}!str_count@{str\_\-count}}
\index{str_count@{str\_\-count}!str@{str}}
\subsubsection[str\_\-count]{\setlength{\rightskip}{0pt plus 5cm}unsigned str\_\-count (const \hyperlink{structstr}{str} $\ast$ {\em s}, char {\em ch})}}
\label{group__str_g54f4ff27f4a2ee0eb842a44b1b16b600}


Count the number of instances of a character \hypertarget{group__str_g3ce731047986d72c5514d83876d259f4}{
\index{str@{str}!str_countof@{str\_\-countof}}
\index{str_countof@{str\_\-countof}!str@{str}}
\subsubsection[str\_\-countof]{\setlength{\rightskip}{0pt plus 5cm}unsigned str\_\-countof (const \hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em list})}}
\label{group__str_g3ce731047986d72c5514d83876d259f4}


Count the number of instances of a list of characters \hypertarget{group__str_g74a4a36ff6330ef20d06aef6ce435880}{
\index{str@{str}!str_diff@{str\_\-diff}}
\index{str_diff@{str\_\-diff}!str@{str}}
\subsubsection[str\_\-diff]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-diff (const \hyperlink{structstr}{str} $\ast$ {\em a}, const \hyperlink{structstr}{str} $\ast$ {\em b})}}
\label{group__str_g74a4a36ff6330ef20d06aef6ce435880}


Differentiate two strings.

The first non-zero difference between {\tt a} and {\tt b} is returned. If {\tt a} is longer than {\tt b} and no differences are found up to the length of {\tt b}, then the return value is positive. If {\tt b} is longer than {\tt a} and no differences are found up to the length of {\tt a}, then the return value is negative. \hypertarget{group__str_g883a558554aff991f4605481553e95b5}{
\index{str@{str}!str_diffb@{str\_\-diffb}}
\index{str_diffb@{str\_\-diffb}!str@{str}}
\subsubsection[str\_\-diffb]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-diffb (const \hyperlink{structstr}{str} $\ast$ {\em a}, const char $\ast$ {\em b}, unsigned {\em len})}}
\label{group__str_g883a558554aff991f4605481553e95b5}


Differentiate a string and a binary block. \hypertarget{group__str_g47e06bbe9f29fa4ef17c8ed8ce86a254}{
\index{str@{str}!str_diffs@{str\_\-diffs}}
\index{str_diffs@{str\_\-diffs}!str@{str}}
\subsubsection[str\_\-diffs]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-diffs (const \hyperlink{structstr}{str} $\ast$ {\em a}, const char $\ast$ {\em b})}}
\label{group__str_g47e06bbe9f29fa4ef17c8ed8ce86a254}


Differentiate a string and a C string. \hypertarget{group__str_g192b55272495861b19f9928a2e677717}{
\index{str@{str}!str_findnext@{str\_\-findnext}}
\index{str_findnext@{str\_\-findnext}!str@{str}}
\subsubsection[str\_\-findnext]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-findnext (const \hyperlink{structstr}{str} $\ast$ {\em s}, char {\em ch}, unsigned {\em pos})}}
\label{group__str_g192b55272495861b19f9928a2e677717}


Find the next instance of the given character, on or after {\tt pos} \hypertarget{group__str_g1fd2973086658d66dc34a27b45b43286}{
\index{str@{str}!str_findnextnot@{str\_\-findnextnot}}
\index{str_findnextnot@{str\_\-findnextnot}!str@{str}}
\subsubsection[str\_\-findnextnot]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-findnextnot (const \hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em list}, unsigned {\em pos})}}
\label{group__str_g1fd2973086658d66dc34a27b45b43286}


Find the next instance of a character not in the given list of characters, on or after {\tt pos} \hypertarget{group__str_g00a17536de20c68dd23fa8e872f8a713}{
\index{str@{str}!str_findnextof@{str\_\-findnextof}}
\index{str_findnextof@{str\_\-findnextof}!str@{str}}
\subsubsection[str\_\-findnextof]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-findnextof (const \hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em list}, unsigned {\em pos})}}
\label{group__str_g00a17536de20c68dd23fa8e872f8a713}


Find the next instance of the given list of characters, on or after {\tt pos} \hypertarget{group__str_gd132f32bf7d02f19f86aca10a0c5f1cc}{
\index{str@{str}!str_findprev@{str\_\-findprev}}
\index{str_findprev@{str\_\-findprev}!str@{str}}
\subsubsection[str\_\-findprev]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-findprev (const \hyperlink{structstr}{str} $\ast$ {\em s}, char {\em ch}, unsigned {\em pos})}}
\label{group__str_gd132f32bf7d02f19f86aca10a0c5f1cc}


Find the previous instance of the given character on or before {\tt pos} \hypertarget{group__str_g58db78418ff61c2b7b7e11f7021c9726}{
\index{str@{str}!str_findprevnot@{str\_\-findprevnot}}
\index{str_findprevnot@{str\_\-findprevnot}!str@{str}}
\subsubsection[str\_\-findprevnot]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-findprevnot (const \hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em list}, unsigned {\em pos})}}
\label{group__str_g58db78418ff61c2b7b7e11f7021c9726}


Find the previous instance of a character not in the given list of characters, on or before {\tt pos} \hypertarget{group__str_g34f902a8bd040b4d44802c7f5f2ca24a}{
\index{str@{str}!str_findprevof@{str\_\-findprevof}}
\index{str_findprevof@{str\_\-findprevof}!str@{str}}
\subsubsection[str\_\-findprevof]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-findprevof (const \hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em list}, unsigned {\em pos})}}
\label{group__str_g34f902a8bd040b4d44802c7f5f2ca24a}


Find the previous instance of the given list of characters, on or before {\tt pos} \hypertarget{group__str_ga45f56943ecb5e8705e041ff6b70df95}{
\index{str@{str}!str_free@{str\_\-free}}
\index{str_free@{str\_\-free}!str@{str}}
\subsubsection[str\_\-free]{\setlength{\rightskip}{0pt plus 5cm}void str\_\-free (\hyperlink{structstr}{str} $\ast$ {\em s})}}
\label{group__str_ga45f56943ecb5e8705e041ff6b70df95}


Free a string's storage. This function also sets all the members of the structure to zero. \hypertarget{group__str_g49aec9c56d91c2a8a18bf4677b5e8a5b}{
\index{str@{str}!str_init@{str\_\-init}}
\index{str_init@{str\_\-init}!str@{str}}
\subsubsection[str\_\-init]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-init (\hyperlink{structstr}{str} $\ast$ {\em s})}}
\label{group__str_g49aec9c56d91c2a8a18bf4677b5e8a5b}


Initialize a string, giving it a small empty allocation. \hypertarget{group__str_gf76c4c5b41641d9437002d2b299d9580}{
\index{str@{str}!str_join@{str\_\-join}}
\index{str_join@{str\_\-join}!str@{str}}
\subsubsection[str\_\-join]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-join (\hyperlink{structstr}{str} $\ast$ {\em s}, char {\em sep}, const \hyperlink{structstr}{str} $\ast$ {\em in})}}
\label{group__str_gf76c4c5b41641d9437002d2b299d9580}


Join two strings together with exactly one instance of the seperator. \hypertarget{group__str_gde075ea52e0a95ac5198b3cb44362f29}{
\index{str@{str}!str_joinb@{str\_\-joinb}}
\index{str_joinb@{str\_\-joinb}!str@{str}}
\subsubsection[str\_\-joinb]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-joinb (\hyperlink{structstr}{str} $\ast$ {\em s}, char {\em sep}, const char $\ast$ {\em in}, unsigned {\em len})}}
\label{group__str_gde075ea52e0a95ac5198b3cb44362f29}


Join a binary block to this string \hypertarget{group__str_g2e8f8918d04489ad5deea5a2322f54b4}{
\index{str@{str}!str_joins@{str\_\-joins}}
\index{str_joins@{str\_\-joins}!str@{str}}
\subsubsection[str\_\-joins]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-joins (\hyperlink{structstr}{str} $\ast$ {\em s}, char {\em sep}, const char $\ast$ {\em in})}}
\label{group__str_g2e8f8918d04489ad5deea5a2322f54b4}


Join a C string to this string \hypertarget{group__str_g369b7dda6ed587477dde663240cf175f}{
\index{str@{str}!str_lcut@{str\_\-lcut}}
\index{str_lcut@{str\_\-lcut}!str@{str}}
\subsubsection[str\_\-lcut]{\setlength{\rightskip}{0pt plus 5cm}void str\_\-lcut (\hyperlink{structstr}{str} $\ast$ {\em s}, unsigned {\em count})}}
\label{group__str_g369b7dda6ed587477dde663240cf175f}


Cut {\tt count} bytes from the left (front) of the string \hypertarget{group__str_gb338bac7017bdd4759f6a876fa3c1b36}{
\index{str@{str}!str_lower@{str\_\-lower}}
\index{str_lower@{str\_\-lower}!str@{str}}
\subsubsection[str\_\-lower]{\setlength{\rightskip}{0pt plus 5cm}void str\_\-lower (\hyperlink{structstr}{str} $\ast$ {\em s})}}
\label{group__str_gb338bac7017bdd4759f6a876fa3c1b36}


Translate all upper-case characters to lower-case \hypertarget{group__str_g97329d0205007c89bf197446f30c75de}{
\index{str@{str}!str_lstrip@{str\_\-lstrip}}
\index{str_lstrip@{str\_\-lstrip}!str@{str}}
\subsubsection[str\_\-lstrip]{\setlength{\rightskip}{0pt plus 5cm}void str\_\-lstrip (\hyperlink{structstr}{str} $\ast$ {\em s})}}
\label{group__str_g97329d0205007c89bf197446f30c75de}


Strip all white space from the left (front) of the string \hypertarget{group__str_g4241fa2b3265e698c4f327ac878b5090}{
\index{str@{str}!str_match@{str\_\-match}}
\index{str_match@{str\_\-match}!str@{str}}
\subsubsection[str\_\-match]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-match (const \hyperlink{structstr}{str} $\ast$ {\em s}, const \hyperlink{structstr}{str} $\ast$ {\em pattern})}}
\label{group__str_g4241fa2b3265e698c4f327ac878b5090}


Simple pattern match on dynamic string pattern. \hypertarget{group__str_gd41f66c803aaaecccbd8f9e5e987d24f}{
\index{str@{str}!str_matchb@{str\_\-matchb}}
\index{str_matchb@{str\_\-matchb}!str@{str}}
\subsubsection[str\_\-matchb]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-matchb (const \hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em pptr}, unsigned {\em plen})}}
\label{group__str_gd41f66c803aaaecccbd8f9e5e987d24f}


Simple but fast (linear time) pattern matching on binary pattern. \hypertarget{group__str_g3c70c8b87d7a5bd64d8ac1d6da3e9165}{
\index{str@{str}!str_matchs@{str\_\-matchs}}
\index{str_matchs@{str\_\-matchs}!str@{str}}
\subsubsection[str\_\-matchs]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-matchs (const \hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em pattern})}}
\label{group__str_g3c70c8b87d7a5bd64d8ac1d6da3e9165}


Simple pattern match on C string pattern. \hypertarget{group__str_gb12e6ee45d534e52ef16f4d3f0d54390}{
\index{str@{str}!str_rcut@{str\_\-rcut}}
\index{str_rcut@{str\_\-rcut}!str@{str}}
\subsubsection[str\_\-rcut]{\setlength{\rightskip}{0pt plus 5cm}void str\_\-rcut (\hyperlink{structstr}{str} $\ast$ {\em s}, unsigned {\em count})}}
\label{group__str_gb12e6ee45d534e52ef16f4d3f0d54390}


Cut {\tt count} bytes from the right (end) of the string \hypertarget{group__str_g095c8adc8d7a7279e8c71746a5974ee6}{
\index{str@{str}!str_rstrip@{str\_\-rstrip}}
\index{str_rstrip@{str\_\-rstrip}!str@{str}}
\subsubsection[str\_\-rstrip]{\setlength{\rightskip}{0pt plus 5cm}void str\_\-rstrip (\hyperlink{structstr}{str} $\ast$ {\em s})}}
\label{group__str_g095c8adc8d7a7279e8c71746a5974ee6}


Strip all white space from the right (end) of the string \hypertarget{group__str_g1185bbfed7209ff269342cea523de7dd}{
\index{str@{str}!str_sort@{str\_\-sort}}
\index{str_sort@{str\_\-sort}!str@{str}}
\subsubsection[str\_\-sort]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-sort (\hyperlink{structstr}{str} $\ast$ {\em s}, char {\em sep}, long {\em count}, int($\ast$)(const \hyperlink{structstr__sortentry}{str\_\-sortentry} $\ast$a, const \hyperlink{structstr__sortentry}{str\_\-sortentry} $\ast$b) {\em fn})}}
\label{group__str_g1185bbfed7209ff269342cea523de7dd}


Sort a string.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em s}]The string to sort. \item[{\em sep}]The character which delimits the substrings. \item[{\em count}]The number of substrings within {\tt s} (set to {\tt -1} if not known). \item[{\em fn}]The comparison function. Defaults to a function that works like {\tt memcmp}.\end{description}
\end{Desc}
\begin{Desc}
\item[Note:]This function allocates a temporary array of substring pointers, and so may return {\tt 0} if memory allocation fails. The string itself is not reallocated. \end{Desc}
\hypertarget{group__str_gcfb8337b4272957c4c69778aa638abb3}{
\index{str@{str}!str_start@{str\_\-start}}
\index{str_start@{str\_\-start}!str@{str}}
\subsubsection[str\_\-start]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-start (const \hyperlink{structstr}{str} $\ast$ {\em a}, const \hyperlink{structstr}{str} $\ast$ {\em b})}}
\label{group__str_gcfb8337b4272957c4c69778aa638abb3}


Match the prefix of the string to another string. \hypertarget{group__str_geee63556363e5c44a1f3b6316cc0ac65}{
\index{str@{str}!str_startb@{str\_\-startb}}
\index{str_startb@{str\_\-startb}!str@{str}}
\subsubsection[str\_\-startb]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-startb (const \hyperlink{structstr}{str} $\ast$ {\em a}, const char $\ast$ {\em b}, unsigned {\em len})}}
\label{group__str_geee63556363e5c44a1f3b6316cc0ac65}


Match the prefix of the string to a binary chunk. \hypertarget{group__str_g30962ec2d9c3c344551d207f60ed1678}{
\index{str@{str}!str_starts@{str\_\-starts}}
\index{str_starts@{str\_\-starts}!str@{str}}
\subsubsection[str\_\-starts]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-starts (const \hyperlink{structstr}{str} $\ast$ {\em a}, const char $\ast$ {\em b})}}
\label{group__str_g30962ec2d9c3c344551d207f60ed1678}


Match the prefix of the string to a C string. \hypertarget{group__str_g7aa699416198667b7b2198591ee1811f}{
\index{str@{str}!str_subst@{str\_\-subst}}
\index{str_subst@{str\_\-subst}!str@{str}}
\subsubsection[str\_\-subst]{\setlength{\rightskip}{0pt plus 5cm}long str\_\-subst (\hyperlink{structstr}{str} $\ast$ {\em s}, char {\em from}, char {\em to})}}
\label{group__str_g7aa699416198667b7b2198591ee1811f}


Substitute one character for another throughout the string. \begin{Desc}
\item[Returns:]the number of substitutions made. \end{Desc}
\hypertarget{group__str_g174d1bf12ba03f33d6bfe98c566fec4e}{
\index{str@{str}!str_truncate@{str\_\-truncate}}
\index{str_truncate@{str\_\-truncate}!str@{str}}
\subsubsection[str\_\-truncate]{\setlength{\rightskip}{0pt plus 5cm}int str\_\-truncate (\hyperlink{structstr}{str} $\ast$ {\em s}, unsigned {\em len})}}
\label{group__str_g174d1bf12ba03f33d6bfe98c566fec4e}


Truncate a string.

If {\tt len} is larger than the current size, the string is reallocated. If {\tt len} is less than the existing length (not size), the length of the string is reduced to {\tt len}. A {\tt NUL} marker is placed at {\tt len}. \hypertarget{group__str_g1b08b4fba3b7ea32ced0109a50ef7d06}{
\index{str@{str}!str_upper@{str\_\-upper}}
\index{str_upper@{str\_\-upper}!str@{str}}
\subsubsection[str\_\-upper]{\setlength{\rightskip}{0pt plus 5cm}void str\_\-upper (\hyperlink{structstr}{str} $\ast$ {\em s})}}
\label{group__str_g1b08b4fba3b7ea32ced0109a50ef7d06}


Translate all lower-case characters to upper-case \hypertarget{group__str_g46b3436a55500d66b1343ff7c8122831}{
\index{str@{str}!str_xlate@{str\_\-xlate}}
\index{str_xlate@{str\_\-xlate}!str@{str}}
\subsubsection[str\_\-xlate]{\setlength{\rightskip}{0pt plus 5cm}long str\_\-xlate (\hyperlink{structstr}{str} $\ast$ {\em s}, const char $\ast$ {\em from}, const char $\ast$ {\em to}, unsigned {\em nchars})}}
\label{group__str_g46b3436a55500d66b1343ff7c8122831}


Substitute one character for another throughout the string. \begin{Desc}
\item[Returns:]the number of substitutions made. \end{Desc}


\subsection{Variable Documentation}
\hypertarget{group__str_gb17c3827c0b106c7103a9879751ea843}{
\index{str@{str}!str_lcase_digits@{str\_\-lcase\_\-digits}}
\index{str_lcase_digits@{str\_\-lcase\_\-digits}!str@{str}}
\subsubsection[str\_\-lcase\_\-digits]{\setlength{\rightskip}{0pt plus 5cm}const char \hyperlink{group__str_gb17c3827c0b106c7103a9879751ea843}{str\_\-lcase\_\-digits}\mbox{[}36\mbox{]}}}
\label{group__str_gb17c3827c0b106c7103a9879751ea843}


Lower-case digits, also used for decimal numbers. \hypertarget{group__str_g46d474d8d0f88e74ba454722af30ac08}{
\index{str@{str}!str_ucase_digits@{str\_\-ucase\_\-digits}}
\index{str_ucase_digits@{str\_\-ucase\_\-digits}!str@{str}}
\subsubsection[str\_\-ucase\_\-digits]{\setlength{\rightskip}{0pt plus 5cm}const char \hyperlink{group__str_g46d474d8d0f88e74ba454722af30ac08}{str\_\-ucase\_\-digits}\mbox{[}36\mbox{]}}}
\label{group__str_g46d474d8d0f88e74ba454722af30ac08}


Upper-case digits. 