Provided by: aolserver4-dev_4.5.1-15_amd64 bug


       Ns_DStringAppend,    Ns_DStringAppendArg,    Ns_DStringAppendElement,    Ns_DStringExport,
       Ns_DStringFree,  Ns_DStringInit,   Ns_DStringLength,   Ns_DStringNAppend,   Ns_DStringPop,
       Ns_DStringPrintf,  Ns_DStringPush,  Ns_DStringSetLength, Ns_DStringTrunc, Ns_DStringValue,
       Ns_DStringVarAppend - library procedures


       #include "ns.h"

       char *
       Ns_DStringAppend(Ns_DString *dsPtr, char *string)

       char *
       Ns_DStringAppendArg(Ns_DString *dsPtr, char *string)

       char *
       Ns_DStringAppendElement(Ns_DString *dsPtr, char *string)

       char *
       Ns_DStringExport(Ns_DString *dsPtr)

       Ns_DStringFree(Ns_DString *dsPtr)

       Ns_DStringInit(Ns_DString *dsPtr)

       Ns_DStringLength(Ns_DString *dsPtr)

       char *
       Ns_DStringNAppend(Ns_DString *dsPtr, char *string, int length)

       Ns_DString *

       char *
       Ns_DStringPrintf(Ns_DString *dsPtr, char *fmt,...)

       Ns_DStringPush(Ns_DString *dsPtr)

       Ns_DStringSetLength(Ns_DString *dsPtr, int length)

       Ns_DStringTrunc(Ns_DString *dsPtr, int length)

       char *
       Ns_DStringValue(Ns_DString *dsPtr)

       char *
       Ns_DStringVarAppend(Ns_DString *dsPtr, ...)


       These functions create, manipulate and destroy  Ns_DStrings.  Ns_DStrings  are  structures
       that  store strings and information about the string length. These dynamic strings grow as
       need to fit the strings placed in them or appended to them. If  the  Ns_DString  plus  the
       appended  string  are  larger  than the size of original string within the Ns_DString, for
       example, the Ns_DString will be automatically extended by allocating more memory to it.

       Many functions return string  pointers  that  point  directly  to  the  string  within  an
       Ns_DString structure. You must not free these returned string pointers with Ns_Free or any
       other freeing function, but must instead use Ns_DStringFree to free memory associated with
       the Ns_DString.

       Ns_DStringAppend(dsPtr, string)

              Append  the  specified  string  plus a terminating null character to the end of the
              Ns_DString. Returns the string associated with the current Ns_DString.

              The Ns_DString ds of the following code would contain "foo " and have a  length  of

              Ns_DString ds;
              Ns_DStringAppend(&ds, "foo");
              /* do something with the dstring */
              printf("%s0, ds.string);
              /* finished with dstring */

       Ns_DStringAppendArg(dsPtr, string)

              Append  the  specified argument plus a terminating null character to the end of the
              Ns_DString. It is useful for making strings like "foo bar baz ". The string pointer
              associated with the current Ns_DString is returned.

       Ns_DStringAppendElement(dsPtr, string)

              Append a list element to the current value of a dynamic string. The string argument
              is reformatted as a list element and added to the current value of the  Ns_DString.
              The return value is a pointer to the dynamic string's new value.


              Returns  the current Ns_DString string and leaves the Ns_DString in the initialized
              state. In this case, the string returned needs to be freed eventually with  Ns_Free
              because the string pointer returned is not a part of the Ns_DString any longer.

              Ns_DString ds;
              char *stringdest;
              Ns_DStringAppend(&ds, "foo");
              stringdest = Ns_DStringExport(&ds);
              /* do something with .stringdest. */


              Free any allocated memory used by an Ns_DString.


              Initialize  an  Ns_DString. Before using an Ns_DString, you must initialize it with
              Ns_DStringInit. Storage for an Ns_DString is often on  the  stack  in  the  calling
              function. The example below shows a typical usage.

              int MyFunctions(int a, int b)
                  Ns_DString ds;
                   * ds is now initialized and ready to
                   * pass to another function


              Return  the  current  length  of  the  string  value  that  is  contained within an

              Ns_DString ds;
              Ns_DStringAppend(&ds, "<html></html>");
              printf("len=%d0, Ns_DStringLength(&ds));
              /* finished with dstring */

       Ns_DStringNAppend(dsPtr, string, length)

              Append n-characters of string to Ns_DString dsPtr. The function appends a string up
              to  the  specified  number of characters, plus a terminating null character. Unlike
              the Tcl_DStringAppend function, which only works with string  data,  the  AOLserver
              Ns_DStringNAppend  function  can append binary data.  Returns the string associated
              with the current Ns_DString.

              The resulting Ns_DString in this example, ds would
              contain "foo " and have a length of 3:

              Ns_DString ds;
              Ns_DStringNAppend(&ds, "fooasdf", 3);
              printf("%s0, ds.string);
              Ns_DStringFree(&ds); /* finished with dstring */

              If you need a null-terminated list of null-terminated
              strings, such as "foo bar  ", you would add one to
              the length of the appended strings to get the extra
              terminating null character. For example:

              Ns_DString ds;
              Ns_DStringNAppend(&ds, "foo", 4);
              Ns_DStringNAppend(&ds, "bar", 4);


              Pop an  Ns_DString  from  the  per-thread  cache,  allocating  the  space  for  the
              Ns_DString  if  necessary.   This  will  initialize  Thread Local Storage (TLS) and
              configure parameters on first use. TLS is a means of storing data associated with a
              particular  thread  within  the thread's context, so that it is always available to
              that thread. A pointer to the initialized Ns_DString is returned.

       Ns_DStringPrintf(dsPtr, fmt, ...)

              Append a formatted string to an Ns_DString. The Ns_DStringPrintf function appends a
              string  that has been created by calling the sprintf function with the given format
              and optional arguments. This function currently uses a fixed length buffer of  1024
              characters to sprintf() the data before appending to the Ns_DString.

              Ns_DString ds;

              Ns_DStringPrintf(&ds, "/path%d", getpid());
              /* do something with dstring */
              printf ("%s0, ds.string);
              /* finished with dstring */


              Push  an Ns_DString onto the per-thread cache. The Ns_DString will be free'd if the
              maximum number of entries or the maximum size parameters have  been  exceeded.  The
              contents held by the Ns_DString are destroyed.

              This  is a performance function. Creating Ns_DStrings is a more expensive operation
              than cleaning out an already-existing Ns_DString and storing it for  later  use  by
              the same thread.

       Ns_DStringSetLength(dsPtr, length)

              The length of dsPtr is changed to length and a null byte is stored at that position
              in the string.  If length is larger than the space  allocated  for  dsPtr,  then  a
              panic occurs.

       Ns_DStringTrunc(dsPtr, length)

              Truncate an Ns_DString. The Ns_DStringTrunc function truncates an Ns_DString to the
              given length. Unlike Ns_DStringFree, which truncates the Ns_DString to length 0 and
              frees  any  memory that may have been allocated on the heap, Ns_DStringTrunc allows
              you to truncate the string to any length. It maintains any memory allocated on  the
              heap.  This function is useful in a loop where the Ns_DString is likely to overflow
              the static space each time through. Using Ns_DStringTrunc instead of Ns_DStringFree
              will  avoid  having the Ns_DString call malloc to obtain the addition space in each
              iteration. You will need to call Ns_DStringFree eventually to free any  space  that
              may have been allocated for the Ns_DString.

              Ns_DString ds;
              int i;

              for (i=0; i < 50; i++) {
                  Ns_DStringPrintf(&ds, "%s%d", "aBigString", i);
                  /* do something with the dstring constructed above */
                  Ns_DStringTrunc(&ds, 0);


              Return  the  current  value  of  an Ns_DString. The Ns_DStringValue macro returns a
              pointer to the current value of an Ns_DString.   This  may  be  a  pointer  to  the
              Ns_DString.s  static space or to a string allocated on the heap if the static space
              has overflowed. It is not safe to use the value returned by  this  macro  after  an
              intervening  call  to Ns_DStringAppend because the Ns_DString string could overflow
              to or move within the heap.

              Ns_DString ds;
              Ns_DStringAppend(&ds, "foo");
              /* do something with the dstring */
              printf ("%s0, Ns_DStringValue(&ds));

       Ns_DStringVarAppend(dsPtr, ...)

              Append a variable number of  strings  to  an  Ns_DString.  The  Ns_DStringVarAppend
              function  appends  a variable number of strings to an Ns_DString. The list must end
              with NULL.

              Ns_DString ds;
              Ns_DStringVarAppend(&ds, "foo", "bar", NULL);
              /* do something with the dstring */
              printf ("%s0, ds.string);


       nsd(1), info(n)