text: /* 6db8b5726a796167bb96b3d83ff9ac6792a01474dbe3778deb3c2a25d60b3693 (0.9.5+)
   *
   * uriparser - RFC 3986 URI parsing library
   *
   * Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
   * Copyright (C) 2007, Sebastian Pipping <sebastian@pipping.org>
   * All rights reserved.
   *
   * Redistribution and use in source  and binary forms, with or without
   * modification, are permitted provided  that the following conditions
   * are met:
   *
   *     1. Redistributions  of  source  code   must  retain  the  above
   *        copyright notice, this list  of conditions and the following
   *        disclaimer.
   *
   *     2. Redistributions  in binary  form  must  reproduce the  above
   *        copyright notice, this list  of conditions and the following
   *        disclaimer  in  the  documentation  and/or  other  materials
   *        provided with the distribution.
   *
   *     3. Neither the  name of the  copyright holder nor the  names of
   *        its contributors may be used  to endorse or promote products
   *        derived from  this software  without specific  prior written
   *        permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   * "AS IS" AND  ANY EXPRESS OR IMPLIED WARRANTIES,  INCLUDING, BUT NOT
   * LIMITED TO,  THE IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS
   * FOR  A  PARTICULAR  PURPOSE  ARE  DISCLAIMED.  IN  NO  EVENT  SHALL
   * THE  COPYRIGHT HOLDER  OR CONTRIBUTORS  BE LIABLE  FOR ANY  DIRECT,
   * INDIRECT, INCIDENTAL, SPECIAL,  EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   * (INCLUDING, BUT NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE GOODS OR
   * SERVICES; LOSS OF USE, DATA,  OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   * STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
   * OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  
  /**
   * @file Uri.h
   * Holds the RFC 3986 %URI parser interface.
   * NOTE: This header includes itself twice.
   */
  
  #if (defined(URI_PASS_ANSI) && !defined(URI_H_ANSI)) \
  	|| (defined(URI_PASS_UNICODE) && !defined(URI_H_UNICODE)) \
  	|| (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
  /* What encodings are enabled? */
  #include "UriDefsConfig.h"
  #if (!defined(URI_PASS_ANSI) && !defined(URI_PASS_UNICODE))
  /* Include SELF twice */
  # ifdef URI_ENABLE_ANSI
  #  define URI_PASS_ANSI 1
  #  include "Uri.h"
  #  undef URI_PASS_ANSI
  # endif
  # ifdef URI_ENABLE_UNICODE
  #  define URI_PASS_UNICODE 1
  #  include "Uri.h"
  #  undef URI_PASS_UNICODE
  # endif
  /* Only one pass for each encoding */
  #elif (defined(URI_PASS_ANSI) && !defined(URI_H_ANSI) \
  	&& defined(URI_ENABLE_ANSI)) || (defined(URI_PASS_UNICODE) \
  	&& !defined(URI_H_UNICODE) && defined(URI_ENABLE_UNICODE))
  # ifdef URI_PASS_ANSI
  #  define URI_H_ANSI 1
  #  include "UriDefsAnsi.h"
  # else
  #  define URI_H_UNICODE 1
  #  include "UriDefsUnicode.h"
  # endif
  
  
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  
  
  #ifndef URI_DOXYGEN
  # include "UriBase.h"
  #endif
  
  
  
  /**
   * Specifies a range of characters within a string.
   * The range includes all characters from <c>first</c>
   * to one before <c>afterLast</c>. So if both are
   * non-NULL the difference is the length of the text range.
   *
   * @see UriUriA
   * @see UriPathSegmentA
   * @see UriHostDataA
   * @since 0.3.0
   */
  typedef struct URI_TYPE(TextRangeStruct) {
  	const URI_CHAR * first; /**< Pointer to first character */
  	const URI_CHAR * afterLast; /**< Pointer to character after the last one still in */
  } URI_TYPE(TextRange); /**< @copydoc UriTextRangeStructA */
  
  
  
  /**
   * Represents a path segment within a %URI path.
   * More precisely it is a node in a linked
   * list of path segments.
   *
   * @see UriUriA
   * @since 0.3.0
   */
  typedef struct URI_TYPE(PathSegmentStruct) {
  	URI_TYPE(TextRange) text; /**< Path segment name */
  	struct URI_TYPE(PathSegmentStruct) * next; /**< Pointer to the next path segment in the list, can be NULL if last already */
  
  	void * reserved; /**< Reserved to the parser */
  } URI_TYPE(PathSegment); /**< @copydoc UriPathSegmentStructA */
  
  
  
  /**
   * Holds structured host information.
   * This is either a IPv4, IPv6, plain
   * text for IPvFuture or all zero for
   * a registered name.
   *
   * @see UriUriA
   * @since 0.3.0
   */
  typedef struct URI_TYPE(HostDataStruct) {
  	UriIp4 * ip4; /**< IPv4 address */
  	UriIp6 * ip6; /**< IPv6 address */
  	URI_TYPE(TextRange) ipFuture; /**< IPvFuture address */
  } URI_TYPE(HostData); /**< @copydoc UriHostDataStructA */
  
  
  
  /**
   * Represents an RFC 3986 %URI.
   * Missing components can be {NULL, NULL} ranges.
   *
   * @see uriFreeUriMembersA
   * @see uriFreeUriMembersMmA
   * @see UriParserStateA
   * @since 0.3.0
   */
  typedef struct URI_TYPE(UriStruct) {
  	URI_TYPE(TextRange) scheme; /**< Scheme (e.g. "http") */
  	URI_TYPE(TextRange) userInfo; /**< User info (e.g. "user:pass") */
  	URI_TYPE(TextRange) hostText; /**< Host text (set for all hosts, excluding square brackets) */
  	URI_TYPE(HostData) hostData; /**< Structured host type specific data */
  	URI_TYPE(TextRange) portText; /**< Port (e.g. "80") */
  	URI_TYPE(PathSegment) * pathHead; /**< Head of a linked list of path segments */
  	URI_TYPE(PathSegment) * pathTail; /**< Tail of the list behind pathHead */
  	URI_TYPE(TextRange) query; /**< Query without leading "?" */
  	URI_TYPE(TextRange) fragment; /**< Query without leading "#" */
  	UriBool absolutePath; /**< Absolute path flag, distincting "a" and "/a";
  								always <c>URI_FALSE</c> for URIs with host */
  	UriBool owner; /**< Memory owner flag */
  
  	void * reserved; /**< Reserved to the parser */
  } URI_TYPE(Uri); /**< @copydoc UriUriStructA */
  
  
  
  /**
   * Represents a state of the %URI parser.
   * Missing components can be NULL to reflect
   * a components absence.
   *
   * @see uriFreeUriMembersA
   * @see uriFreeUriMembersMmA
   * @since 0.3.0
   */
  typedef struct URI_TYPE(ParserStateStruct) {
  	URI_TYPE(Uri) * uri; /**< Plug in the %URI structure to be filled while parsing here */
  	int errorCode; /**< Code identifying the error which occurred */
  	const URI_CHAR * errorPos; /**< Pointer to position in case of a syntax error */
  
  	void * reserved; /**< Reserved to the parser */
  } URI_TYPE(ParserState); /**< @copydoc UriParserStateStructA */
  
  
  
  /**
   * Represents a query element.
   * More precisely it is a node in a linked
   * list of query elements.
   *
   * @since 0.7.0
   */
  typedef struct URI_TYPE(QueryListStruct) {
  	const URI_CHAR * key; /**< Key of the query element */
  	const URI_CHAR * value; /**< Value of the query element, can be NULL */
  
  	struct URI_TYPE(QueryListStruct) * next; /**< Pointer to the next key/value pair in the list, can be NULL if last already */
  } URI_TYPE(QueryList); /**< @copydoc UriQueryListStructA */
  
  
  
  /**
   * Parses a RFC 3986 %URI.
   * Uses default libc-based memory manager.
   *
   * @param state       <b>INOUT</b>: Parser state with set output %URI, must not be NULL
   * @param first       <b>IN</b>: Pointer to the first character to parse, must not be NULL
   * @param afterLast   <b>IN</b>: Pointer to the character after the last to parse, must not be NULL
   * @return            0 on success, error code otherwise
   *
   * @see uriParseUriA
   * @see uriParseSingleUriA
   * @see uriParseSingleUriExA
   * @see uriToStringA
   * @since 0.3.0
   * @deprecated Deprecated since 0.9.0, please migrate to uriParseSingleUriExA (with "Single").
   */
  URI_PUBLIC int URI_FUNC(ParseUriEx)(URI_TYPE(ParserState) * state,
  		const URI_CHAR * first, const URI_CHAR * afterLast);
  
  
  
  /**
   * Parses a RFC 3986 %URI.
   * Uses default libc-based memory manager.
   *
   * @param state   <b>INOUT</b>: Parser state with set output %URI, must not be NULL
   * @param text    <b>IN</b>: Text to parse, must not be NULL
   * @return        0 on success, error code otherwise
   *
   * @see uriParseUriExA
   * @see uriParseSingleUriA
   * @see uriParseSingleUriExA
   * @see uriToStringA
   * @since 0.3.0
   * @deprecated Deprecated since 0.9.0, please migrate to uriParseSingleUriA (with "Single").
   */
  URI_PUBLIC int URI_FUNC(ParseUri)(URI_TYPE(ParserState) * state,
  		const URI_CHAR * text);
  
  
  
  /**
   * Parses a single RFC 3986 %URI.
   * Uses default libc-based memory manager.
   *
   * @param uri         <b>OUT</b>: Output %URI, must not be NULL
   * @param text        <b>IN</b>: Pointer to the first character to parse,
   *                               must not be NULL
   * @param errorPos    <b>OUT</b>: Pointer to a pointer to the first character
   *                                causing a syntax error, can be NULL;
   *                                only set when URI_ERROR_SYNTAX was returned
   * @return            0 on success, error code otherwise
   *
   * @see uriParseSingleUriExA
   * @see uriParseSingleUriExMmA
   * @see uriToStringA
   * @since 0.9.0
   */
  URI_PUBLIC int URI_FUNC(ParseSingleUri)(URI_TYPE(Uri) * uri,
  		const URI_CHAR * text, const URI_CHAR ** errorPos);
  
  
  
  /**
   * Parses a single RFC 3986 %URI.
   * Uses default libc-based memory manager.
   *
   * @param uri         <b>OUT</b>: Output %URI, must not be NULL
   * @param first       <b>IN</b>: Pointer to the first character to parse,
   *                               must not be NULL
   * @param afterLast   <b>IN</b>: Pointer to the character after the last to
   *                               parse, can be NULL
   *                               (to use first + strlen(first))
   * @param errorPos    <b>OUT</b>: Pointer to a pointer to the first character
   *                                causing a syntax error, can be NULL;
   *                                only set when URI_ERROR_SYNTAX was returned
   * @return            0 on success, error code otherwise
   *
   * @see uriParseSingleUriA
   * @see uriParseSingleUriExMmA
   * @see uriToStringA
   * @since 0.9.0
   */
  URI_PUBLIC int URI_FUNC(ParseSingleUriEx)(URI_TYPE(Uri) * uri,
  		const URI_CHAR * first, const URI_CHAR * afterLast,
  		const URI_CHAR ** errorPos);
  
  
  
  /**
   * Parses a single RFC 3986 %URI.
   *
   * @param uri         <b>OUT</b>: Output %URI, must not be NULL
   * @param first       <b>IN</b>: Pointer to the first character to parse,
   *                               must not be NULL
   * @param afterLast   <b>IN</b>: Pointer to the character after the last to
   *                               parse, can be NULL
   *                               (to use first + strlen(first))
   * @param errorPos    <b>OUT</b>: Pointer to a pointer to the first character
   *                                causing a syntax error, can be NULL;
   *                                only set when URI_ERROR_SYNTAX was returned
   * @param memory      <b>IN</b>: Memory manager to use, NULL for default libc
   * @return            0 on success, error code otherwise
   *
   * @see uriParseSingleUriA
   * @see uriParseSingleUriExA
   * @see uriToStringA
   * @since 0.9.0
   */
  URI_PUBLIC int URI_FUNC(ParseSingleUriExMm)(URI_TYPE(Uri) * uri,
  		const URI_CHAR * first, const URI_CHAR * afterLast,
  		const URI_CHAR ** errorPos, UriMemoryManager * memory);
  
  
  
  /**
   * Frees all memory associated with the members
   * of the %URI structure. Note that the structure
   * itself is not freed, only its members.
   * Uses default libc-based memory manager.
   *
   * @param uri   <b>INOUT</b>: %URI structure whose members should be freed
   *
   * @see uriFreeUriMembersMmA
   * @since 0.3.0
   */
  URI_PUBLIC void URI_FUNC(FreeUriMembers)(URI_TYPE(Uri) * uri);
  
  
  
  /**
   * Frees all memory associated with the members
   * of the %URI structure. Note that the structure
   * itself is not freed, only its members.
   *
   * @param uri     <b>INOUT</b>: %URI structure whose members should be freed
   * @param memory  <b>IN</b>: Memory manager to use, NULL for default libc
   * @return        0 on success, error code otherwise
   *
   * @see uriFreeUriMembersA
   * @since 0.9.0
   */
  URI_PUBLIC int URI_FUNC(FreeUriMembersMm)(URI_TYPE(Uri) * uri,
  		UriMemoryManager * memory);
  
  
  
  /**
   * Percent-encodes all unreserved characters from the input string and
   * writes the encoded version to the output string.
   * Be sure to allocate <b>3 times</b> the space of the input buffer for
   * the output buffer for <c>normalizeBreaks == URI_FALSE</c> and <b>6 times</b>
   * the space for <c>normalizeBreaks == URI_TRUE</c>
   * (since e.g. "\x0d" becomes "%0D%0A" in that case)
   *
   * @param inFirst           <b>IN</b>: Pointer to first character of the input text
   * @param inAfterLast       <b>IN</b>: Pointer after the last character of the input text
   * @param out               <b>OUT</b>: Encoded text destination
   * @param spaceToPlus       <b>IN</b>: Whether to convert ' ' to '+' or not
   * @param normalizeBreaks   <b>IN</b>: Whether to convert CR and LF to CR-LF or not.
   * @return                  Position of terminator in output string
   *
   * @see uriEscapeA
   * @see uriUnescapeInPlaceExA
   * @since 0.5.2
   */
  URI_PUBLIC URI_CHAR * URI_FUNC(EscapeEx)(const URI_CHAR * inFirst,
  		const URI_CHAR * inAfterLast, URI_CHAR * out,
  		UriBool spaceToPlus, UriBool normalizeBreaks);
  
  
  
  /**
   * Percent-encodes all unreserved characters from the input string and
   * writes the encoded version to the output string.
   * Be sure to allocate <b>3 times</b> the space of the input buffer for
   * the output buffer for <c>normalizeBreaks == URI_FALSE</c> and <b>6 times</b>
   * the space for <c>normalizeBreaks == URI_TRUE</c>
   * (since e.g. "\x0d" becomes "%0D%0A" in that case)
   *
   * @param in                <b>IN</b>: Text source
   * @param out               <b>OUT</b>: Encoded text destination
   * @param spaceToPlus       <b>IN</b>: Whether to convert ' ' to '+' or not
   * @param normalizeBreaks   <b>IN</b>: Whether to convert CR and LF to CR-LF or not.
   * @return                  Position of terminator in output string
   *
   * @see uriEscapeExA
   * @see uriUnescapeInPlaceA
   * @since 0.5.0
   */
  URI_PUBLIC URI_CHAR * URI_FUNC(Escape)(const URI_CHAR * in, URI_CHAR * out,
  		UriBool spaceToPlus, UriBool normalizeBreaks);
  
  
  
  /**
   * Unescapes percent-encoded groups in a given string.
   * E.g. "%20" will become " ". Unescaping is done in place.
   * The return value will be point to the new position
   * of the terminating zero. Use this value to get the new
   * length of the string. NULL is only returned if <c>inout</c>
   * is NULL.
   *
   * @param inout             <b>INOUT</b>: Text to unescape/decode
   * @param plusToSpace       <b>IN</b>: Whether to convert '+' to ' ' or not
   * @param breakConversion   <b>IN</b>: Line break conversion mode
   * @return                  Pointer to new position of the terminating zero
   *
   * @see uriUnescapeInPlaceA
   * @see uriEscapeExA
   * @since 0.5.0
   */
  URI_PUBLIC const URI_CHAR * URI_FUNC(UnescapeInPlaceEx)(URI_CHAR * inout,
  		UriBool plusToSpace, UriBreakConversion breakConversion);
  
  
  
  /**
   * Unescapes percent-encoded groups in a given string.
   * E.g. "%20" will become " ". Unescaping is done in place.
   * The return value will be point to the new position
   * of the terminating zero. Use this value to get the new
   * length of the string. NULL is only returned if <c>inout</c>
   * is NULL.
   *
   * NOTE: '+' is not decoded to ' ' and line breaks are not converted.
   * Use the more advanced UnescapeInPlaceEx for that features instead.
   *
   * @param inout   <b>INOUT</b>: Text to unescape/decode
   * @return        Pointer to new position of the terminating zero
   *
   * @see uriUnescapeInPlaceExA
   * @see uriEscapeA
   * @since 0.3.0
   */
  URI_PUBLIC const URI_CHAR * URI_FUNC(UnescapeInPlace)(URI_CHAR * inout);
  
  
  
  /**
   * Performs reference resolution as described in
   * <a href="http://tools.ietf.org/html/rfc3986#section-5.2.2">section 5.2.2 of RFC 3986</a>.
   * Uses default libc-based memory manager.
   * NOTE: On success you have to call uriFreeUriMembersA on \p absoluteDest manually later.
   *
   * @param absoluteDest     <b>OUT</b>: Result %URI
   * @param relativeSource   <b>IN</b>: Reference to resolve
   * @param absoluteBase     <b>IN</b>: Base %URI to apply
   * @return                 Error code or 0 on success
   *
   * @see uriRemoveBaseUriA
   * @see uriRemoveBaseUriMmA
   * @see uriAddBaseUriExA
   * @see uriAddBaseUriExMmA
   * @since 0.4.0
   */
  URI_PUBLIC int URI_FUNC(AddBaseUri)(URI_TYPE(Uri) * absoluteDest,
  		const URI_TYPE(Uri) * relativeSource,
  		const URI_TYPE(Uri) * absoluteBase);
  
  
  
  /**
   * Performs reference resolution as described in
   * <a href="http://tools.ietf.org/html/rfc3986#section-5.2.2">section 5.2.2 of RFC 3986</a>.
   * Uses default libc-based memory manager.
   * NOTE: On success you have to call uriFreeUriMembersA on \p absoluteDest manually later.
   *
   * @param absoluteDest     <b>OUT</b>: Result %URI
   * @param relativeSource   <b>IN</b>: Reference to resolve
   * @param absoluteBase     <b>IN</b>: Base %URI to apply
   * @param options          <b>IN</b>: Configuration to apply
   * @return                 Error code or 0 on success
   *
   * @see uriRemoveBaseUriA
   * @see uriAddBaseUriA
   * @see uriAddBaseUriExMmA
   * @since 0.8.1
   */
  URI_PUBLIC int URI_FUNC(AddBaseUriEx)(URI_TYPE(Uri) * absoluteDest,
  		const URI_TYPE(Uri) * relativeSource,
  		const URI_TYPE(Uri) * absoluteBase,
  		UriResolutionOptions options);
  
  
  
  /**
   * Performs reference resolution as described in
   * <a href="http://tools.ietf.org/html/rfc3986#section-5.2.2">section 5.2.2 of RFC 3986</a>.
   * NOTE: On success you have to call uriFreeUriMembersMmA on \p absoluteDest manually later.
   *
   * @param absoluteDest     <b>OUT</b>: Result %URI
   * @param relativeSource   <b>IN</b>: Reference to resolve
   * @param absoluteBase     <b>IN</b>: Base %URI to apply
   * @param options          <b>IN</b>: Configuration to apply
   * @param memory           <b>IN</b>: Memory manager to use, NULL for default libc
   * @return                 Error code or 0 on success
   *
   * @see uriRemoveBaseUriA
   * @see uriRemoveBaseUriMmA
   * @see uriAddBaseUriA
   * @see uriAddBaseUriExA
   * @since 0.9.0
   */
  URI_PUBLIC int URI_FUNC(AddBaseUriExMm)(URI_TYPE(Uri) * absoluteDest,
  		const URI_TYPE(Uri) * relativeSource,
  		const URI_TYPE(Uri) * absoluteBase,
  		UriResolutionOptions options, UriMemoryManager * memory);
  
  
  
  /**
   * Tries to make a relative %URI (a reference) from an
   * absolute %URI and a given base %URI. The resulting %URI is going to be
   * relative if the absolute %URI and base %UI share both scheme and authority.
   * If that is not the case, the result will still be
   * an absolute URI (with scheme part if necessary).
   * Uses default libc-based memory manager.
   * NOTE: On success you have to call uriFreeUriMembersA on
   * \p dest manually later.
   *
   * @param dest             <b>OUT</b>: Result %URI
   * @param absoluteSource   <b>IN</b>: Absolute %URI to make relative
   * @param absoluteBase     <b>IN</b>: Base %URI
   * @param domainRootMode   <b>IN</b>: Create %URI with path relative to domain root
   * @return                 Error code or 0 on success
   *
   * @see uriRemoveBaseUriMmA
   * @see uriAddBaseUriA
   * @see uriAddBaseUriExA
   * @see uriAddBaseUriExMmA
   * @since 0.5.2
   */
  URI_PUBLIC int URI_FUNC(RemoveBaseUri)(URI_TYPE(Uri) * dest,
  		const URI_TYPE(Uri) * absoluteSource,
  		const URI_TYPE(Uri) * absoluteBase,
  		UriBool domainRootMode);
  
  
  
  /**
   * Tries to make a relative %URI (a reference) from an
   * absolute %URI and a given base %URI. The resulting %URI is going to be
   * relative if the absolute %URI and base %UI share both scheme and authority.
   * If that is not the case, the result will still be
   * an absolute URI (with scheme part if necessary).
   * NOTE: On success you have to call uriFreeUriMembersMmA on
   * \p dest manually later.
   *
   * @param dest             <b>OUT</b>: Result %URI
   * @param absoluteSource   <b>IN</b>: Absolute %URI to make relative
   * @param absoluteBase     <b>IN</b>: Base %URI
   * @param domainRootMode   <b>IN</b>: Create %URI with path relative to domain root
   * @param memory           <b>IN</b>: Memory manager to use, NULL for default libc
   * @return                 Error code or 0 on success
   *
   * @see uriRemoveBaseUriA
   * @see uriAddBaseUriA
   * @see uriAddBaseUriExA
   * @see uriAddBaseUriExMmA
   * @since 0.9.0
   */
  URI_PUBLIC int URI_FUNC(RemoveBaseUriMm)(URI_TYPE(Uri) * dest,
  		const URI_TYPE(Uri) * absoluteSource,
  		const URI_TYPE(Uri) * absoluteBase,
  		UriBool domainRootMode, UriMemoryManager * memory);
  
  
  
  /**
   * Checks two URIs for equivalence. Comparison is done
   * the naive way, without prior normalization.
   * NOTE: Two <c>NULL</c> URIs are equal as well.
   *
   * @param a   <b>IN</b>: First %URI
   * @param b   <b>IN</b>: Second %URI
   * @return    <c>URI_TRUE</c> when equal, <c>URI_FAlSE</c> else
   *
   * @since 0.4.0
   */
  URI_PUBLIC UriBool URI_FUNC(EqualsUri)(const URI_TYPE(Uri) * a,
  		const URI_TYPE(Uri) * b);
  
  
  
  /**
   * Calculates the number of characters needed to store the
   * string representation of the given %URI excluding the
   * terminator.
   *
   * @param uri             <b>IN</b>: %URI to measure
   * @param charsRequired   <b>OUT</b>: Length of the string representation in characters <b>excluding</b> terminator
   * @return                Error code or 0 on success
   *
   * @see uriToStringA
   * @since 0.5.0
   */
  URI_PUBLIC int URI_FUNC(ToStringCharsRequired)(const URI_TYPE(Uri) * uri,
  		int * charsRequired);
  
  
  
  /**
   * Converts a %URI structure back to text as described in
   * <a href="http://tools.ietf.org/html/rfc3986#section-5.3">section 5.3 of RFC 3986</a>.
   *
   * @param dest           <b>OUT</b>: Output destination
   * @param uri            <b>IN</b>: %URI to convert
   * @param maxChars       <b>IN</b>: Maximum number of characters to copy <b>including</b> terminator
   * @param charsWritten   <b>OUT</b>: Number of characters written, can be lower than maxChars even if the %URI is too long!
   * @return               Error code or 0 on success
   *
   * @see uriToStringCharsRequiredA
   * @since 0.4.0
   */
  URI_PUBLIC int URI_FUNC(ToString)(URI_CHAR * dest, const URI_TYPE(Uri) * uri,
  		int maxChars, int * charsWritten);
  
  
  
  /**
   * Determines the components of a %URI that are not normalized.
   *
   * @param uri   <b>IN</b>: %URI to check
   * @return      Normalization job mask
   *
   * @see uriNormalizeSyntaxA
   * @see uriNormalizeSyntaxExA
   * @see uriNormalizeSyntaxExMmA
   * @see uriNormalizeSyntaxMaskRequiredExA
   * @since 0.5.0
   * @deprecated Deprecated since 0.9.0, please migrate to uriNormalizeSyntaxMaskRequiredExA (with "Ex").
   */
  URI_PUBLIC unsigned int URI_FUNC(NormalizeSyntaxMaskRequired)(
  		const URI_TYPE(Uri) * uri);
  
  
  
  /**
   * Determines the components of a %URI that are not normalized.
   *
   * @param uri      <b>IN</b>: %URI to check
   * @param outMask  <b>OUT</b>: Normalization job mask
   * @return         Error code or 0 on success
   *
   * @see uriNormalizeSyntaxA
   * @see uriNormalizeSyntaxExA
   * @see uriNormalizeSyntaxExMmA
   * @see uriNormalizeSyntaxMaskRequiredA
   * @since 0.9.0
   */
  URI_PUBLIC int URI_FUNC(NormalizeSyntaxMaskRequiredEx)(
  		const URI_TYPE(Uri) * uri, unsigned int * outMask);
  
  
  
  /**
   * Normalizes a %URI using a normalization mask.
   * The normalization mask decides what components are normalized.
   *
   * NOTE: If necessary the %URI becomes owner of all memory
   * behind the text pointed to. Text is duplicated in that case.
   * Uses default libc-based memory manager.
   *
   * @param uri    <b>INOUT</b>: %URI to normalize
   * @param mask   <b>IN</b>: Normalization mask
   * @return       Error code or 0 on success
   *
   * @see uriNormalizeSyntaxA
   * @see uriNormalizeSyntaxExMmA
   * @see uriNormalizeSyntaxMaskRequiredA
   * @since 0.5.0
   */
  URI_PUBLIC int URI_FUNC(NormalizeSyntaxEx)(URI_TYPE(Uri) * uri,
  		unsigned int mask);
  
  
  
  /**
   * Normalizes a %URI using a normalization mask.
   * The normalization mask decides what components are normalized.
   *
   * NOTE: If necessary the %URI becomes owner of all memory
   * behind the text pointed to. Text is duplicated in that case.
   *
   * @param uri    <b>INOUT</b>: %URI to normalize
   * @param mask   <b>IN</b>: Normalization mask
   * @param memory <b>IN</b>: Memory manager to use, NULL for default libc
   * @return       Error code or 0 on success
   *
   * @see uriNormalizeSyntaxA
   * @see uriNormalizeSyntaxExA
   * @see uriNormalizeSyntaxMaskRequiredA
   * @since 0.9.0
   */
  URI_PUBLIC int URI_FUNC(NormalizeSyntaxExMm)(URI_TYPE(Uri) * uri,
  		unsigned int mask, UriMemoryManager * memory);
  
  
  
  /**
   * Normalizes all components of a %URI.
   *
   * NOTE: If necessary the %URI becomes owner of all memory
   * behind the text pointed to. Text is duplicated in that case.
   * Uses default libc-based memory manager.
   *
   * @param uri   <b>INOUT</b>: %URI to normalize
   * @return      Error code or 0 on success
   *
   * @see uriNormalizeSyntaxExA
   * @see uriNormalizeSyntaxExMmA
   * @see uriNormalizeSyntaxMaskRequiredA
   * @since 0.5.0
   */
  URI_PUBLIC int URI_FUNC(NormalizeSyntax)(URI_TYPE(Uri) * uri);
  
  
  
  /**
   * Converts a Unix filename to a %URI string.
   * The destination buffer must be large enough to hold 7 + 3 * len(filename) + 1
   * characters in case of an absolute filename or 3 * len(filename) + 1 in case
   * of a relative filename.
   *
   * EXAMPLE
   *   Input:  "/bin/bash"
   *   Output: "file:///bin/bash"
   *
   * @param filename     <b>IN</b>: Unix filename to convert
   * @param uriString    <b>OUT</b>: Destination to write %URI string to
   * @return             Error code or 0 on success
   *
   * @see uriUriStringToUnixFilenameA
   * @see uriWindowsFilenameToUriStringA
   * @since 0.5.2
   */
  URI_PUBLIC int URI_FUNC(UnixFilenameToUriString)(const URI_CHAR * filename,
  		URI_CHAR * uriString);
  
  
  
  /**
   * Converts a Windows filename to a %URI string.
   * The destination buffer must be large enough to hold 8 + 3 * len(filename) + 1
   * characters in case of an absolute filename or 3 * len(filename) + 1 in case
   * of a relative filename.
   *
   * EXAMPLE
   *   Input:  "E:\\Documents and Settings"
   *   Output: "file:///E:/Documents%20and%20Settings"
   *
   * @param filename     <b>IN</b>: Windows filename to convert
   * @param uriString    <b>OUT</b>: Destination to write %URI string to
   * @return             Error code or 0 on success
   *
   * @see uriUriStringToWindowsFilenameA
   * @see uriUnixFilenameToUriStringA
   * @since 0.5.2
   */
  URI_PUBLIC int URI_FUNC(WindowsFilenameToUriString)(const URI_CHAR * filename,
  		URI_CHAR * uriString);
  
  
  
  /**
   * Extracts a Unix filename from a %URI string.
   * The destination buffer must be large enough to hold len(uriString) + 1 - 7
   * characters in case of an absolute %URI or len(uriString) + 1 in case
   * of a relative %URI.
   *
   * @param uriString    <b>IN</b>: %URI string to convert
   * @param filename     <b>OUT</b>: Destination to write filename to
   * @return             Error code or 0 on success
   *
   * @see uriUnixFilenameToUriStringA
   * @see uriUriStringToWindowsFilenameA
   * @since 0.5.2
   */
  URI_PUBLIC int URI_FUNC(UriStringToUnixFilename)(const URI_CHAR * uriString,
  		URI_CHAR * filename);
  
  
  
  /**
   * Extracts a Windows filename from a %URI string.
   * The destination buffer must be large enough to hold len(uriString) + 1 - 5
   * characters in case of an absolute %URI or len(uriString) + 1 in case
   * of a relative %URI.
   *
   * @param uriString    <b>IN</b>: %URI string to convert
   * @param filename     <b>OUT</b>: Destination to write filename to
   * @return             Error code or 0 on success
   *
   * @see uriWindowsFilenameToUriStringA
   * @see uriUriStringToUnixFilenameA
   * @since 0.5.2
   */
  URI_PUBLIC int URI_FUNC(UriStringToWindowsFilename)(const URI_CHAR * uriString,
  		URI_CHAR * filename);
  
  
  
  /**
   * Calculates the number of characters needed to store the
   * string representation of the given query list excluding the
   * terminator. It is assumed that line breaks are will be
   * normalized to "%0D%0A".
   *
   * @param queryList         <b>IN</b>: Query list to measure
   * @param charsRequired     <b>OUT</b>: Length of the string representation in characters <b>excluding</b> terminator
   * @return                  Error code or 0 on success
   *
   * @see uriComposeQueryCharsRequiredExA
   * @see uriComposeQueryA
   * @since 0.7.0
   */
  URI_PUBLIC int URI_FUNC(ComposeQueryCharsRequired)(
  		const URI_TYPE(QueryList) * queryList, int * charsRequired);
  
  
  
  /**
   * Calculates the number of characters needed to store the
   * string representation of the given query list excluding the
   * terminator.
   *
   * @param queryList         <b>IN</b>: Query list to measure
   * @param charsRequired     <b>OUT</b>: Length of the string representation in characters <b>excluding</b> terminator
   * @param spaceToPlus       <b>IN</b>: Whether to convert ' ' to '+' or not
   * @param normalizeBreaks   <b>IN</b>: Whether to convert CR and LF to CR-LF or not.
   * @return                  Error code or 0 on success
   *
   * @see uriComposeQueryCharsRequiredA
   * @see uriComposeQueryExA
   * @since 0.7.0
   */
  URI_PUBLIC  int URI_FUNC(ComposeQueryCharsRequiredEx)(
  		const URI_TYPE(QueryList) * queryList,
  		int * charsRequired, UriBool spaceToPlus, UriBool normalizeBreaks);
  
  
  
  /**
   * Converts a query list structure back to a query string.
   * The composed string does not start with '?',
   * on the way ' ' is converted to '+' and line breaks are
   * normalized to "%0D%0A".
   *
   * @param dest              <b>OUT</b>: Output destination
   * @param queryList         <b>IN</b>: Query list to convert
   * @param maxChars          <b>IN</b>: Maximum number of characters to copy <b>including</b> terminator
   * @param charsWritten      <b>OUT</b>: Number of characters written, can be lower than maxChars even if the query list is too long!
   * @return                  Error code or 0 on success
   *
   * @see uriComposeQueryExA
   * @see uriComposeQueryMallocA
   * @see uriComposeQueryMallocExA
   * @see uriComposeQueryMallocExMmA
   * @see uriComposeQueryCharsRequiredA
   * @see uriDissectQueryMallocA
   * @see uriDissectQueryMallocExA
   * @see uriDissectQueryMallocExMmA
   * @since 0.7.0
   */
  URI_PUBLIC int URI_FUNC(ComposeQuery)(URI_CHAR * dest,
  		const URI_TYPE(QueryList) * queryList, int maxChars, int * charsWritten);
  
  
  
  /**
   * Converts a query list structure back to a query string.
   * The composed string does not start with '?'.
   *
   * @param dest              <b>OUT</b>: Output destination
   * @param queryList         <b>IN</b>: Query list to convert
   * @param maxChars          <b>IN</b>: Maximum number of characters to copy <b>including</b> terminator
   * @param charsWritten      <b>OUT</b>: Number of characters written, can be lower than maxChars even if the query list is too long!
   * @param spaceToPlus       <b>IN</b>: Whether to convert ' ' to '+' or not
   * @param normalizeBreaks   <b>IN</b>: Whether to convert CR and LF to CR-LF or not.
   * @return                  Error code or 0 on success
   *
   * @see uriComposeQueryA
   * @see uriComposeQueryMallocA
   * @see uriComposeQueryMallocExA
   * @see uriComposeQueryMallocExMmA
   * @see uriComposeQueryCharsRequiredExA
   * @see uriDissectQueryMallocA
   * @see uriDissectQueryMallocExA
   * @see uriDissectQueryMallocExMmA
   * @since 0.7.0
   */
  URI_PUBLIC int URI_FUNC(ComposeQueryEx)(URI_CHAR * dest,
  		const URI_TYPE(QueryList) * queryList, int maxChars, int * charsWritten,
  		UriBool spaceToPlus, UriBool normalizeBreaks);
  
  
  
  /**
   * Converts a query list structure back to a query string.
   * Memory for this string is allocated internally.
   * The composed string does not start with '?',
   * on the way ' ' is converted to '+' and line breaks are
   * normalized to "%0D%0A".
   * Uses default libc-based memory manager.
   *
   * @param dest              <b>OUT</b>: Output destination
   * @param queryList         <b>IN</b>: Query list to convert
   * @return                  Error code or 0 on success
   *
   * @see uriComposeQueryMallocExA
   * @see uriComposeQueryMallocExMmA
   * @see uriComposeQueryA
   * @see uriDissectQueryMallocA
   * @see uriDissectQueryMallocExA
   * @see uriDissectQueryMallocExMmA
   * @since 0.7.0
   */
  URI_PUBLIC int URI_FUNC(ComposeQueryMalloc)(URI_CHAR ** dest,
  		const URI_TYPE(QueryList) * queryList);
  
  
  
  /**
   * Converts a query list structure back to a query string.
   * Memory for this string is allocated internally.
   * The composed string does not start with '?'.
   * Uses default libc-based memory manager.
   *
   * @param dest              <b>OUT</b>: Output destination
   * @param queryList         <b>IN</b>: Query list to convert
   * @param spaceToPlus       <b>IN</b>: Whether to convert ' ' to '+' or not
   * @param normalizeBreaks   <b>IN</b>: Whether to convert CR and LF to CR-LF or not.
   * @return                  Error code or 0 on success
   *
   * @see uriComposeQueryMallocA
   * @see uriComposeQueryMallocExMmA
   * @see uriComposeQueryExA
   * @see uriDissectQueryMallocA
   * @see uriDissectQueryMallocExA
   * @see uriDissectQueryMallocExMmA
   * @since 0.7.0
   */
  URI_PUBLIC int URI_FUNC(ComposeQueryMallocEx)(URI_CHAR ** dest,
  		const URI_TYPE(QueryList) * queryList,
  		UriBool spaceToPlus, UriBool normalizeBreaks);
  
  
  
  /**
   * Converts a query list structure back to a query string.
   * Memory for this string is allocated internally.
   * The composed string does not start with '?'.
   *
   * @param dest              <b>OUT</b>: Output destination
   * @param queryList         <b>IN</b>: Query list to convert
   * @param spaceToPlus       <b>IN</b>: Whether to convert ' ' to '+' or not
   * @param normalizeBreaks   <b>IN</b>: Whether to convert CR and LF to CR-LF or not.
   * @param memory            <b>IN</b>: Memory manager to use, NULL for default libc
   * @return                  Error code or 0 on success
   *
   * @see uriComposeQueryMallocA
   * @see uriComposeQueryMallocExA
   * @see uriComposeQueryExA
   * @see uriDissectQueryMallocA
   * @see uriDissectQueryMallocExA
   * @see uriDissectQueryMallocExMmA
   * @since 0.9.0
   */
  URI_PUBLIC int URI_FUNC(ComposeQueryMallocExMm)(URI_CHAR ** dest,
  		const URI_TYPE(QueryList) * queryList,
  		UriBool spaceToPlus, UriBool normalizeBreaks,
  		UriMemoryManager * memory);
  
  
  
  /**
   * Constructs a query list from the raw query string of a given URI.
   * On the way '+' is converted back to ' ', line breaks are not modified.
   * Uses default libc-based memory manager.
   *
   * @param dest              <b>OUT</b>: Output destination
   * @param itemCount         <b>OUT</b>: Number of items found, can be NULL
   * @param first             <b>IN</b>: Pointer to first character <b>after</b> '?'
   * @param afterLast         <b>IN</b>: Pointer to character after the last one still in
   * @return                  Error code or 0 on success
   *
   * @see uriDissectQueryMallocExA
   * @see uriDissectQueryMallocExMmA
   * @see uriComposeQueryA
   * @see uriFreeQueryListA
   * @see uriFreeQueryListMmA
   * @since 0.7.0
   */
  URI_PUBLIC int URI_FUNC(DissectQueryMalloc)(URI_TYPE(QueryList) ** dest,
  		int * itemCount, const URI_CHAR * first, const URI_CHAR * afterLast);
  
  
  
  /**
   * Constructs a query list from the raw query string of a given URI.
   * Uses default libc-based memory manager.
   *
   * @param dest              <b>OUT</b>: Output destination
   * @param itemCount         <b>OUT</b>: Number of items found, can be NULL
   * @param first             <b>IN</b>: Pointer to first character <b>after</b> '?'
   * @param afterLast         <b>IN</b>: Pointer to character after the last one still in
   * @param plusToSpace       <b>IN</b>: Whether to convert '+' to ' ' or not
   * @param breakConversion   <b>IN</b>: Line break conversion mode
   * @return                  Error code or 0 on success
   *
   * @see uriDissectQueryMallocA
   * @see uriDissectQueryMallocExMmA
   * @see uriComposeQueryExA
   * @see uriFreeQueryListA
   * @since 0.7.0
   */
  URI_PUBLIC int URI_FUNC(DissectQueryMallocEx)(URI_TYPE(QueryList) ** dest,
  		int * itemCount, const URI_CHAR * first, const URI_CHAR * afterLast,
  		UriBool plusToSpace, UriBreakConversion breakConversion);
  
  
  
  /**
   * Constructs a query list from the raw query string of a given URI.
   *
   * @param dest              <b>OUT</b>: Output destination
   * @param itemCount         <b>OUT</b>: Number of items found, can be NULL
   * @param first             <b>IN</b>: Pointer to first character <b>after</b> '?'
   * @param afterLast         <b>IN</b>: Pointer to character after the last one still in
   * @param plusToSpace       <b>IN</b>: Whether to convert '+' to ' ' or not
   * @param breakConversion   <b>IN</b>: Line break conversion mode
   * @param memory            <b>IN</b>: Memory manager to use, NULL for default libc
   * @return                  Error code or 0 on success
   *
   * @see uriDissectQueryMallocA
   * @see uriDissectQueryMallocExA
   * @see uriComposeQueryExA
   * @see uriFreeQueryListA
   * @see uriFreeQueryListMmA
   * @since 0.9.0
   */
  URI_PUBLIC int URI_FUNC(DissectQueryMallocExMm)(URI_TYPE(QueryList) ** dest,
  		int * itemCount, const URI_CHAR * first, const URI_CHAR * afterLast,
  		UriBool plusToSpace, UriBreakConversion breakConversion,
  		UriMemoryManager * memory);
  
  
  
  /**
   * Frees all memory associated with the given query list.
   * The structure itself is freed as well.
   *
   * @param queryList   <b>INOUT</b>: Query list to free
   *
   * @see uriFreeQueryListMmA
   * @since 0.7.0
   */
  URI_PUBLIC void URI_FUNC(FreeQueryList)(URI_TYPE(QueryList) * queryList);
  
  
  
  /**
   * Frees all memory associated with the given query list.
   * The structure itself is freed as well.
   *
   * @param queryList  <b>INOUT</b>: Query list to free
   * @param memory     <b>IN</b>: Memory manager to use, NULL for default libc
   * @return           Error code or 0 on success
   *
   * @see uriFreeQueryListA
   * @since 0.9.0
   */
  URI_PUBLIC int URI_FUNC(FreeQueryListMm)(URI_TYPE(QueryList) * queryList,
  		UriMemoryManager * memory);
  
  
  
  /**
   * Makes the %URI hold copies of strings so that it no longer depends
   * on the original %URI string.  If the %URI is already owner of copies,
   * this function returns <c>URI_TRUE</c> and does not modify the %URI further.
   *
   * Uses default libc-based memory manager.
   *
   * @param uri    <b>INOUT</b>: %URI to make independent
   * @return       Error code or 0 on success
   *
   * @see uriMakeOwnerMmA
   * @since 0.9.4
   */
  URI_PUBLIC int URI_FUNC(MakeOwner)(URI_TYPE(Uri) * uri);
  
  
  
  /**
   * Makes the %URI hold copies of strings so that it no longer depends
   * on the original %URI string.  If the %URI is already owner of copies,
   * this function returns <c>URI_TRUE</c> and does not modify the %URI further.
   *
   * @param uri     <b>INOUT</b>: %URI to make independent
   * @param memory  <b>IN</b>: Memory manager to use, NULL for default libc
   * @return        Error code or 0 on success
   *
   * @see uriMakeOwnerA
   * @since 0.9.4
   */
  URI_PUBLIC int URI_FUNC(MakeOwnerMm)(URI_TYPE(Uri) * uri,
                                       UriMemoryManager * memory);
  
  
  
  #ifdef __cplusplus
  }
  #endif
  
  
  
  #endif
  #endif
  