# Index of values

A
add_inplace [Netbuffer] | `add_inplace nb f`: Calls the function `f` to add bytes to the netbuffer `nb`.
add_string [Netbuffer] | `add_string nb s`: Adds a copy of the string `s` to the logical end of the netbuffer `nb`.
add_sub_string [Netbuffer] | `add_sub_string nb s k n`: Adds the substring of `s` starting at position `k` with length `n` to the logical end of the netbuffer `nb`.
apply_relative_url [Neturl] | `apply_relative_url base rel`: Interprets `rel` relative to `base` and returns the new URL.
available_input_encodings [Netconversion] | Returns the list of all available encodings that can be used for input strings.
available_output_encodings [Netconversion] | Returns the list of all available encodings that can be used for output strings.
B
blit [Netbuffer] | `blit nb srcpos dest destpos len`: Copies the `len` bytes at position `srcpos` from `nb` to the string `dest` at position `destpos`.
bounded_full_split [Netstring_pcre] | Splits into at most `n` substrings, based on `full_split`
bounded_full_split [Netstring_str] | Splits into at most `n` substrings, based on `full_split`
bounded_split [Netstring_pcre] | Splits into at most `n` substrings, based on `split`
bounded_split [Netstring_str] | Splits into at most `n` substrings, based on `split`
bounded_split_delim [Netstring_pcre] | Splits into at most `n` substrings, based on `split_delim`
bounded_split_delim [Netstring_str] | Splits into at most `n` substrings, based on `split_delim`
buffered_transactional_optype [Netcgi] | A predefined transactional `operating_type` using a `Buffer.t` to store the not yet completed transaction.
byte_order_mark [Netconversion] | Returns the byte order mark that must occur at the beginning of files to indicate whether "little endian" or "big endian" is used.
C
clear [Netbuffer] | Deletes all contents from the buffer.
close [Netulex.ULB] | Sets `ulb_eof` of the `unicode_lexbuf`.
common_url_syntax [Neturl] | Syntax descriptions for common URL schemes.
compose [Netsendmail] | Composes a mail message with a main text, and optionally a number of attachments.
contents [Netbuffer] | Returns the contents of the buffer as fresh string.
convert [Netconversion] | Converts the string from `in_enc` to `out_enc`, and returns it.
copy_cursor [Netconversion] | Copies the cursor.
create [Netdate] | Convert the time (seconds since the epoch) to a date/time record
create [Netbuffer] | Creates a netbuffer which allocates initially this number of bytes.
create_address_list_tokens [Netsendmail] | Returns the list of `s_token`s representing email addresses as structured value.
create_boundary [Mimestring] | Creates a boundary string that can be used to separate multipart messages.
create_cursor [Netconversion] | Creates a new cursor for the passed string and the passed encoding.
create_input_netbuffer [Netchannels] | Creates an input channel and a shutdown function for a netbuffer.
create_mime_scanner [Mimestring] | Creates a new `mime_scanner` scanning the passed string.
create_text_tokens [Netsendmail] | Returns the list of `s_token`s representing an informal text as structured value.
cursor_at_end [Netconversion] | Returns whether the cursor is positioned past the last character.
cursor_blit [Netconversion] | `cursor_blit cs ua pos len`: Copies at most `len` characters as code points from the cursor position and the following positions to the array `ua` at index `pos`.
cursor_blit_maxlen [Netconversion] | Returns the maximum number of characters `cursor_blit` can copy at the current cursor position.
cursor_blit_positions [Netconversion] | Works like `cursor_blit`, but copies the byte positions of the characters into `ua` instead of the code points.
cursor_byte_length [Netconversion] | Returns the byte length of the representation of the character at the cursor.
cursor_char_count [Netconversion] | Returns the character count of the cursor.
cursor_encoding [Netconversion] | Returns the encoding of the cursor.
cursor_initial_rel_pos [Netconversion] | Returns the initial relative byte position of the cursor
cursor_pos [Netconversion] | Returns the byte position of the cursor, i.e.
cursor_range [Netconversion] | Returns the valid range of the cursor as pair `(range_pos, range_len)`
cursor_target [Netconversion] | Returns the string of the cursor
D
decode [Nethtml] | Converts entities `&name;` and `&#num;` into the corresponding characters.
decode [Netencoding.Html] | The input string is recoded from `in_enc` to `out_enc`, and HTML entities (`&name;` or `&#num;`) are resolved.
decode [Netencoding.Url] | Option `plus`: Whether '+' is converted to space.
decode [Netencoding.Q] |
decode [Netencoding.QuotedPrintable] | Decodes the string and returns it.
decode [Netencoding.Base64] | Decodes the given string argument.
decode_mime_body [Netmime] | `let ch' = decode_mime_body hdr ch`: According to the value of the Content-transfer-encoding header field in `hdr` the encoded MIME body written to `ch'` is decoded and transferred to `ch`.
decode_to_latin1 [Netencoding.Html] |

default_config [Netcgi_env]

The default configuration is: `tmp_directory`: one of /var/tmp, /tmp, C:\temp, ., `tmp_prefix`: "netstring", `permitted_http_methods`: `"GET"`, `"POST"`, `permitted_input_content_types`: `"multipart/form-data"`, `"application/x-www-form-urlencoded"`, `input_content_length_limit`: `maxint`, `workarounds`: all To create a custom configuration, it is suggested to use this syntax:

     let custom_config =
        { default_config with tmp_prefix = "my_prefix" }

default_url [Neturl] | Adds missing components and returns the modified URL.
delete [Netulex.ULB] | Deletes the number of characters from `unicode_lexbuf`.
delete [Netbuffer] | `delete nb k n`: Deletes the `n` bytes at position `k` of netbuffer `nb` in-place.
dest_url_encoded_parameters [Netencoding.Url] | The argument is the URL-encoded parameter string.
E
encode [Nethtml] | Converts problematic characters to their corresponding entities.

encode [Netencoding.Html]

The input string that is encoded as `in_enc` is recoded to `out_enc`, and the following characters are encoded as HTML entity (`&name;` or `&#num;`): The ASCII characters contained in `unsafe_chars`, The characters that cannot be represented in `out_enc`. By default (`out_enc=`Enc_usascii`), only ASCII characters can be represented, and thus all code points >= 128 are encoded as HTML entities. If you pass `out_enc=`Enc_utf8`, all characters can be represented. For example, the string `"(a<b) & (c>d)"` is encoded as `"(a&lt;b) &amp; (c&gt;d)"`.

encode [Netencoding.Url] | Option `plus`: Whether spaces are converted to '+'.
encode [Netencoding.Q] | Note: All characters except alphanumeric characters are protected by hex tokens.
encode [Netencoding.QuotedPrintable] | Encodes the string and returns it.
encode [Netencoding.Base64] | Compute the "base 64" encoding of the given string argument.
encode_from_latin1 [Netencoding.Html] |
encode_mime_body [Netmime] | `let ch' = encode_mime_body hdr ch`: According to the value of the Content-transfer-encoding header field in `hdr` the unencoded MIME body written to ch' is encoded and transferred to ch.
encoding_of_string [Netconversion] | Returns the encoding of the name of the encoding.
ensure_absolute_url [Neturl] | If the anonymous URL is absolute, it is just returned as result of this function.
extract_url_scheme [Neturl] | Returns the URL scheme from the string representation of an URL.
F
fcgi_accept [Netcgi_fcgi_10] |
fcgi_destroy [Netcgi_fcgi_10] |
fcgi_write_end_request [Netcgi_fcgi_10] |
fcgi_write_stderr [Netcgi_fcgi_10] |
fcgi_write_stdout [Netcgi_fcgi_10] |
file_url_of_local_path [Neturl] | Generates a URL with "file" scheme from the passed path name.
find_pattern [Netaux.KMP] |
first_chars [Netstring_pcre] | Same as `string_before`
first_chars [Netstring_str] | Same as `string_before`
format [Netdate] | Format a date/time record as a string
format_field_value [Netsendmail] | To put `sval`, an `s_token list`, into the header field `name`, call
format_to [Netdate] | Format a date/time record according to the format string and outputs the resulting string to the channel.
from_function [Netulex.ULB] | Creates a `unicode_lexbuf` to analyse strings of the passed `encoding` coming from the `refill` function.
from_in_obj_channel [Netulex.ULB] | Creates a `unicode_lexbuf` to analyse strings of the passed `encoding` coming from the object channel.
from_string [Netulex.ULB] | Creates a `unicode_lexbuf` analysing the passed string encoded in the passed encoding.
from_string_inplace [Netulex.ULB] | Creates a `unicode_lexbuf` analysing the passed string encoded in the passed encoding.
from_ulb_lexbuf [Netulex.Ulexing] | Creates a new `lexbuf` from the `unicode_lexbuf`.
from_unicode [Netconversion] | Maps the Unicode code point to the corresponding code point of the charset, or raises `Cannot_represent` when there is no such corresponding code point.
full_split [Netstring_pcre] | Like `split_delim`, but returns the delimiters in the result
full_split [Netstring_str] | Like `split_delim`, but returns the delimiters in the result
G
get_charset [Mimestring] | Return the decoded word (the contents of the word after decoding the "Q" or "B" representation), and the character set of the decoded word (uppercase).
get_column [Mimestring] | Return the column of the line where the token starts (first column is number 0)
get_column_of_scanner [Mimestring] | Return the current position, line, and column of a `mime_scanner`.
get_decoded_word [Mimestring] |
get_fcgi_activation [Netcgi_fcgi] | This function will accept one connection and build a cgi activation object for you.
get_fcgi_env [Netcgi_fcgi] | This function allow you to accept one connection, and get an environment object for it.
get_from_unicode [Netmappings] |
get_language [Mimestring] | Returns the language if the token is an `EncodedWord`, and `""` for all other tokens.
get_length [Mimestring] | Return the length of the token in bytes
get_line [Mimestring] | Return the line number where the token starts (numbering begins usually with 1)
get_line_of_scanner [Mimestring] |
get_pos [Mimestring] | Return the byte position where the token starts in the string (the first byte has position 0)
get_pos_of_scanner [Mimestring] |
get_to_unicode [Netmappings] |
get_token [Mimestring] | Return the `s_token` within the `s_extended_token`
global_replace [Netstring_pcre] | `global_replace re templ s`: Replaces all matchings of `re` in `s` by `templ`.
global_replace [Netstring_str] | `global_replace re templ s`: Replaces all matchings of `re` in `s` by `templ`.
global_substitute [Netstring_pcre] | `global_substitute re subst s`: Applies the substitution function `subst` to all matchings of `re` in `s`, and returns the transformed string.
global_substitute [Netstring_str] | `global_substitute re subst s`: Applies the substitution function `subst` to all matchings of `re` in `s`, and returns the transformed string.
group_beginning [Netstring_pcre] | Returns the position where the substring matching the nth group begins
group_beginning [Netstring_str] | Returns the position where the substring matching the nth group begins
group_end [Netstring_pcre] | Returns the position where the substring matching the nth group ends
group_end [Netstring_str] | Returns the position where the substring matching the nth group ends
H
html40_dtd [Nethtml] | The (transitional) HTML 4.0 DTD, expressed as `simplified_dtd`
I
index_from [Netbuffer] | `index_from nb k c`: Searches the character `c` in the netbuffer beginning at position `k`.
init_mt [Netmappings] |
insert_char [Netbuffer] | `insert_char nb p c`: Inserts character `c` at position `p` into the netbuffer `nb`
insert_string [Netbuffer] | `insert_string nb p s`: Inserts the value of string `s` at position `p` into the netbuffer `nb`
insert_sub_string [Netbuffer] | `insert_string nb p s k n`: Inserts a substring of string `s` at position `p` into the netbuffer `nb`.
int_blit [Netaux.ArrayAux] | A specialisation of `Array.blit` for int arrays.
int_series [Netaux.ArrayAux] | `int_series src srcpos dst dstpos len n`: Computes for every `i`, `0 <= i < len`: `dst.(dstpos+i) = n + SUM(j=0..(i-1): src.(srcpos+j))`
ip_url_syntax [Neturl] | Syntax for IP based protocols.
is_ascii_compatible [Netconversion] | "ASCII compatible" means: The bytes 1 to 127 represent the ASCII codes 1 to 127, and no other representation of a character contains the bytes 1 to 127.
is_single_byte [Netconversion] | Returns whether the encoding is a single-byte encoding
J
join_path [Neturl] | Concatenates the path components (reverse function of split_path).
jvm_emu_main [Netcgi_jserv] | This function fakes the "java" command (JVM startup).
L
last_chars [Netstring_pcre] | Same as `string_after`
last_chars [Netstring_str] | Same as `string_after`
length [Netbuffer] | Returns the logical length of the buffer
lexbuf_of_in_obj_channel [Netchannels] | Creates a lexical buffer from an input channel.
lexeme [Netulex.Ulexing] | Returns the lexeme as array of Unicode code points
lexeme_char [Netulex.Ulexing] | Returns the code point of a certain character of the lexeme
lexeme_end [Netulex.Ulexing] | The character position of the end of the lexeme
lexeme_length [Netulex.Ulexing] | The length of the lexeme in characters
lexeme_start [Netulex.Ulexing] | The character position of the start of the lexeme
lift_in [Netchannels] | Turns a `rec_in_channel` or `raw_in_channel`, depending on the passed variant, into a full `in_obj_channel` object.
lift_out [Netchannels] | Turns a `rec_out_channel` or `raw_out_channel`, depending on the passed variant, into a full `out_obj_channel` object.
local_path_of_file_url [Neturl] | Extracts the path from an absolute file URL, and returns a correct path name.
localzone [Netdate] | The offset in minutes for the local time zone from the UTC
lock [Netmappings] |
logger [Netcgi_jserv_app] | This variable contains the logger function.
M
make_pattern [Netaux.KMP] |
make_temporary_file [Netchannels] | Creates a temporary file in the directory `tmp_directory` with a name prefix `tmp_prefix` and a unique suffix.
make_url [Neturl] | Creates a URL from components:
makechar [Netconversion] | `makechar enc i:` Creates the string representing the Unicode code point `i` in encoding `enc`.
map_list [Nethtml] | `map_list f doclst`: Applies `f` to all attribute values and data strings (except the attributes of "?", "!", or "--" nodes).
match_beginning [Netstring_pcre] | Returns the position where the matched part begins
match_beginning [Netstring_str] | Returns the position where the matched part begins
match_end [Netstring_pcre] | Returns the position where the matched part ends
match_end [Netstring_str] | Returns the position where the matched part ends
matched_group [Netstring_pcre] | Extracts the substring the nth group matches from the whole string.
matched_group [Netstring_str] | Extracts the substring the nth group matches from the whole string.
matched_string [Netstring_pcre] | Extracts the matched part from the string.
matched_string [Netstring_str] | Extracts the matched part from the string.
mk_mail_date [Netdate] | Convert the time (seconds since the epoch) to a date string that conforms to RFC 1123 (which updates RFC 822).
mk_param [Mimestring] | Creates a parameter from a value (in decoded form).
mk_url_encoded_parameters [Netencoding.Url] | The argument is a list of (name,value) pairs.
mk_usenet_date [Netdate] | Convert the time (seconds since the epoch) to a date string that conforms to RFC 1036 (which obsoletes RFC 850).
modify_url [Neturl] | Modifies the passed components and returns the modified URL.
move [Netconversion] | Moves the cursor one character to the right, or if `num` is passed, this number of characters to the right.
N
norm_path [Neturl] | Removes `"."` and `".."` from the path if possible.
null_url [Neturl] | A URL without any component and `null_url_syntax`
null_url_syntax [Neturl] | An URL syntax that recognizes nothing.
P
param_charset [Mimestring] |
param_language [Mimestring] | Return the decoded value of the parameter, the charset (uppercase), and the language.
param_tokens [Mimestring] | Formats a parameter list.
param_value [Mimestring] |
parse [Nethtml] | Parses the HTML document from an object channel and returns it.
parse [Netdate] | Parse a string and return a date/time record
parse [Netaddress] | Parse a list of addresses in string representation, and return them as list of mailboxes or groups.
parse_document [Nethtml] | Parses the HTML document from a `lexbuf` and returns it.
parse_epoch [Netdate] | Parse a string and return the time (seconds since the epoch
parse_properties [Netcgi_jserv] | Parses a property file and returns it as alist
parse_url [Neturl] | Parses the string and returns the URL the string represents.
partial_url_syntax [Neturl] | Transforms the syntax into another syntax where all required parts are changed into optional parts.
print_buffer [Netbuffer] | For the toploop
print_in_obj_stream [Netstream] | A top-loop printer for streams
print_s_param [Mimestring] | Prints a parameter to the formatter (as toploop printer)
print_url [Neturl] | Printer for the toploop.
prng_init [Netcgi_jserv] | Initializes the PRNG and seeds it with the passed key.
prng_init_from_file [Netcgi_jserv] | Initializes the PRNG and seeds it with the contents of the passed file.
Q
quote [Netstring_pcre] | Quotes a string such that it can be included in a regexp
quote [Netstring_str] | Quotes a string such that it can be included in a regexp
R
random_8bits [Netcgi_jserv] | Returns the next byte of the PRNG
read_control_pipe [Netcgi_jserv] | Reads the next message from the control pipe, and raises either `Signal_restart` or `Signal_shutdown`.
read_header [Mimestring] | This function expects that the current position of the passed `in_obj_stream` is the first byte of the header.
read_mime_header [Netmime] | Decodes the MIME header that begins at the current position of the netstream, and returns the header as class `basic_mime_header`.
read_mime_message [Netmime] | Decodes the MIME message that begins at the current position of the passed netstream.
read_multipart_body [Mimestring] | This is the "next generation" multipart message parser.
recode [Netconversion] | Converts the character sequence contained in the at most `in_len` bytes of `in_buf` starting at byte position `in_pos`, and writes the result into at most `out_len` bytes of `out_buf` starting at byte position `out_pos`.
recode_string [Netconversion] | Recodes a complete string from `in_enc` to `out_enc`, and returns it.
refill [Netulex.ULB] | Tries to add characters to the `unicode_lexbuf` by calling the `ulb_refill` function.
regexp [Netstring_pcre] | Parses a regexp
regexp [Netstring_str] | Parses a regexp
regexp_case_fold [Netstring_pcre] | Parses a case-insensitive regexp
regexp_case_fold [Netstring_str] | Parses a case-insensitive regexp
regexp_string [Netstring_pcre] | Returns a regexp that matches exactly the string
regexp_string [Netstring_str] | Returns a regexp that matches exactly the string
regexp_string_case_fold [Netstring_pcre] | Returns a case-insensitive regexp that matches exactly the string
regexp_string_case_fold [Netstring_str] | Returns a case-insensitive regexp that matches exactly the string
reinit_cursor [Netconversion] | Reuses an existing cursor for a new purpose.
relaxed_html40_dtd [Nethtml] | A relaxed version of the HTML 4.0 DTD that matches better common practice.
remove_from_url [Neturl] | Removes the `true` components from the URL, and returns the modified URL.
replace_first [Netstring_pcre] | `replace_first re templ s`: Replaces the first match of `re` in `s` by `templ`.
replace_first [Netstring_str] | `replace_first re templ s`: Replaces the first match of `re` in `s` by `templ`.
run [Netcgi_jserv_app] | Starts the server.
S
same_encoding [Netconversion] | Whether both encodings are the same.
scan_encoded_text_value [Mimestring] | Scans a "text" value.
scan_header [Mimestring] | `let params, header_end_pos = scan_header s start_pos end_pos`:
scan_mime_type [Mimestring] | `let name, params = scan_mime_type s options`: Scans MIME types like `text/plain; charset=iso-8859-1` The name of the type and the names of the parameters are converted to lower case.
scan_mime_type_ep [Mimestring] | `let name, params = scan_mime_type_ep s options`: This version copes with RFC-2231-encoded parameters.
scan_multipart_body [Mimestring] | `let [params1, value1; params2, value2; ...] = scan_multipart_body s start_pos end_pos boundary`:
scan_multipart_body_and_decode [Mimestring] | Same as `scan_multipart_body`, but decodes the bodies of the parts if they are encoded using the methods "base64" or "quoted printable".
scan_multipart_body_from_netstream [Mimestring] | `scan_multipart_body_from_netstream s boundary create add stop`:
scan_structured_value [Mimestring] | This function is included for backwards compatibility, and for all cases not requiring extended tokens.
scan_token [Mimestring] | Returns the next token, or `End` if there is no more token.
scan_token_list [Mimestring] | Returns all following tokens as a list (excluding `End`)
scan_value_with_parameters [Mimestring] | `let name, params = scan_value_with_parameters s options`: Scans values with annotations like `name ; p1=v1 ; p2=v2 ; ...` For example, MIME types like "text/plain;charset=ISO-8859-1" can be parsed.
scan_value_with_parameters_ep [Mimestring] | `let name, params = scan_value_with_parameters_ep s options`: This version of the scanner copes with encoded parameters according to RFC 2231.
search_backward [Netstring_pcre] | Searches a match of the string with the regexp, starting at the position and in backward direction.
search_backward [Netstring_str] | Searches a match of the string with the regexp, starting at the position and in backward direction.
search_forward [Netstring_pcre] | Searches a match of the string with the regexp, starting at the position and in forward direction.
search_forward [Netstring_str] | Searches a match of the string with the regexp, starting at the position and in forward direction.
sendmail [Netsendmail] | Sends the passed message.
separates_adjacent_encoded_words [Mimestring] | True iff the current token is white space (i.e.
serv [Netcgi_fcgi] | This function "serves".
serve_connection [Netcgi_jserv_ajp12] | Serves the connection designated by the `in_obj_channel` and the `out_obj_channel`.
server [Netcgi_jserv] | The function `server` simply calls `server_init` first to get the file descriptor from the port specification, and it then calls `server_loop` to process the requests.
server_init [Netcgi_jserv] | Initializes the AJP server by listening on a TCP port.
server_loop [Netcgi_jserv] | Accepts connection coming from the web server on the `file_descr`, and calls the connection handler.
set_encoding [Netulex.ULB] | Sets the `encoding` to the passed value.
signal_restart [Netcgi_jserv] | Signals the server that a "restart" must be done.
signal_shutdown [Netcgi_jserv] | Signals the server that a "shutdown" must be done.
since_epoch [Netdate] | Convert a date/time record into the time (seconds since the epoch)
specials_rfc2045 [Mimestring] | The sets of special characters defined by the RFCs 822 and 2045.
specials_rfc822 [Mimestring] |
split [Netstring_pcre] | Splits the string according to the regexp in substrings.
split [Netstring_str] | Splits the string according to the regexp in substrings.
split_delim [Netstring_pcre] | Same as `split`, but occurrences of the delimiter at the beginning and the end are returned as empty strings
split_delim [Netstring_str] | Same as `split`, but occurrences of the delimiter at the beginning and the end are returned as empty strings
split_mime_type [Mimestring] | `let (main_type, sub_type) = split_mime_type content_type`: Splits the MIME type into main and sub type, for example `split_mime_type "text/plain" = ("text", "plain")` .
split_path [Neturl] | Splits a `'/'`-separated path into components (e.g.
split_uri [Mimestring] | Splits a long URI according to the algorithm of RFC 2017.
std_config [Netcgi_jserv_app] | The standard configuration:
storage [Netmime] | Creates a new storage facility for a mime body according to `store`.
string_after [Netstring_pcre] | The last `n` characters of a string
string_after [Netstring_str] | The last `n` characters of a string
string_before [Netstring_pcre] | The first `n` characters of a string
string_before [Netstring_str] | The first `n` characters of a string
string_match [Netstring_pcre] | Matches the string at the position with the regexp.
string_match [Netstring_str] | Matches the string at the position with the regexp.
string_of_encoding [Netconversion] | Returns the name of the encoding.
string_of_in_obj_channel [Netchannels] | Reads from the input channel until EOF and returns the characters as string.
string_of_url [Neturl] | Returns the URL as string
sub [Netbuffer] | `sub nb k n`: returns the n characters starting at position `n` from netbuffer `nb` as fresh string
sub_lexeme [Netulex.Ulexing] | Returns a substring of the lexeme as array of Unicode code points.
substitute_first [Netstring_pcre] | `substitute_first re subst s`: Applies the substitution function `subst` to the first matching of `re` in `s`, and returns the transformed string.
substitute_first [Netstring_str] | `substitute_first re subst s`: Applies the substitution function `subst` to the first matching of `re` in `s`, and returns the transformed string.
T
tcp_port [Netpop] | Default TCP port for POP version 3
tempfile_transactional_optype [Netcgi] | A predefined transactional `operating_type` using a temporary file to store the not yet completed transaction
to_unicode [Netconversion] | Maps the code point of the charset to the corresponding Unicode code point, or raises `Malformed_code`, when the input number does not correspond to a code point.
try_shrinking [Netbuffer] | `try_shrinking nb`: If the length of the buffer is less than half of the allocated space, the netbuffer is reallocated in order to save memory.
U
uarray_of_ustring [Netconversion] | Returns the characters of the string as array of Unicode code points.
uchar_at [Netconversion] | Returns the Unicode code point of the character at the cursor.
undefault_url [Neturl] | Removes components from the URL if they have the passed value, and returns the modified URL.
unlock [Netmappings] |
unsafe_buffer [Netbuffer] | Warning! This is a low-level function! Returns the current string that internally holds the buffer.
unsafe_chars_html4 [Netencoding.Html] | The string contains '<', '>', '"', '&' and the control characters 0-8, 11-12, 14-31, 127.
url_encode [Netencoding.Base64] | Same as `encode` but use slightly different characters that can be part of URLs without additional encodings.
url_fragment [Neturl] |
url_host [Neturl] |
url_of_string [Neturl] | Parses the passed string according to the passed `url_syntax`.
url_other [Neturl] | Return components of the URL.
url_param [Neturl] |
url_password [Neturl] |
url_path [Neturl] |
url_port [Neturl] |
url_provides [Neturl] | Returns `true` iff the URL has all of the components passed with `true` value.
url_query [Neturl] |
url_scheme [Neturl] |
url_syntax_is_valid [Neturl] | Checks whether the passed `url_syntax` is valid.
url_syntax_of_url [Neturl] | Returns the `url_syntax` record of a URL.
url_user [Neturl] |
url_user_param [Neturl] |
ustring_compare [Netconversion] | Compares two strings lexicographically.
ustring_iter [Netconversion] | Iterates over the characters of a string, and calls the passed function for every code point.
ustring_length [Netconversion] | Returns the length of the string in characters.
ustring_map [Netconversion] | Maps every character of a string to a list of characters, and returns the concatenated string.
ustring_of_uarray [Netconversion] | Returns the array of Unicode code points as encoded string.
ustring_of_uchar [Netconversion] | `ustring_of_uchar enc i`: Creates the string representing the Unicode code point `i` in encoding `enc`.
ustring_sub [Netconversion] | `ustring_sub enc start length s`: Returns the substring of `s` starting at character count `start` and consisting of `length` characters.
utf8_lexeme [Netulex.Ulexing] | Returns the lexeme as UTF-8 encoded string
utf8_sub_lexeme [Netulex.Ulexing] | Returns a substring of the lexeme as UTF-8 encoded string.
utf8_sub_lexeme_length [Netulex.Ulexing] | Same as String.length(utf8_sub_lexeme args), i.e.
utf8_sub_string [Netulex.ULB] | The two `int` arguments are the position and length of a sub string of the lexbuf that is returned as UTF8 string.
utf8_sub_string_length [Netulex.ULB] | Returns `String.length(utf8_sub_string args)`.
V
verify [Netconversion] | Checks whether the string is properly encoded.
W
with_in_obj_channel [Netchannels] | `with_in_obj_channel ch f`: Computes `f ch` and closes `ch`.
with_out_obj_channel [Netchannels] | `with_out_obj_channel ch f`: Computes `f ch` and closes `ch`.
wrap_attachment [Netsendmail] | Generates a header for the `mime_body`.
wrap_mail [Netsendmail] | Sets the mail-related header fields in the input message, and returns a message ready for delivery.
wrap_parts [Netsendmail] | Generates an intermediate container for multipart attachments.
write [Nethtml] | Writes the document to the output channel.
write_header [Mimestring] | This function writes the header to the passed `out_obj_channel`.
write_mime_message [Netmime] | Writes the MIME message to the output channel.
write_value [Mimestring] | Writes the list of `s_token` to the `out_obj_channel`.