/packages/httpd20/src/apr/apr_lib.inc

https://github.com/slibre/freepascal · Pascal · 221 lines · 25 code · 16 blank · 180 comment · 0 complexity · 09e12012c44eaaa232530a0c2ef2048b MD5 · raw file

  1. { Copyright 2000-2005 The Apache Software Foundation or its licensors, as
  2. * applicable.
  3. *
  4. * Licensed under the Apache License, Version 2.0 (the "License");
  5. * you may not use this file except in compliance with the License.
  6. * You may obtain a copy of the License at
  7. *
  8. * http://www.apache.org/licenses/LICENSE-2.0
  9. *
  10. * Unless required by applicable law or agreed to in writing, software
  11. * distributed under the License is distributed on an "AS IS" BASIS,
  12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. * See the License for the specific language governing permissions and
  14. * limitations under the License.
  15. }
  16. {
  17. * @file apr_lib.h
  18. * This is collection of oddballs that didn't fit anywhere else,
  19. * and might move to more appropriate headers with the release
  20. * of APR 1.0.
  21. * @brief APR general purpose library routines
  22. }
  23. {#include "apr.h"
  24. #include "apr_errno.h"
  25. #if APR_HAVE_CTYPE_H
  26. #include <ctype.h>
  27. #endif
  28. #if APR_HAVE_STDARG_H
  29. #include <stdarg.h>
  30. #endif}
  31. {
  32. * @defgroup apr_lib General Purpose Library Routines
  33. * @ingroup APR
  34. * This is collection of oddballs that didn't fit anywhere else,
  35. * and might move to more appropriate headers with the release
  36. * of APR 1.0.
  37. }
  38. { A constant representing a 'large' string. }
  39. const HUGE_STRING_LEN = 8192;
  40. {
  41. * Define the structures used by the APR general-purpose library.
  42. }
  43. { @see apr_vformatter_buff_t }
  44. type
  45. Papr_vformatter_buff_t = ^apr_vformatter_buff_t;
  46. {
  47. * Structure used by the variable-formatter routines.
  48. }
  49. apr_vformatter_buff_t = record
  50. { The current position }
  51. curpos: PChar;
  52. { The end position of the format string }
  53. endpos: PChar;
  54. end;
  55. {
  56. * return the final element of the pathname
  57. * @param pathname The path to get the final element of
  58. * @return the final element of the path
  59. * @remark
  60. * <PRE>
  61. * For example:
  62. * "/foo/bar/gum" -> "gum"
  63. * "/foo/bar/gum/" -> ""
  64. * "gum" -> "gum"
  65. * "bs\\path\\stuff" -> "stuff"
  66. * </PRE>
  67. }
  68. function apr_filepath_name_get(const pathname: PChar): PChar;
  69. {$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
  70. external LibAPR name LibNamePrefix + 'apr_filepath_name_get' + LibSuff4;
  71. { @deprecated @see apr_filepath_name_get }
  72. function apr_filename_of_pathname(const pathname: PChar): PChar;
  73. {$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
  74. external LibAPR name LibNamePrefix + 'apr_filename_of_pathname' + LibSuff4;
  75. {
  76. * apr_killpg
  77. * Small utility macros to make things easier to read. Not usually a
  78. * goal, to be sure..
  79. }
  80. //#ifdef WIN32
  81. //#define apr_killpg(x, y)
  82. //#else { WIN32 }
  83. //#ifdef NO_KILLPG
  84. //#define apr_killpg(x, y) (kill (-(x), (y)))
  85. //#else { NO_KILLPG }
  86. //#define apr_killpg(x, y) (killpg ((x), (y)))
  87. //#endif { NO_KILLPG }
  88. //#endif { WIN32 }
  89. {
  90. * apr_vformatter() is a generic printf-style formatting routine
  91. * with some extensions.
  92. * @param flush_func The function to call when the buffer is full
  93. * @param c The buffer to write to
  94. * @param fmt The format string
  95. * @param ap The arguments to use to fill out the format string.
  96. *
  97. * @remark
  98. * <PRE>
  99. * The extensions are:
  100. *
  101. * %%pA takes a struct in_addr *, and prints it as a.b.c.d
  102. * %%pI takes an apr_sockaddr_t * and prints it as a.b.c.d:port or
  103. * [ipv6-address]:port
  104. * %%pT takes an apr_os_thread_t * and prints it in decimal
  105. * ('0' is printed if !APR_HAS_THREADS)
  106. * %%pp takes a void * and outputs it in hex
  107. *
  108. * The %%p hacks are to force gcc's printf warning code to skip
  109. * over a pointer argument without complaining. This does
  110. * mean that the ANSI-style %%p (output a void * in hex format) won't
  111. * work as expected at all, but that seems to be a fair trade-off
  112. * for the increased robustness of having printf-warnings work.
  113. *
  114. * Additionally, apr_vformatter allows for arbitrary output methods
  115. * using the apr_vformatter_buff and flush_func.
  116. *
  117. * The apr_vformatter_buff has two elements curpos and endpos.
  118. * curpos is where apr_vformatter will write the next byte of output.
  119. * It proceeds writing output to curpos, and updating curpos, until
  120. * either the end of output is reached, or curpos == endpos (i.e. the
  121. * buffer is full).
  122. *
  123. * If the end of output is reached, apr_vformatter returns the
  124. * number of bytes written.
  125. *
  126. * When the buffer is full, the flush_func is called. The flush_func
  127. * can return -1 to indicate that no further output should be attempted,
  128. * and apr_vformatter will return immediately with -1. Otherwise
  129. * the flush_func should flush the buffer in whatever manner is
  130. * appropriate, re apr_pool_t nitialize curpos and endpos, and return 0.
  131. *
  132. * Note that flush_func is only invoked as a result of attempting to
  133. * write another byte at curpos when curpos >= endpos. So for
  134. * example, it's possible when the output exactly matches the buffer
  135. * space available that curpos == endpos will be true when
  136. * apr_vformatter returns.
  137. *
  138. * apr_vformatter does not call out to any other code, it is entirely
  139. * self-contained. This allows the callers to do things which are
  140. * otherwise "unsafe". For example, apr_psprintf uses the "scratch"
  141. * space at the unallocated end of a block, and doesn't actually
  142. * complete the allocation until apr_vformatter returns. apr_psprintf
  143. * would be completely broken if apr_vformatter were to call anything
  144. * that used this same pool. Similarly http_bprintf() uses the "scratch"
  145. * space at the end of its output buffer, and doesn't actually note
  146. * that the space is in use until it either has to flush the buffer
  147. * or until apr_vformatter returns.
  148. * </PRE>
  149. }
  150. type
  151. flush_func_t = function (b: Papr_vformatter_buff_t): Integer;
  152. function apr_vformatter(flush_func: flush_func_t;
  153. c: Papr_vformatter_buff_t; const fmt: PChar; ap: va_list): Integer;
  154. {$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
  155. external LibAPR name LibNamePrefix + 'apr_vformatter' + LibSuff16;
  156. {
  157. * Display a prompt and read in the password from stdin.
  158. * @param prompt The prompt to display
  159. * @param pwbuf Buffer to store the password
  160. * @param bufsize The length of the password buffer.
  161. }
  162. function apr_password_get(const prompt: PChar;
  163. pwbuf: PChar; bufsize: Papr_size_t): apr_status_t;
  164. {$IFDEF WINDOWS} stdcall; {$ELSE} cdecl; {$ENDIF}
  165. external LibAPR name LibNamePrefix + 'apr_password_get' + LibSuff12;
  166. {
  167. * @defgroup apr_ctype ctype functions
  168. * These macros allow correct support of 8-bit characters on systems which
  169. * support 8-bit characters. Pretty dumb how the cast is required, but
  170. * that's legacy libc for ya. These new macros do not support EOF like
  171. * the standard macros do. Tough.
  172. }
  173. { @see isalnum }
  174. //#define apr_isalnum(c) (isalnum(((unsigned char)(c))))
  175. { @see isalpha }
  176. //#define apr_isalpha(c) (isalpha(((unsigned char)(c))))
  177. { @see iscntrl }
  178. //#define apr_iscntrl(c) (iscntrl(((unsigned char)(c))))
  179. { @see isdigit }
  180. //#define apr_isdigit(c) (isdigit(((unsigned char)(c))))
  181. { @see isgraph }
  182. //#define apr_isgraph(c) (isgraph(((unsigned char)(c))))
  183. { @see islower}
  184. //#define apr_islower(c) (islower(((unsigned char)(c))))
  185. { @see isascii }
  186. {#ifdef isascii
  187. #define apr_isascii(c) (isascii(((unsigned char)(c))))
  188. #else
  189. #define apr_isascii(c) (((c) & ~0x7f)==0)
  190. #endif}
  191. { @see isprint }
  192. //#define apr_isprint(c) (isprint(((unsigned char)(c))))
  193. { @see ispunct }
  194. //#define apr_ispunct(c) (ispunct(((unsigned char)(c))))
  195. { @see isspace }
  196. //#define apr_isspace(c) (isspace(((unsigned char)(c))))
  197. { @see isupper }
  198. //#define apr_isupper(c) (isupper(((unsigned char)(c))))
  199. { @see isxdigit }
  200. //#define apr_isxdigit(c) (isxdigit(((unsigned char)(c))))
  201. { @see tolower }
  202. function apr_tolower(c: Char): Char;
  203. { @see toupper }
  204. function apr_toupper(c: Char): Char;