home *** CD-ROM | disk | FTP | other *** search
/ Chip 2004 November / CMCD1104.ISO / Software / Complet / Apache / apache_2.0.52-win32-x86-no_ssl.msi / Data.Cab / F277232_apr_strings.h < prev    next >
C/C++ Source or Header  |  2004-02-13  |  13KB  |  335 lines
  1. /* Copyright 2000-2004 The Apache Software Foundation
  2.  *
  3.  * Licensed under the Apache License, Version 2.0 (the "License");
  4.  * you may not use this file except in compliance with the License.
  5.  * You may obtain a copy of the License at
  6.  *
  7.  *     http://www.apache.org/licenses/LICENSE-2.0
  8.  *
  9.  * Unless required by applicable law or agreed to in writing, software
  10.  * distributed under the License is distributed on an "AS IS" BASIS,
  11.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12.  * See the License for the specific language governing permissions and
  13.  * limitations under the License.
  14.  */
  15.  
  16. /* Portions of this file are covered by */
  17. /* -*- mode: c; c-file-style: "k&r" -*-
  18.  
  19.   strnatcmp.c -- Perform 'natural order' comparisons of strings in C.
  20.   Copyright (C) 2000 by Martin Pool <mbp@humbug.org.au>
  21.  
  22.   This software is provided 'as-is', without any express or implied
  23.   warranty.  In no event will the authors be held liable for any damages
  24.   arising from the use of this software.
  25.  
  26.   Permission is granted to anyone to use this software for any purpose,
  27.   including commercial applications, and to alter it and redistribute it
  28.   freely, subject to the following restrictions:
  29.  
  30.   1. The origin of this software must not be misrepresented; you must not
  31.      claim that you wrote the original software. If you use this software
  32.      in a product, an acknowledgment in the product documentation would be
  33.      appreciated but is not required.
  34.   2. Altered source versions must be plainly marked as such, and must not be
  35.      misrepresented as being the original software.
  36.   3. This notice may not be removed or altered from any source distribution.
  37. */
  38.  
  39. #ifndef APR_STRINGS_H
  40. #define APR_STRINGS_H
  41.  
  42. /**
  43.  * @file apr_strings.h
  44.  * @brief APR Strings library
  45.  */
  46.  
  47. #include "apr.h"
  48. #include "apr_errno.h"
  49. #include "apr_pools.h"
  50. #define APR_WANT_IOVEC
  51. #include "apr_want.h"
  52.  
  53. #if APR_HAVE_STDARG_H
  54. #include <stdarg.h>
  55. #endif
  56.  
  57. #ifdef __cplusplus
  58. extern "C" {
  59. #endif /* __cplusplus */
  60.  
  61. /**
  62.  * @defgroup apr_strings String routines
  63.  * @ingroup APR 
  64.  * @{
  65.  */
  66.  
  67. /**
  68.  * Do a natural order comparison of two strings.
  69.  * @param a The first string to compare
  70.  * @param b The second string to compare
  71.  * @return Either <0, 0, or >0.  If the first string is less than the second
  72.  *          this returns <0, if they are equivalent it returns 0, and if the
  73.  *          first string is greater than second string it retuns >0.
  74.  */
  75. APR_DECLARE(int) apr_strnatcmp(char const *a, char const *b);
  76.  
  77. /**
  78.  * Do a natural order comparison of two strings ignoring the case of the 
  79.  * strings.
  80.  * @param a The first string to compare
  81.  * @param b The second string to compare
  82.  * @return Either <0, 0, or >0.  If the first string is less than the second
  83.  *         this returns <0, if they are equivalent it returns 0, and if the
  84.  *         first string is greater than second string it retuns >0.
  85.  */
  86. APR_DECLARE(int) apr_strnatcasecmp(char const *a, char const *b);
  87.  
  88. /**
  89.  * duplicate a string into memory allocated out of a pool
  90.  * @param p The pool to allocate out of
  91.  * @param s The string to duplicate
  92.  * @return The new string
  93.  */
  94. APR_DECLARE(char *) apr_pstrdup(apr_pool_t *p, const char *s);
  95.  
  96. /**
  97.  * Create a null-terminated string by making a copy of a sequence
  98.  * of characters and appending a null byte
  99.  * @param p The pool to allocate out of
  100.  * @param s The block of characters to duplicate
  101.  * @param n The number of characters to duplicate
  102.  * @return The new string
  103.  * @remark This is a faster alternative to apr_pstrndup, for use
  104.  *         when you know that the string being duplicated really
  105.  *         has 'n' or more characters.  If the string might contain
  106.  *         fewer characters, use apr_pstrndup.
  107.  */
  108. APR_DECLARE(char *) apr_pstrmemdup(apr_pool_t *p, const char *s, apr_size_t n);
  109.  
  110. /**
  111.  * duplicate the first n characters of a string into memory allocated 
  112.  * out of a pool; the new string will be null-terminated
  113.  * @param p The pool to allocate out of
  114.  * @param s The string to duplicate
  115.  * @param n The number of characters to duplicate
  116.  * @return The new string
  117.  */
  118. APR_DECLARE(char *) apr_pstrndup(apr_pool_t *p, const char *s, apr_size_t n);
  119.  
  120. /**
  121.  * Duplicate a block of memory.
  122.  *
  123.  * @param p The pool to allocate from
  124.  * @param m The memory to duplicate
  125.  * @param n The number of bytes to duplicate
  126.  * @return The new block of memory
  127.  */
  128. APR_DECLARE(void *) apr_pmemdup(apr_pool_t *p, const void *m, apr_size_t n);
  129.  
  130. /**
  131.  * Concatenate multiple strings, allocating memory out a pool
  132.  * @param p The pool to allocate out of
  133.  * @param ... The strings to concatenate.  The final string must be NULL
  134.  * @return The new string
  135.  */
  136. APR_DECLARE_NONSTD(char *) apr_pstrcat(apr_pool_t *p, ...);
  137.  
  138. /**
  139.  * Concatenate multiple strings specified in a writev-style vector
  140.  * @param p The pool from which to allocate
  141.  * @param vec The strings to concatenate
  142.  * @param nvec The number of strings to concatenate
  143.  * @param nbytes (output) strlen of new string (pass in NULL to omit)
  144.  * @return The new string
  145.  */
  146. APR_DECLARE(char *) apr_pstrcatv(apr_pool_t *p, const struct iovec *vec,
  147.                                  apr_size_t nvec, apr_size_t *nbytes);
  148.  
  149. /**
  150.  * printf-style style printing routine.  The data is output to a string 
  151.  * allocated from a pool
  152.  * @param p The pool to allocate out of
  153.  * @param fmt The format of the string
  154.  * @param ap The arguments to use while printing the data
  155.  * @return The new string
  156.  */
  157. APR_DECLARE(char *) apr_pvsprintf(apr_pool_t *p, const char *fmt, va_list ap);
  158.  
  159. /**
  160.  * printf-style style printing routine.  The data is output to a string 
  161.  * allocated from a pool
  162.  * @param p The pool to allocate out of
  163.  * @param fmt The format of the string
  164.  * @param ... The arguments to use while printing the data
  165.  * @return The new string
  166.  */
  167. APR_DECLARE_NONSTD(char *) apr_psprintf(apr_pool_t *p, const char *fmt, ...)
  168.         __attribute__((format(printf,2,3)));
  169.  
  170. /**
  171.  * copy n characters from src to dst
  172.  * @param dst The destination string
  173.  * @param src The source string
  174.  * @param dst_size The space available in dst; dst always receives
  175.  *                 null-termination, so if src is longer than
  176.  *                 dst_size, the actual number of characters copied is
  177.  *                 dst_size - 1.
  178.  * @remark
  179.  * <PRE>
  180.  * We re-implement this function to implement these specific changes:
  181.  *       1) strncpy() doesn't always null terminate and we want it to.
  182.  *       2) strncpy() null fills, which is bogus, esp. when copy 8byte strings
  183.  *          into 8k blocks.
  184.  *       3) Instead of returning the pointer to the beginning of the
  185.  *          destination string, we return a pointer to the terminating null
  186.  *          to allow us to check for truncation.
  187.  * </PRE>
  188.  */
  189. APR_DECLARE(char *) apr_cpystrn(char *dst, const char *src,
  190.                                 apr_size_t dst_size);
  191.  
  192. /**
  193.  * Strip spaces from a string
  194.  * @param dest The destination string.  It is okay to modify the string
  195.  *             in place.  Namely dest == src
  196.  * @param src The string to rid the spaces from.
  197.  */
  198. APR_DECLARE(char *) apr_collapse_spaces(char *dest, const char *src);
  199.  
  200. /**
  201.  * Convert the arguments to a program from one string to an array of 
  202.  * strings terminated by a NULL pointer
  203.  * @param arg_str The arguments to convert
  204.  * @param argv_out Output location.  This is a pointer to an array of strings.
  205.  * @param token_context Pool to use.
  206.  */
  207. APR_DECLARE(apr_status_t) apr_tokenize_to_argv(const char *arg_str,
  208.                                                char ***argv_out,
  209.                                                apr_pool_t *token_context);
  210.  
  211. /**
  212.  * Split a string into separate null-terminated tokens.  The tokens are 
  213.  * delimited in the string by one or more characters from the sep
  214.  * argument.
  215.  * @param str The string to separate; this should be specified on the
  216.  *            first call to apr_strtok() for a given string, and NULL
  217.  *            on subsequent calls.
  218.  * @param sep The set of delimiters
  219.  * @param last Internal state saved by apr_strtok() between calls.
  220.  * @return The next token from the string
  221.  */
  222. APR_DECLARE(char *) apr_strtok(char *str, const char *sep, char **last);
  223.  
  224. /**
  225.  * @defgroup APR_Strings_Snprintf snprintf implementations
  226.  * @warning
  227.  * These are snprintf implementations based on apr_vformatter().
  228.  *
  229.  * Note that various standards and implementations disagree on the return
  230.  * value of snprintf, and side-effects due to %n in the formatting string.
  231.  * apr_snprintf (and apr_vsnprintf) behaves as follows:
  232.  *
  233.  * Process the format string until the entire string is exhausted, or
  234.  * the buffer fills.  If the buffer fills then stop processing immediately
  235.  * (so no further %n arguments are processed), and return the buffer
  236.  * length.  In all cases the buffer is NUL terminated. It will return the
  237.  * number of characters inserted into the buffer, not including the
  238.  * terminating NUL. As a special case, if len is 0, apr_snprintf will
  239.  * return the number of characters that would have been inserted if
  240.  * the buffer had been infinite (in this case, *buffer can be NULL)
  241.  *
  242.  * In no event does apr_snprintf return a negative number.
  243.  * @{
  244.  */
  245.  
  246. /**
  247.  * snprintf routine based on apr_vformatter.  This means it understands the
  248.  * same extensions.
  249.  * @param buf The buffer to write to
  250.  * @param len The size of the buffer
  251.  * @param format The format string
  252.  * @param ... The arguments to use to fill out the format string.
  253.  */
  254. APR_DECLARE_NONSTD(int) apr_snprintf(char *buf, apr_size_t len,
  255.                                      const char *format, ...)
  256.         __attribute__((format(printf,3,4)));
  257.  
  258. /**
  259.  * vsnprintf routine based on apr_vformatter.  This means it understands the
  260.  * same extensions.
  261.  * @param buf The buffer to write to
  262.  * @param len The size of the buffer
  263.  * @param format The format string
  264.  * @param ap The arguments to use to fill out the format string.
  265.  */
  266. APR_DECLARE(int) apr_vsnprintf(char *buf, apr_size_t len, const char *format,
  267.                                va_list ap);
  268. /** @} */
  269.  
  270. /**
  271.  * create a string representation of an int, allocated from a pool
  272.  * @param p The pool from which to allocate
  273.  * @param n The number to format
  274.  * @return The string representation of the number
  275.  */
  276. APR_DECLARE(char *) apr_itoa(apr_pool_t *p, int n);
  277.  
  278. /**
  279.  * create a string representation of a long, allocated from a pool
  280.  * @param p The pool from which to allocate
  281.  * @param n The number to format
  282.  * @return The string representation of the number
  283.  */
  284. APR_DECLARE(char *) apr_ltoa(apr_pool_t *p, long n);
  285.  
  286. /**
  287.  * create a string representation of an apr_off_t, allocated from a pool
  288.  * @param p The pool from which to allocate
  289.  * @param n The number to format
  290.  * @return The string representation of the number
  291.  */
  292. APR_DECLARE(char *) apr_off_t_toa(apr_pool_t *p, apr_off_t n);
  293.  
  294. /**
  295.  * parse a numeric string into a 64-bit numeric value
  296.  * @param buf The string to parse. It may contain optional whitespace,
  297.  *   followed by an optional '+' (positive, default) or '-' (negative)
  298.  *   character, followed by an optional '0x' prefix if base is 0 or 16,
  299.  *   followed by numeric digits appropriate for base.
  300.  * @param end A pointer to the end of the valid character in buf. If
  301.  *   not nil, it is set to the first invalid character in buf.
  302.  * @param base A numeric base in the range between 2 and 36 inclusive,
  303.  *   or 0.  If base is zero, buf will be treated as base ten unless its
  304.  *   digits are prefixed with '0x', in which case it will be treated as
  305.  *   base 16.
  306.  * @return The numeric value of the string.
  307.  */
  308. APR_DECLARE(apr_int64_t) apr_strtoi64(const char *buf, char **end, int base);
  309.  
  310. /**
  311.  * parse a base-10 numeric string into a 64-bit numeric value.
  312.  * Equivalent to apr_strtoi64(buf, (char**)NULL, 10).
  313.  * @param buf The string to parse
  314.  * @return The numeric value of the string
  315.  */
  316. APR_DECLARE(apr_int64_t) apr_atoi64(const char *buf);
  317.  
  318. /**
  319.  * Format a binary size (magnitiudes are 2^10 rather than 10^3) from an apr_off_t,
  320.  * as bytes, K, M, T, etc, to a four character compacted human readable string.
  321.  * @param size The size to format
  322.  * @param buf The 5 byte text buffer (counting the trailing null)
  323.  * @return The buf passed to apr_strfsize()
  324.  * @remark All negative sizes report '  - ', apr_strfsize only formats positive values.
  325.  */
  326. APR_DECLARE(char *) apr_strfsize(apr_off_t size, char *buf);
  327.  
  328. /** @} */
  329.  
  330. #ifdef __cplusplus
  331. }
  332. #endif
  333.  
  334. #endif  /* !APR_STRINGS_H */
  335.