X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2FDEVEL%2Fpxp%2Fnetstring%2Fnetencoding.mli;fp=helm%2FDEVEL%2Fpxp%2Fnetstring%2Fnetencoding.mli;h=6466572b3fd5e790c2c124356e10e7a5c0f1b429;hb=c03d2c1fdab8d228cb88aaba5ca0f556318bebc5;hp=0000000000000000000000000000000000000000;hpb=758057e85325f94cd88583feb1fdf6b038e35055;p=helm.git diff --git a/helm/DEVEL/pxp/netstring/netencoding.mli b/helm/DEVEL/pxp/netstring/netencoding.mli new file mode 100644 index 000000000..6466572b3 --- /dev/null +++ b/helm/DEVEL/pxp/netstring/netencoding.mli @@ -0,0 +1,271 @@ +(* $Id$ + * ---------------------------------------------------------------------- + * + *) + +(**********************************************************************) +(* Several encodings important for the net *) +(**********************************************************************) + + +(**********************************************************************) +(* Base 64 encoding *) +(**********************************************************************) + +(* See RFC 2045 for a description of Base 64 encoding. *) + +(* THREAD-SAFETY: + * All Base64 functions are reentrant and thus thread-safe. + *) + +module Base64 : sig + + val encode : ?pos:int -> ?len:int -> ?linelength:int -> ?crlf:bool -> + string -> string + (* Compute the "base 64" encoding of the given string argument. + * Note that the result is a string that only contains the characters + * a-z, A-Z, 0-9, +, /, =, and optionally spaces, CR and LF characters. + * + * If pos and/or len are passed, only the substring starting at + * pos (default: 0) with length len (default: rest of the string) + * is encoded. + * + * The result is divided up into lines not longer than 'linelength' + * (without counting the line separator); default: do not divide lines. + * If 'linelength' is smaller than 4, no line division is performed. + * If 'linelength' is not divisible by 4, the produced lines are a + * bit shorter than 'linelength'. + * + * If 'crlf' (default: false) the lines are ended by CRLF; otherwise + * they are only ended by LF. + * (You need the crlf option to produce correct MIME messages.) + * + *) + + val url_encode : ?pos:int -> ?len:int -> ?linelength:int -> ?crlf:bool -> + string -> string + (* Same as 'encode' but use slightly different characters that can be + * part of URLs without additional encodings. + * The encoded string consists only of the characters a-z, A-Z, 0-9, + * -, /, . + * 'url_encode' does NOT implement the Base 64 encoding as described + * in the standard! + *) + + val encode_substring : string -> pos:int -> len:int -> linelength:int -> + crlf:bool -> string + (* *** DEPRECATED FUNCTION *** Use 'encode' instead! *** + * + * encode_substring s pos len linelen crlf: + * Encodes the substring at position 'pos' in 's' with length 'len'. + * The result is divided up into lines not longer than 'linelen' (without + * counting the line separator). + * If 'linelen' is smaller than 4, no line division is performed. + * If 'linelen' is not divisible by 4, the produced lines are a + * bit shorter than 'linelen'. + * If 'crlf' the lines are ended by CRLF; otherwise they are only + * ended by LF. + * (You need the crlf option to produce correct MIME messages.) + *) + + val decode : ?pos:int -> ?len:int -> ?url_variant:bool -> + ?accept_spaces:bool -> string -> string + (* Decodes the given string argument. + * + * If pos and/or len are passed, only the substring starting at + * pos (default: 0) with length len (default: rest of the string) + * is decoded. + * + * If url_variant (default: true) is set, the functions also + * accepts the characters '-' and '.' as produced by 'url_encode'. + * + * If accept_spaces (default: false) is set, the function ignores + * white space contained in the string to decode (otherwise the + * function fails if it finds white space). + *) + + val decode_ignore_spaces : string -> string + (* *** DEPRECATED FUNCTION *** Use 'decode' instead! *** + * + * Decodes the string, too, but it is allowed that the string contains + * whitespace characters. + * This function is slower than 'decode'. + *) + + val decode_substring : string -> pos:int -> len:int -> url_variant:bool -> + accept_spaces:bool -> string + (* *** DEPRECATED FUNCTION *** Use 'decode' instead! *** + * + * decode_substring s pos len url spaces: + * Decodes the substring of 's' beginning at 'pos' with length 'len'. + * If 'url', strings created by 'url_encode' are accepted, too. + * If 'spaces', whitespace characters are allowed in the string. + *) +end + +(**********************************************************************) +(* Quoted printable encoding *) +(**********************************************************************) + +(* See RFC 2045. + * This implementation assumes that the encoded string has a text MIME + * type. Because of this, the characters CR and LF are never protected + * by hex tokens; they are copied literally to the output string. + *) + +(* THREAD-SAFETY: + * All QuotedPrintable functions are reentrant and thus thread-safe. + *) + +module QuotedPrintable : + sig + val encode : ?pos:int -> ?len:int -> string -> string + (* Encodes the string and returns it. + * Note line breaks: + * No additional soft line breaks are added. The characters CR + * and LF are not represented as =0D resp. =0A. (But other control + * characters ARE encoded.) + * Note unsafe characters: + * As recommended by RFC 2045, the characters !\"#$@[]^`{|}~ + * are additionally represented as hex tokens. -- " + * + * If pos and/or len are passed, only the substring starting at + * pos (default: 0) with length len (default: rest of the string) + * is encoded. + *) + + val encode_substring : string -> pos:int -> len:int -> string + (* *** DEPRECATED FUNCTION *** Use 'encode' instead! *** + * encode_substring s pos len: + * Encodes the substring of 's' beginning at 'pos' with length 'len'. + *) + + val decode : ?pos:int -> ?len:int -> string -> string + (* Decodes the string and returns it. + * Most format errors cause an Invalid_argument exception. + * Note that soft line breaks can be properly decoded although + * 'encode' will never produce them. + * + * If pos and/or len are passed, only the substring starting at + * pos (default: 0) with length len (default: rest of the string) + * is decoded. + *) + + val decode_substring : string -> pos:int -> len:int -> string + (* *** DEPRECATED FUNCTION *** Use 'decode' instead! *** + * decode_substring s pos len: + * Decodes the substring of 's' beginning at 'pos' with length 'len'. + *) + + end + +(**********************************************************************) +(* Q encoding *) +(**********************************************************************) + +(* See RFC 2047. + * The functions behave similar to those of QuotedPrintable. + *) + +(* THREAD-SAFETY: + * All Q functions are reentrant and thus thread-safe. + *) + +module Q : + sig + val encode : ?pos:int -> ?len:int -> string -> string + (* Note: + * All characters except alphanumeric characters are protected by + * hex tokens. + * In particular, spaces are represented as "=20", not as "_". + *) + + val decode : ?pos:int -> ?len:int -> string -> string + + val encode_substring : string -> pos:int -> len:int -> string + (* *** DEPRECATED FUNCTION *** Use 'encode' instead! *** *) + + val decode_substring : string -> pos:int -> len:int -> string + (* *** DEPRECATED FUNCTION *** Use 'decode' instead! *** *) + end + +(**********************************************************************) +(* B encoding *) +(**********************************************************************) + +(* The B encoding of RFC 2047 is the same as Base64. *) + + +(**********************************************************************) +(* URL-encoding *) +(**********************************************************************) + +(* Encoding/Decoding within URLs: + * + * The following two functions perform the '%'-substitution for + * characters that may otherwise be interpreted as metacharacters. + * + * According to: RFC 1738, RFC 1630 + *) + +(* THREAD-SAFETY: + * The Url functions are thread-safe. + *) + +module Url : + sig + val decode : string -> string + val encode : string -> string + end + + +(**********************************************************************) +(* HTMLization *) +(**********************************************************************) + +(* Encodes characters that need protection by converting them to + * entity references. E.g. "<" is converted to "<". + * As the entities may be named, there is a dependency on the character + * set. Currently, there are only functions for the Latin 1 alphabet. + *) + +(* THREAD-SAFETY: + * The Html functions are thread-safe. + *) + +module Html : + sig + val encode_from_latin1 : string -> string + (* Encodes the characters 0-8, 11-12, 14-31, '<', '>', '"', '&', + * 127-255. If the characters have a name, a named entity is + * preferred over a numeric entity. + *) + val decode_to_latin1 : string -> string + (* Decodes the string. Unknown named entities are left as they + * are (i.e. decode_to_latin1 "&nonsense;" = "&nonsense;"). + * The same applies to numeric entities greater than 255. + *) + end + + +(* ====================================================================== + * History: + * + * $Log$ + * Revision 1.1 2000/11/17 09:57:27 lpadovan + * Initial revision + * + * Revision 1.4 2000/06/25 22:34:43 gerd + * Added labels to arguments. + * + * Revision 1.3 2000/06/25 21:15:48 gerd + * Checked thread-safety. + * + * Revision 1.2 2000/03/03 01:08:29 gerd + * Added Netencoding.Html functions. + * + * Revision 1.1 2000/03/02 01:14:48 gerd + * Initial revision. + * + * + *)