+#endif
+
+
+
+#if !defined(HAVE_INLINE)
+void SB_Cut (StrBuf* B, unsigned Len)
+/* Cut the contents of B at the given length. If the current length of the
+ * buffer is smaller than Len, nothing will happen.
+ */
+{
+ if (Len < B->Len) {
+ B->Len = Len;
+ }
+}
+#endif
+
+
+
+void SB_Slice (StrBuf* Target, const StrBuf* Source, unsigned Start, unsigned Len)
+/* Copy a slice from Source into Target. The current contents of Target are
+ * destroyed. If Start is greater than the length of Source, or if Len
+ * characters aren't available, the result will be a buffer with less than Len
+ * bytes.
+ */
+{
+ /* Calculate the length of the resulting buffer */
+ if (Start >= Source->Len) {
+ /* Target will be empty */
+ SB_Clear (Target);
+ return;
+ }
+ if (Start + Len > Source->Len) {
+ Len = Source->Len - Start;
+ }
+
+ /* Make sure we have enough room in the target string buffer */
+ if (Len > Target->Allocated) {
+ SB_Realloc (Target, Len);
+ }
+
+ /* Copy the slice */
+ memcpy (Target->Buf, Source->Buf + Start, Len);
+ Target->Len = Len;
+}
+
+
+
+void SB_Move (StrBuf* Target, StrBuf* Source)
+/* Move the complete contents of Source to target. This will delete the old
+ * contents of Target, and Source will be empty after the call.
+ */
+{
+ /* Free the target string */
+ if (Target->Allocated) {
+ xfree (Target->Buf);
+ }
+
+ /* Move all data from Source to Target */
+ *Target = *Source;
+
+ /* Clear Source */
+ SB_Init (Source);
+}
+
+
+
+void SB_ToLower (StrBuf* S)
+/* Convert all characters in S to lower case */
+{
+ unsigned I;
+ char* B = S->Buf;
+ for (I = 0; I < S->Len; ++I, ++B) {
+ if (IsUpper (*B)) {
+ *B = tolower (*B);
+ }
+ }
+}
+
+
+
+void SB_ToUpper (StrBuf* S)
+/* Convert all characters in S to upper case */
+{
+ unsigned I;
+ char* B = S->Buf;
+ for (I = 0; I < S->Len; ++I, ++B) {
+ if (IsLower (*B)) {
+ *B = toupper (*B);
+ }
+ }
+}
+
+
+
+int SB_Compare (const StrBuf* S1, const StrBuf* S2)
+/* Do a lexical compare of S1 and S2. See strcmp for result codes. */
+{
+ int Result;
+ if (S1->Len < S2->Len) {
+ Result = memcmp (S1->Buf, S2->Buf, S1->Len);
+ if (Result == 0) {
+ /* S1 considered lesser because it's shorter */
+ Result = -1;
+ }
+ } else if (S1->Len > S2->Len) {
+ Result = memcmp (S1->Buf, S2->Buf, S2->Len);
+ if (Result == 0) {
+ /* S2 considered lesser because it's shorter */
+ Result = 1;
+ }
+ } else {
+ Result = memcmp (S1->Buf, S2->Buf, S1->Len);
+ }
+ return Result;
+}
+
+
+
+int SB_CompareStr (const StrBuf* S1, const char* S2)
+/* Do a lexical compare of S1 and S2. See strcmp for result codes. */
+{
+ int Result;
+ unsigned S2Len = strlen (S2);
+ if (S1->Len < S2Len) {
+ Result = memcmp (S1->Buf, S2, S1->Len);
+ if (Result == 0) {
+ /* S1 considered lesser because it's shorter */
+ Result = -1;
+ }
+ } else if (S1->Len > S2Len) {
+ Result = memcmp (S1->Buf, S2, S2Len);
+ if (Result == 0) {
+ /* S2 considered lesser because it's shorter */
+ Result = 1;
+ }
+ } else {
+ Result = memcmp (S1->Buf, S2, S1->Len);
+ }
+ return Result;
+}
+
+
+
+void SB_VPrintf (StrBuf* S, const char* Format, va_list ap)
+/* printf function with S as target. The function is safe, which means that
+ * the current contents of S are discarded, and are allocated again with
+ * a matching size for the output. The function will call FAIL when problems
+ * are detected (anything that let xsnprintf return -1).
+ */
+{
+ va_list tmp;
+ int SizeNeeded;
+
+ /* Since we must determine the space needed anyway, we will try with
+ * the currently allocated memory. If the call succeeds, we've saved
+ * an allocation. If not, we have to reallocate and try again.
+ */
+ va_copy (tmp, ap);
+ SizeNeeded = xvsnprintf (S->Buf, S->Allocated, Format, tmp);
+ va_end (tmp);
+
+ /* Check the result, the xvsnprintf function should not fail */
+ CHECK (SizeNeeded >= 0);
+
+ /* Check if we must reallocate */
+ if ((unsigned) SizeNeeded >= S->Allocated) {
+ /* Must retry. Use CheapRealloc to avoid copying */
+ SB_CheapRealloc (S, SizeNeeded + 1); /* Account for '\0' */
+ (void) xvsnprintf (S->Buf, S->Allocated, Format, ap);
+ }
+
+ /* Update string buffer variables */
+ S->Len = SizeNeeded;
+ S->Index = 0;
+}
+
+
+
+void SB_Printf (StrBuf* S, const char* Format, ...)
+/* vprintf function with S as target. The function is safe, which means that
+ * the current contents of S are discarded, and are allocated again with
+ * a matching size for the output. The function will call FAIL when problems
+ * are detected (anything that let xsnprintf return -1).
+ */
+{
+ va_list ap;
+ va_start (ap, Format);
+ SB_VPrintf (S, Format, ap);
+ va_end (ap);
+}