| (++) [Uq_engines.Operators] | 
Another name for  qseq_engine. | 
| (<&) [Shell] | 
Same as  assign, but infix notation. | 
| (>&) [Shell] | 
Same as  assign, but infix notation. | 
| (>>) [Uq_engines.Operators] | 
Another name for  fmap_engine. | 
| _exit [Netsys] | 
Exit the program immediately without running the atexit handlers.
 | 
| _of_PMAP'V2'pmapproc_callit'arg [Rpc_portmapper_aux] | |
| _of_PMAP'V2'pmapproc_callit'res [Rpc_portmapper_aux] | |
| _of_PMAP'V2'pmapproc_dump'arg [Rpc_portmapper_aux] | |
| _of_PMAP'V2'pmapproc_dump'res [Rpc_portmapper_aux] | |
| _of_PMAP'V2'pmapproc_getport'arg [Rpc_portmapper_aux] | |
| _of_PMAP'V2'pmapproc_getport'res [Rpc_portmapper_aux] | |
| _of_PMAP'V2'pmapproc_null'arg [Rpc_portmapper_aux] | |
| _of_PMAP'V2'pmapproc_null'res [Rpc_portmapper_aux] | |
| _of_PMAP'V2'pmapproc_set'arg [Rpc_portmapper_aux] | |
| _of_PMAP'V2'pmapproc_set'res [Rpc_portmapper_aux] | |
| _of_PMAP'V2'pmapproc_unset'arg [Rpc_portmapper_aux] | |
| _of_PMAP'V2'pmapproc_unset'res [Rpc_portmapper_aux] | |
| _of_call_args [Rpc_portmapper_aux] | |
| _of_call_result [Rpc_portmapper_aux] | |
| _of_mapping [Rpc_portmapper_aux] | |
| _of_pmaplist [Rpc_portmapper_aux] | |
| _of_pmaplist_p [Rpc_portmapper_aux] | |
| _program [Rpc_portmapper_clnt.PMAP.V2] | |
| _program [Rpc_portmapper_clnt.Make'PMAP.V2] | |
| _to_PMAP'V2'pmapproc_callit'arg [Rpc_portmapper_aux] | |
| _to_PMAP'V2'pmapproc_callit'res [Rpc_portmapper_aux] | |
| _to_PMAP'V2'pmapproc_dump'arg [Rpc_portmapper_aux] | |
| _to_PMAP'V2'pmapproc_dump'res [Rpc_portmapper_aux] | |
| _to_PMAP'V2'pmapproc_getport'arg [Rpc_portmapper_aux] | |
| _to_PMAP'V2'pmapproc_getport'res [Rpc_portmapper_aux] | |
| _to_PMAP'V2'pmapproc_null'arg [Rpc_portmapper_aux] | |
| _to_PMAP'V2'pmapproc_null'res [Rpc_portmapper_aux] | |
| _to_PMAP'V2'pmapproc_set'arg [Rpc_portmapper_aux] | |
| _to_PMAP'V2'pmapproc_set'res [Rpc_portmapper_aux] | |
| _to_PMAP'V2'pmapproc_unset'arg [Rpc_portmapper_aux] | |
| _to_PMAP'V2'pmapproc_unset'res [Rpc_portmapper_aux] | |
| _to_call_args [Rpc_portmapper_aux] | |
| _to_call_result [Rpc_portmapper_aux] | |
| _to_mapping [Rpc_portmapper_aux] | |
| _to_pmaplist [Rpc_portmapper_aux] | |
| _to_pmaplist_p [Rpc_portmapper_aux] | |
| A | |
| abandon_call [Rpc_client] | 
To be used in conjunction with  Rpc_client.Keep_call: The call
      with this session identifier is no longer expected, and removed
      from the internal data structures. | 
| abandon_job [Shell_sys] | 
Deprecated name for  cancel_job | 
| ac_by_host [Nethttpd_services] | 
Configures host-based access control
 | 
| accelerated_pollset [Netsys_pollset_posix] | 
Returns a pollset using a "fast" poll mechanism, if available.
 | 
| access [Netplex_mutex] | 
Access the named mutex.
 | 
| access [Netmcore_buffer] | access b pos f: Gets access to the internal string backing the
      byte at positionpos. | 
| act_events_of_event_source [Netsys_posix] | 
Return the actual events of the source.
 | 
| act_events_of_int [Netsys_posix] | |
| add [Netshm_hashtbl] | add tbl key value: Adds the binding ofkeytovalueto the
 table. | 
| add [Netshm] | add tbl key value: Adds the binding ofkeytovalueto the
 table. | 
| add [Netmcore_hashtbl] | add tbl x yadds a binding ofxtoyin tabletbl. | 
| add [Netmcore_heap] | 
Pushes a new value onto the heap.
 | 
| add [Netcgi_apache.Apache.Table] | Table.add tbl key valueadds the(key, value)pair in
          the tabletbl. | 
| add [Uq_libevent.LIBOEVENT] | |
| add_1_complement [Netauth] | 
The addition algorithm for 1's-complement numbers.
 | 
| add_abort_action [Unixqueue] | 
An abort action is added to the group.
 | 
| add_buffer [Netbuffer] | add_buffer nb1 nb2: Adds the contents ofnb2to the end ofnb1 | 
| add_call [Rpc_client] | add_call client proc_name arg f: add the call to the procedurenamewith argumentargto the queue of unprocessed calls. | 
| add_char [Netbuffer] | add_char nb c: Adds a single char at the end of the buffer | 
| add_char_2 [Netbuffer] | add_char_2 nb c1 c2: Adds two chars at the end of the buffer | 
| add_char_4 [Netbuffer] | add_char_4 nb c1 c2 c3 c4: Adds four chars at the end of the buffer | 
| add_close_action [Unixqueue] | 
A close action is added for the file descriptor.
 | 
| add_command [Shell_sys] | 
Adds a command to a job.
 | 
| add_consumer [Shell_sys] | 
Adds a consumer to the job.
 | 
| add_event [Unixqueue] | 
Add an additional event.
 | 
| add_event [Equeue] | 
Puts an event into the event queue of the system.
 | 
| add_event_source [Netsys_posix] | 
Adds the event source to the aggregator
 | 
| add_handler [Unixqueue] | 
Add an event handler that is associated to the given group.
 | 
| add_handler [Equeue] | 
Adds a handler to the list of handlers of the system.
 | 
| add_helper_service [Netplex_kit] | add_helper_service ctrl name hooks: Adds a helper servicenameto
      the controllerctrl. | 
| add_immutable [Netmcore_heap] | 
Pushes a new value onto the heap.
 | 
| add_init_array [Netmcore_heap] | add_init_array m n f: Pushes a new value with n elements onto
      the heap. | 
| add_inplace [Netpagebuffer] | add_inplace b f: Callsf m pos lenwheremis the last page
      of the buffer, andposis the first free byte on the page, andlenis the number of free bytes on the page. | 
| add_inplace [Netbuffer] | add_inplace nb f: Calls the functionfto add bytes to the
 netbuffernb. | 
| add_pipeline [Shell_sys] | 
Adds a pipeline which redirects the output of the command  srcto the
 input of the commanddest. | 
| add_plugins [Netmcore] | 
To enable compute processes for any Netplex program, call this
      function with the controller object as argument.
 | 
| add_producer [Shell_sys] | 
Adds a producer to the job.
 | 
| add_resource [Unixqueue] | 
Add a resource such that it is watched for conditions described
 by the  operationfor the period given by thefloatnumber. | 
| add_some [Netmcore_heap] | add_some mut x: ReturnsSome xwhere the O'Caml value representingSomeis allocated in the heap usingmut. | 
| add_string [Netpagebuffer] | 
Adds a string to the end of the buffer
 | 
| add_string [Netbuffer] | add_string nb s: Adds a copy of the stringsto the logical end of
 the netbuffernb. | 
| add_string [Netmcore_buffer] | 
Adds a string to the end of the buffer
 | 
| add_string [Netmcore_heap] | let s = add_string mut len: Adds an uninitialized string of lengthlento the heap usingmut, and returns the string | 
| add_sub_memory [Netpagebuffer] | 
Adds a sub memory buffer to the end of the buffer
 | 
| add_sub_memory [Netbuffer] | 
Same as  add_sub_string, but gets data from a memory buffer | 
| add_sub_memory [Netmcore_buffer] | 
Adds a sub memory buffer to the end of the buffer
 | 
| add_sub_string [Netpagebuffer] | 
Adds a sub string to the end of the buffer
 | 
| add_sub_string [Netbuffer] | add_sub_string nb s k n: Adds the substring ofsstarting at positionkwith lengthnto the logical end of the netbuffernb. | 
| add_sub_string [Netmcore_buffer] | 
Adds a sub string to the end of the buffer
 | 
| add_substring [Netbuffer] | 
Alias for add_sub_string
 | 
| add_uniform_array [Netmcore_heap] | add_uniform_array m n x: Pushes a new value with n elements onto
      the heap. | 
| add_weak_resource [Unixqueue] | 
Similar to  add_resource, but the resource is weak. | 
| admin [Netcgi_apache.Apache.Server] | server_adminfield. | 
| admin_connector [Netplex_cenv] | 
Determines the admin socket of the controller, and returns an RPC
      client connector suitable for connecting with the admin interface
      of the controller.
 | 
| advance [Netpagebuffer] | advance b n: Marks furthernbytes in the last page of the
      buffer as used. | 
| advance [Netbuffer] | 
These two functions work together, so that the effect of  add_inplacecan be obtained in two steps. | 
| ajp_processor [Netcgi_plex] | |
| all_decoders [Netcompression] | 
The iana names of all encoders and decoders, resp.
 | 
| all_encoders [Netcompression] | |
| alloc_aligned_memory [Netsys_mem] | alloc_aligned_memory alignment size: Allocates a buffer ofsizewhose start address is a multiple ofalignment. | 
| alloc_mem [Netmcore_mempool] | 
Allocate memory in this pool.
 | 
| alloc_memory_pages [Netsys_mem] | 
Allocates memory in units of pages.
 | 
| alloc_wait_entry [Netmcore_condition] | 
Allocates a  wait_entry | 
| alloc_wait_entry_e [Netmcore_condition] | alloc_wait_entry_e mut set filename: Allocates a new wait entry
      with notification via named pipe. | 
| any_file_client_connector [Netplex_sockserv] | 
Interprets a file name as connector for a local RPC service.
 | 
| apply_relative_url [Neturl] | apply_relative_url base rel:
 Interpretsrelrelative tobaseand returns the new URL. | 
| are_compatible [Xdr] | are_compatible: currently not implemented | 
| area_for_additions [Netbuffer] | |
| arg_parse [Netcgi_ajp] | arg_parse speclist anon_fun usage_msgparses the command line
      and return an associative list describing the content of the
      property file (seeNetcgi_ajp.props_of_file). | 
| args [Netplex_main] | let (opt_list, cmdline_cfg) = args():
 Returnsopt_listfor inclusion in theArg.parseoption list. | 
| args [Netcgi_apache.Apache.Request] | request_recargsfield. | 
| as_obj [Netsys_mem] | 
Same as  as_valuebut returns the value asObj.t | 
| as_process_event [Netsys_win32] | 
Casts the process handle to an event handle.
 | 
| as_sem [Netsys_sem] | as_sem mem pos: Interprets the memory at positionpostopos + sem_size() - 1as anonymous semaphore. | 
| as_sem [Netsys_posix] | as_sem mem pos: Interprets the memory at positionpostopos + sem_size() - 1as anonymous semaphore. | 
| as_value [Netsys_mem] | as_value mem offset: Returns a pointer tomem+offset. | 
| assbackwards [Netcgi_apache.Apache.Request] | request_recassbackwardsfield;trueif HTTP/0.9,
	  "simple" request. | 
| assign [Shell] | 
Arranges a redirection such that writing to  srcor reading fromsrcwill actually write totargetor read fromtarget(i.e., thetargetdescriptor is duplicated and replaces
 thesrcdescriptor just before the process is launched.) | 
| assign [Netmcore_ref] | assign sr x: Sets the contents ofsrto a deep copy ofx. | 
| assigned_pair [Shell] | 
Returns the target and the source of the assignment as
 pair of descriptors  (target,src). | 
| at_fdcwd [Netsys_posix] | 
Pseudo descriptor value to be used as first argument of  *atfunctions | 
| auth_none [Rpc_server] | 
The authentication method "AUTH_NONE", i.e.
 | 
| auth_none [Rpc_client] | 
The authentication method that does not perform authentication.
 | 
| auth_too_weak [Rpc_server] | 
The method that always rejects.
 | 
| auth_transport [Rpc_server] | 
Authenticate by trusting the transport layer.
 | 
| auth_type [Netcgi_apache.Apache.Request] | |
| 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 | |
| base_code [Nethttp] | 
Allows to handle unknown status codes that are untranslatable by
       http_status_of_int: for a code 100 to 199 the value 100 is returned, for a code 200 to 299 the value 200 is returned, for a code 300 to 399 the value 300 is returned, for a code 400 to 499 the value 400 is returned, for all other codes 500 is returned
      E.g. | 
| best_charset [Nethttp.Header] | 
Returns the best charset for a header and a list of supported charsets.
 | 
| best_encoding [Nethttp.Header] | 
Returns the best encoding for a header and a list of supported
 encodings.
 | 
| best_locking_method [Netshm] | 
Return the best locking method other than  No_locking | 
| best_media_type [Nethttp.Header] | 
Returns the best media type for a header and a list of supported types.
 | 
| bg_blue [Netsys_win32] | |
| bg_green [Netsys_win32] | |
| bg_intensity [Netsys_win32] | 
Bits of  text_attr | 
| bg_red [Netsys_win32] | |
| bigarray [Netshm] | |
| bind [Rpc_server] | 
Binds the program as specified by the  binding list. | 
| bind [Rpc_client] | 
Binds this program additionally
 | 
| blit [Netbuffer] | 
Compatibility name for  blit_to_string, now deprecated | 
| blit_from_string [Netbuffer] | blit_from_string src srcpos dest destpos len: Copies thelenbytes
 at positionsrcposfrom the stringsrcto the netbufferdestat
 positiondestpos. | 
| blit_memory_to_string [Netsys_mem] | blit_memory_to_string src srcoff dst dstoff lencopieslencharacters
      from buffersrc, starting at character numbersrcoff, to
      stringdst, starting at character numberdstoff | 
| blit_memory_to_string_unsafe [Netsys_mem] | 
Unsafe version
 | 
| blit_mstrings_to_memory [Xdr_mstring] | 
blits the mstrings one after the other to the memory, so that
      they appear there concatenated
 | 
| blit_poll_array [Netsys_posix] | blit_poll_array a1 p1 a2 p2 len: Copies thelencells at indexp1froma1toa2at indexp2. | 
| blit_string_to_memory [Netsys_mem] | blit_string_to_memory src srcoff dst dstoff lencopieslencharacters
      from stringsrc, starting at character numbersrcoff, to
      bufferdst, starting at character numberdstoff | 
| blit_string_to_memory_unsafe [Netsys_mem] | 
Unsafe version
 | 
| blit_to_memory [Netpagebuffer] | 
Blits contents to another memory buffer
 | 
| blit_to_memory [Netbuffer] | blit_to_memory nb srcpos dest destpos len: Copies thelenbytes at
  positionsrcposfromnbto the membufferdestat positiondestpos. | 
| blit_to_memory [Netmcore_buffer] | 
Blits contents to a memory buffer
 | 
| blit_to_string [Netpagebuffer] | 
Blits contents to a string
 | 
| blit_to_string [Netbuffer] | blit_to_string nb srcpos dest destpos len: Copies thelenbytes at
 positionsrcposfromnbto the stringdestat positiondestpos. | 
| blit_to_string [Netmcore_buffer] | 
Blits contents to a string
 | 
| blocking_gread [Netsys] | let p = blocking_gread fd_style fd s pos len: 
      Likegreadup tolenbytes are read fromfdand stored ins. | 
| blocking_read [Netsys] | 
Same as  blocking_gread `Read_write | 
| blocking_socket_config [Rpc_client] | 
Configuration with  non_blocking_connect= false | 
| bool_var [Netplex_cenv] | 
Access a variable with simple type.
 | 
| bound_programs [Rpc_server] | 
Returns the bound programs
 | 
| bounded_full_split [Netstring_pcre] | 
Like  split_delim, but returns the delimiters in the result | 
| bounded_full_split [Netstring_str] | 
Splits into at most  nsubstrings, based onfull_split | 
| bounded_split [Netstring_pcre] | 
Splits the string according to the regexp in substrings.
 | 
| bounded_split [Netstring_str] | 
Splits into at most  nsubstrings, based onsplit | 
| bounded_split_delim [Netstring_pcre] | 
Same as  split, but occurrences of the delimiter at the beginning 
 and the end are returned as empty strings | 
| bounded_split_delim [Netstring_str] | 
Splits into at most  nsubstrings, based onsplit_delim | 
| broadcast [Netmcore_condition] | broadcast crestarts all processes waiting on the
      condition variablec. | 
| buffer_of_descr [Netmcore_buffer] | 
Look up the buffer for this descriptor
 | 
| buffered_transactional_optype [Netcgi1_compat.Netcgi] | |
| buffered_transactional_optype [Netcgi] | 
Deprecated name for  buffered_transactional_outtype | 
| buffered_transactional_outtype [Netcgi] | 
The  output_typeimplementing transactions with a RAM-based buffer | 
| 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 | |
| c [Netmech_scram.AES_CTS] | |
| cache [Uq_engines] | 
Same as function
 | 
| call [Shell] | 
Starts the pipeline represented by the list of commands; i.e.
 | 
| call [Shell_sys] | 
Executes the command and waits until the process terminates
 (synchronous execution a la  system, but no intermediate shell). | 
| call [Rpc_simple_client] | call simple_client procedure_name procedure_arg:
 Call the procedure with the given name and the given argument. | 
| call_job [Shell_sys] | 
Starts the job (see  run_job) and waits until it finishes (seefinish_job); i.e. | 
| callit [Rpc_portmapper] | callit pm_client program_spec proc_name argument:
 This is an alternate way of calling a remote procedure. | 
| camlbox_addr [Netcamlbox] | 
returns the address
 | 
| camlbox_bcapacity [Netcamlbox] | 
same for an already opened box
 | 
| camlbox_bmessages [Netcamlbox] | 
same for an already opened box
 | 
| camlbox_bmsg_size [Netcamlbox] | 
same for an already opened box
 | 
| camlbox_cancel_wait [Netcamlbox] | 
Cancels a  camlbox_waitoperation called by a different thread | 
| camlbox_capacity [Netcamlbox] | 
Returns the maximum number of messages  n | 
| camlbox_delete [Netcamlbox] | camlbox_delete box k: Deletes the message numberkfrombox. | 
| camlbox_fd [Netcamlbox] | 
Opens a new file descriptor to this address
 | 
| camlbox_get [Netcamlbox] | camlbox_get box k: Returns message numberkfrombox. | 
| camlbox_get_copy [Netcamlbox] | camlbox_get box k: Returns a deep copy of message numberkfrombox. | 
| camlbox_messages [Netcamlbox] | 
Returns the number of messages at the moment
 | 
| camlbox_msg_size [Netcamlbox] | 
Returns the max size of a message in bytes
 | 
| camlbox_saddr [Netcamlbox] | 
returns the address
 | 
| camlbox_scapacity [Netcamlbox] | 
same for a box already opened for sending
 | 
| camlbox_send [Netcamlbox] | 
Sends a message to a camlbox.
 | 
| camlbox_sender [Netcamlbox] | 
Prepares for sending.
 | 
| camlbox_sender_of_fd [Netcamlbox] | 
Gets a sender for a file descriptor from  camlbox_fd. | 
| camlbox_smessages [Netcamlbox] | 
same for a box already opened for sending
 | 
| camlbox_smsg_size [Netcamlbox] | 
same for a box already opened for sending
 | 
| camlbox_wait [Netcamlbox] | 
Waits until new messages arrive, and return the message numbers.
 | 
| camlbox_wake [Netcamlbox] | 
Sends an "empty message" - this only means that if the receiving
      thread is waiting for new messages it is interrupted and 
       camlbox_waitwill return the empty list. | 
| cancel_all_timers [Netplex_cenv] | 
Cancels all active timers
 | 
| cancel_input_thread [Netsys_win32] | 
Stops the input thread.
 | 
| cancel_job [Shell_sys] | 
Tries to get rid of a running job.
 | 
| cancel_output_thread [Netsys_win32] | 
Stops the output thread.
 | 
| cancel_timer [Netplex_cenv] | 
Cancels the timer: The callback function is not called any longer
 | 
| cgi_with_args [Netcgi_common] | cgi_with_args (new cgi) env out op ?put_arg in_chanconstructs
      aNetcgi.cgiobject. | 
| channel_logger [Netlog] | channel_logger ch lev: Prints all messages with a level oflevand higher to the channelch. | 
| channel_logger [Netplex_log] | 
Outputs messages to the channel
 | 
| channel_logger_from_obj [Netplex_log] | 
Outputs messages to the channel
 | 
| char_of_option [Telnet_client] | 
Converts the option name to the character representing it on the
 octet-stream level.
 | 
| check_directory_glob_expr [Netglob] | 
If the last component of the glob expression matches only directories
 because it ends with a literal  /character, the valueSome expr'is
 returned whereexpr'matches the same path without the trailing/. | 
| check_rooted_glob_expr [Netglob] | 
If the glob expression matches the root directory (i.e.
 | 
| chmod_shm [Netshm] | |
| chown_shm [Netshm] | 
Set file permission bits, user and group ownership of the object
 | 
| ci_code_cmp [Netconversion] | 
A compare function for  ustring_compare: Case-insensitive comparison:
      This function compares by the lowercase code point if it exists, 
      and the untransformed code point otherwise. | 
| clear [Netpagebuffer] | 
Deletes all contents of the buffer
 | 
| clear [Netbuffer] | 
Deletes all contents from the buffer.
 | 
| clear [Netmcore_hashtbl] | 
Empty a hash table.
 | 
| clear [Netmcore_buffer] | 
Deletes all contents of the buffer
 | 
| clear [Netmcore_queue] | 
Removes all elements from the queue
 | 
| clear [Netcgi_apache.Apache.Table] | Table.clear tblremoves all key/value pairs from the tabletbl. | 
| clear [Unixqueue] | 
Terminate the whole group.
 | 
| clear_close_on_exec [Netsys] | 
Working versions of the functions with the same name in  Unix | 
| clear_console [Netsys_win32] | 
Clears the screen and the buffer, and sets the cursor to (0,0).
 | 
| clear_until_end_of_line [Netsys_win32] | 
Writes a space character from the current cursor position to the
      end of the line
 | 
| clear_until_end_of_screen [Netsys_win32] | 
Writes a space character from the current cursor position to the
      end of the screen
 | 
| client_auth_method [Rpc_auth_gssapi] | 
Creates an authentication method from a GSS-API interface.
 | 
| client_auth_method [Rpc_auth_sys] | 
Pass the result of this function to  Rpc_client.set_auth_methodsto
 configure client authentication. | 
| client_auth_method [Rpc_auth_dh] | 
Creates a new authentication method using AUTH_DH.
 | 
| client_channel_binding [Netmech_scram] | 
Returns the channel binding ("" of none)
 | 
| client_configure_channel_binding [Netmech_scram] | 
Instruct the client to require a channel binding.
 | 
| client_connector [Netplex_sockserv] | 
Returns the RPC client connector for this Netplex address
 | 
| client_emit_flag [Netmech_scram] | 
Whether  client_emit_messagecan now be called | 
| client_emit_message [Netmech_scram] | 
Emits the next message to be sent to the server
 | 
| client_endpoint [Uq_engines] | 
Returns the client endpoint contained in the  connect_status | 
| client_error_flag [Netmech_scram] | 
Whether an error occurred, and the protocol cannot advance anymore
 | 
| client_export [Netmech_scram] | |
| client_finish_flag [Netmech_scram] | 
Whether the client is authenticated and the server verified
 | 
| client_import [Netmech_scram] | 
Exports a client session as string, and imports the string again.
 | 
| client_protocol_key [Netmech_scram] | 
The 128-bit protocol key for encrypting messages.
 | 
| client_recv_flag [Netmech_scram] | 
Whether  client_recv_messagecan now be called | 
| client_recv_message [Netmech_scram] | 
Receives the next message from the server
 | 
| client_socket [Uq_engines] | 
For backward compatibility.
 | 
| client_user_name [Netmech_scram] | 
The user name
 | 
| clock_getcpuclockid [Netsys_posix] | 
Return the ID of a clock that counts the CPU seconds of the given
      process.
 | 
| clock_getres [Netsys_posix] | 
Get the resolution of this clock
 | 
| clock_gettime [Netsys_posix] | 
Get the time of this clock
 | 
| clock_settime [Netsys_posix] | 
Set the time of this clock
 | 
| clone [Netcgi.Argument] | |
| close [Netulex.ULB] | 
Sets  ulb_eofof theunicode_lexbuf. | 
| close [Netcgi_dbi.DBI_DRIVER] | |
| close_connection_cache [Http_client] | 
Closes all descriptors known to the cache
 | 
| close_output_thread [Netsys_win32] | 
Adds the EOF condition to the buffer.
 | 
| close_process [Netsys_win32] | 
Closes the handle in the  w32_processvalue, if it is still open | 
| close_server_socket [Netplex_sockserv] | 
Closes a socket as opened with  create_server_socket | 
| close_shm [Netshm] | 
Closes the object.
 | 
| closed [Netcgi_dbi.DBI_DRIVER] | |
| closelog [Netsys_posix] | 
Closes the log stream
 | 
| cmd [Shell] | 
The same as  commandbut with a slightly different interface: Useinstead of | 
| cmd_interpreter [Shell_fs] | 
Creates a command interpreter from a function that creates the
      real command (as pipeline) to execute
 | 
| cmp_string [Netsys_mem] | 
Compares two strings like  String.compare. | 
| code_cmp [Netconversion] | 
A compare function for  ustring_compare: Normal string comparison:
      This function compares by code point | 
| color [Netsys_mem] | 
Return the GC color
 | 
| command [Shell] | 
Creates a command descriptor, to be used in  call. | 
| command [Shell_sys] | 
Creates a command from the passed arguments:
 | 
| command_of_process [Shell_sys] | 
Returns the command that is now running as the process
 | 
| comment [Nethttp.Cookie] | 
Returns the comment associated to the cookie or  ""if it
        does not exists. | 
| comment [Netcgi.Cookie] | 
Returns the comment associated to the cookie or  ""if it
        does not exists. | 
| comment [Netcgi_common.Cookie] | 
Returns the comment associated to the cookie or  ""if it
	does not exists. | 
| comment_url [Nethttp.Cookie] | 
Returns the comment URL associated to the cookie or  ""if it
        does not exists. | 
| comment_url [Netcgi.Cookie] | 
Returns the comment URL associated to the cookie or  ""if it
        does not exists. | 
| comment_url [Netcgi_common.Cookie] | 
Returns the comment URL associated to the cookie or  ""if it
	does not exists. | 
| commit [Netcgi_dbi.DBI_DRIVER] | |
| common_url_syntax [Neturl] | 
Syntax descriptions for common URL schemes.
 | 
| compare [Rpc_proxy.ManagedClient] | ManagedClientcan be used withSet.MakeandMap.Make | 
| compile_l9n [Netdate] | 
Preprocess the localization data for faster parsing and printing
 | 
| compose [Netsendmail] | 
Composes a mail message with a main text, and optionally
 a number of attachments.
 | 
| concat_mstrings [Xdr_mstring] | 
concatenates the mstrings and return them as single string.
 | 
| config_filename [Netplex_main] | 
Returns the filename of the configuration file, or the default
      if it has not been set on the command-line
 | 
| config_filename_opt [Netplex_main] | 
Returns the filename of the configuration file, or  Noneif it
      has not been set on the command-line | 
| config_tree_opt [Netplex_main] | 
Returns the tree of the configuration file, or  Noneif it
      has not been set bycreateormodify. | 
| configure [Rpc_client] | configure client retransmissions timeout:
 sets the number of retransmissions and the timeout for the next calls. | 
| configure_job_handlers [Shell_sys] | 
Configures signal and at_exit handlers for jobs: The keyboard signals SIGINT and SIGQUIT are forwarded to all jobs
   which are running in the background (and thus are not
   automatically notified) and want to get such signals ( forward_signals)., The signals SIGTERM and SIGHUP are (if the handler is installed) 
   forwarded to all dependent processes (regardless whether they are
   running in their own Unix process group or not, and regardless offorward_signals)., Theat_exithandler sends a SIGTERM to all dependent processes, too.
 In previous versions of Ocamlnet it was also possible to configurecatch_sigchldto set whether a SIGCHLD handler is installed. | 
| configure_next_call [Rpc_client] | 
Same as  configure, but it only affects the next call | 
| configure_pipeline [Http_client.Convenience] | 
This function will be called before the pipeline is used.
 | 
| connect [Netcgi_dbi.DBI_DRIVER] | |
| connect_check [Netsys] | 
Tests whether the socket is connected with the peer after calling
       Unix.connect. | 
| connect_method [Ftp_client] | 
This method connects to the  host | 
| connection [Netcgi_apache.Apache.Request] | request_recconnectionfield. | 
| connector [Uq_engines] | 
This engine connects to a socket as specified by the  connect_address,
 optionally using theproxy, and changes to the state`Done(status)when the connection is established. | 
| connector_of_sockaddr [Rpc_server] | 
Converts the socket address into a connector
 | 
| connector_of_sockaddr [Rpc_client] | 
Converts the socket address into a connector
 | 
| connector_of_socksymbol [Rpc_server] | 
Converts the  Netsockaddr.socksymbolinto a connector | 
| connector_of_socksymbol [Rpc_client] | 
Converts the  Netsockaddr.socksymbolinto a connector | 
| const_err_event [Netsys_posix] | |
| const_hup_event [Netsys_posix] | |
| const_nval_event [Netsys_posix] | |
| const_pri_event [Netsys_posix] | |
| const_rd_event [Netsys_posix] | |
| const_wr_event [Netsys_posix] | |
| constant_workload_manager_factory [Netplex_workload] | 
Reads a workload_manager section like
 | 
| consume_event [Netsys_posix] | 
Consumes the event, and switches the event fd to off again.
 | 
| container [Netsys_sem] | container prefix: The prefix shall identify the container uniquely. | 
| content_type [Netcgi_apache.Apache.Request] | request_reccontent_typefield. | 
| contents [Netpagebuffer] | 
Returns the contents as string
 | 
| contents [Netbuffer] | 
Returns the contents of the buffer as fresh string.
 | 
| contents [Netmcore_buffer] | 
Returns the full contents
 | 
| convert [Netconversion] | 
Converts the string from  in_enctoout_enc, and returns it. | 
| convert_path [Netfs] | convert_path oldfs newfs oldpath: The encoding ofoldpath(which is assumed to reside inoldfs) is converted to the encoding
      ofnewfsand returned. | 
| copy [Netfs] | copy orig_fs orig_name dest_fs dest_name: Copies the fileorig_namefromorig_fsto the filedest_nameindest_fs. | 
| copy [Netmcore_heap] | 
Creates a deep copy of the input value, and stores the duplicate
      in normal process memory.
 | 
| copy_command [Shell_sys] | 
Returns a duplicate of the command description
 | 
| copy_cursor [Netconversion] | 
Copies the cursor.
 | 
| copy_e [Uq_io] | let e = copy_e d_in d_out: Copies data fromd_intod_out,
      and transitions to`Done nwhen all data is copied (wherenare the number of copied bytes). | 
| copy_env [Shell_sys] | 
Copies an environment
 | 
| copy_into [Netfs] | copy_into orig_fs orig_name dest_fs dest_name: 
      Likecopy, but this version also supports recursive copies. | 
| copy_mstring [Xdr_mstring] | 
Create a copy
 | 
| copy_mstrings [Xdr_mstring] | 
Create a copy
 | 
| copy_value [Netsys_mem] | copy_value flags v: Creates a deep copy ofvand returns it. | 
| cots_connect [Rpc_xti_client] | 
The first parameter is the name of the TLI/XTI device.
 | 
| cp_set_env [Netsys_win32] | 
Returns the  CP_set_envoption for this array of environment
      variables (in theUnix.environmentformat) | 
| create [Rpc_server] | 
Deprecated creation of an RPC server.
 | 
| create [Rpc_portmapper] | 
Connects to the portmapper service listening on the given connector.
 | 
| create [Rpc_simple_client] | 
Create a simple client that connects with the given server using
 the given protocol type.
 | 
| create [Rpc_client] | 
Opens a connection to the server specified by the  connector. | 
| create [Rpc_program] | create program_nr version_nr type_system procedures | 
| create [Rpc_key_service] | 
Connects to the keyserv daemon.
 | 
| create [Netpagebuffer] | 
create  blocksize: creates new buffer with thisblocksize, which must
      be a whole multiple of the page size of the OS | 
| 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 [Netplex_mbox.MBOX] | 
Creates a new mailbox with the passed name, or opens an existing
        mailbox.
 | 
| create [Netplex_semaphore] | 
Create the semaphore with this initial value.
 | 
| create [Netplex_main] | 
Creates the command-line configuration object.
 | 
| create [Netmcore_hashtbl] | Hashtbl.create pool hcreates a new, empty hash table inpoolwith a headerh. | 
| create [Netmcore_matrix] | create pool_id n2 a h:
      Creates a matrix by deeply copying a normal arrayaand using the copy ofhas header. | 
| create [Netmcore_buffer] | create pool bsize h: Creates a buffer inpoolwith a block
      size ofbsize. | 
| create [Netmcore_queue] | create pool h: Creates an empty queue in thepool, with headerh | 
| create [Netmcore_mutex] | create m t: Creates a mutex of typet, and
      pushes it to the heap, using the mutatorm. | 
| create [Netmcore_sem] | create m value: Creates a semaphore with initialvalue, and
      pushes it to the heap, using the mutatorm. | 
| create [Netmcore_array] | create pool_id a h:
      Creates a shared array by deeply copying a normal arrayaand using the copy ofhas header | 
| create [Uq_libevent.LIBOEVENT] | |
| create [Equeue] | 
Creates a new event system that has an event source, but is 
 otherwise empty.
 | 
| create2 [Rpc_server] | 
Creates a server according to the  mode2argument. | 
| create2 [Rpc_client] | 
New style clients:
 Opens a connection to the server specified by  mode2. | 
| create_address_list_tokens [Netsendmail] | 
Returns the list of  s_tokens representing email addresses as
 structured value. | 
| create_admin_container [Netplex_container] | 
Internally used.
 | 
| create_aggressive_cache [Http_client] | 
This type of cache tries to keep connections as long open as
 possible.
 | 
| create_boundary [Mimestring] | 
Creates a boundary string that can be used to separate multipart
 messages.
 | 
| create_camlbox [Netmcore_camlbox] | create_camlbox prefix n size: Creates a new camlbox with a 
      unique name derived fromprefix. | 
| create_camlbox [Netcamlbox] | create_camlbox addr n size: Creates a new camlbox for up tonmessages ofsizebytes. | 
| create_client [Rpc_portmapper_clnt.PMAP.V2] | |
| create_client2 [Rpc_portmapper_clnt.PMAP.V2] | |
| create_client_session [Netmech_scram] | create_client_session p username password: Creates a new client
      session for profilepso that the client authenticates as userusername, and proves its identify with the givenpassword. | 
| create_condition [Netmcore_condition] | create m: Creates a condition variable, and
      pushes it to the heap, using the mutatorm. | 
| create_constant_workload_manager [Netplex_workload] | 
A constant number of threads is created (the int argument).
 | 
| create_container [Netsys_sem] | create_container prefix: Likecontainer, but the container is
      always created. | 
| create_container [Netplex_container] | 
The container for normal services
 | 
| create_controller [Netplex_controller] | 
Create a controller with the default event system
 | 
| create_controller_for_esys [Netplex_controller] | 
Create a controller for the passed event system
 | 
| create_cursor [Netconversion] | 
Creates a new cursor for the passed string and the passed encoding.
 | 
| create_dynamic_workload_manager [Netplex_workload] | |
| create_env [Shell_sys] | 
Creates an empty environment
 | 
| create_event [Netsys_win32] | 
Create an event object
 | 
| create_event [Netsys_posix] | 
Creates a new event file descriptor.
 | 
| create_event_aggregator [Netsys_posix] | create_event_aggregator is_interruptible: Creates a new aggregator,
      and allocates the required OS resources. | 
| create_event_system [Uq_libevent.POLLSET] | |
| create_heap [Netmcore_heap] | create_heap pool_id size root: Creates a new heap withsizebytes in the pool identified bypool_id. | 
| create_in_buffer [Uq_io] | 
Provides a buffered version of the  in_device. | 
| create_inet [Rpc_portmapper] | 
Connects to a portmapper listening on an Internet port.
 | 
| create_input_netbuffer [Netchannels] | 
Creates an input channel and a shutdown function for a netbuffer.
 | 
| create_input_thread [Netsys_win32] | 
Creates the input thread for this file descriptor.
 | 
| create_local_pipe_server [Netsys_win32] | |
| create_mclient [Rpc_proxy.ManagedClient] | 
Create a managed client for this config connecting to this
        connector.
 | 
| create_mclient_config [Rpc_proxy.ManagedClient] | |
| create_mempool [Netmcore_mempool] | 
Creates the memory pool as shared memory object of the passed size
      (rounded up to the next multiple of pages) and returns the resource ID.
 | 
| create_mic_token [Netgssapi] | 
Create a MIC token:
 | 
| create_mime_scanner [Mimestring] | 
Creates a new  mime_scannerscanning the passed string. | 
| create_monitor [Uq_mt] | 
Creates a new monitor.
 | 
| create_mset [Rpc_proxy.ManagedSet] | create_mset config services: The mset is created withconfig,
        and theservicesarray describes which ports are available,
        and how often each port may be contacted (i.e. | 
| create_mset_config [Rpc_proxy.ManagedSet] | 
Create a config record.
 | 
| create_multiplex_controller_for_connected_socket [Uq_engines] | 
Creates a multiplex controller for a bidirectional socket (e.g.
 | 
| create_multiplex_controller_for_datagram_socket [Uq_engines] | 
Creates a multiplex controller for datagram sockets (e.g.
 | 
| create_out_buffer [Uq_io] | 
Provides a buffered version of the  out_device. | 
| create_output_thread [Netsys_win32] | 
Creates the output thread for this file descriptor.
 | 
| create_poll_array [Netsys_posix] | 
Create a poll array with the given size.
 | 
| create_pollset [Uq_libevent.POLLSET] | |
| create_pool [Netsys_mem] | 
Create a new pool.
 | 
| create_portmapped_client [Rpc_portmapper_clnt.PMAP.V2] | |
| create_preallocated_shm [Netmcore] | create_preallocated_shm prefix size: Creates a new preallocated
      shm object with a unique name based onprefix, and a length ofsizebytes. | 
| create_preallocated_shm_sc [Netmcore] | 
Same as  create_preallocated_shmwith the extension that 
      a semaphore container is also allocated and returned | 
| create_process [Netsys_win32] | create_process cmd cmdline options: Spawns a new process that runs
      concurrently with the calling process. | 
| create_protocol [Netplex_kit] | create_protocol name addresses: Creates aprotocolobject
      from the passed arguments | 
| create_rcache [Rpc_proxy.ReliabilityCache] | 
Creates a new cache object.
 | 
| create_rcache_config [Rpc_proxy.ReliabilityCache] | 
Create a config record.
 | 
| create_restrictive_cache [Http_client] | 
A restrictive cache closes connections as soon as there are no
 pending requests.
 | 
| create_salt [Netmech_scram] | 
Creates a random string suited as salt
 | 
| create_server_session [Netmech_scram] | create_server_session p auth: Creates a new server session with
      profilepand authenticator functionauth. | 
| create_server_socket [Netplex_sockserv] | create_server_socket service_name proto addr: Creates a server socket
      as specified inprotofor the addressaddrand returns it. | 
| create_socket_service [Netplex_sockserv] | 
Create the socket service (usually only internally used)
 | 
| create_socket_service_config [Netplex_kit] | create_socket_service_config name protos ctrl_conf: Creates asocket_service_configobject from the passed arguments | 
| create_ssl_multiplex_controller [Uq_ssl] | 
Creates a multiplex controller for an SSL socket.
 | 
| create_text_tokens [Netsendmail] | 
Returns the list of  s_tokens representing an informal text
 as structured value. | 
| create_timer [Netplex_cenv] | create_timer f tmo: Creates a timer with timeout valuetmo:
      Intmosecondsfis called, and if this function returnstrue,
      the timer remains active, and another round of timing is arranged. | 
| create_unique_shm [Netshm] | 
Create a shared memory object under a name that is derived
 from the passed  shm_name. | 
| create_unix_event_system [Unixqueue] | 
An alternate name for  standard_event_system, provided for
      backward compatibility. | 
| create_var [Netplex_sharedvar] | 
Create the variable with the passed name with an empty string
      (or the exception  Sharedvar_null) as
      initial value. | 
| create_wait_set [Netmcore_condition] | 
Creates a  wait_setin the heap designated by the mutator | 
| create_wrap_token_conf [Netgssapi] | 
Wraps a  messageso that it is encrypted and signed (confidential). | 
| ctermid [Netsys_posix] | 
Returns the name of the controlling tty of the current process 
 as pathname to a device file
 | 
| ctrl_increment [Netplex_semaphore] | 
Increment the named semaphore from controller context, substituting
      an increment from a container (e.g.
 | 
| current_dlogger [Netlog.Debug] | 
The current debug logger.
 | 
| current_env [Shell_sys] | 
Returns the environment of the current process as abstract environment
 value
 | 
| current_formatter [Netlog] | 
The current timestamp formatter
 | 
| current_logger [Netlog] | 
The variable containing the current logger function.
 | 
| current_resolver [Uq_resolver] | 
Returns the pluggable resolver
 | 
| current_sys_id [Netplex_cenv] | 
Returns the system-dependent thread identifier of the caller
      (which must be in container or controller context)
 | 
| 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 mostlencharacters as code
 points from
 the cursor position and the following positions to the arrayuaat indexpos. | 
| cursor_blit_maxlen [Netconversion] | 
Returns the maximum number of characters  cursor_blitcan copy
 at the current cursor position. | 
| cursor_blit_positions [Netconversion] | 
Works like  cursor_blit, but copies the byte positions of the
 characters intouainstead 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 | |
| datagram_provider [Uq_engines] | 
This engine creates a datagram socket as demanded by the  datagram_type,
 optionally usingproxyfor sending and receiving datagrams. | 
| datagram_rpc_multiplex_controller [Rpc_transport] | 
The multiplex controller for datagrams
 | 
| debug_c_wrapper [Netsys_win32.Debug] | 
Sets whether to debug the C wrapper part.
 | 
| debug_info [Netmcore_heap] | 
Returns a multi-line debug string
 | 
| debug_info [Netmcore_mempool] | 
Returns a string describing the allocations etc.
 | 
| debug_rpc_internals [Rpc_netplex] | |
| debug_rpc_service [Rpc_netplex] | 
These variables control debugging of  Rpc_server. | 
| decode [Nethtml] | 
Converts entities  &name;and&#num;into the corresponding 
 characters. | 
| decode [Netencoding.Html] | 
The input string is recoded from  in_enctoout_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_exported_name [Netgssapi] | 
Encode names as described in section 3.2 of RFC 2078
 | 
| decode_mime_body [Netmime] | let ch' = decode_mime_body hdr ch:
 According to the value of the Content-transfer-encoding header field
 inhdrthe encoded MIME body written toch'is decoded and transferred
 toch. | 
| decode_query [Nethttp] | 
Splits the URI into a "script name" and a "query string"
 | 
| decode_to_latin1 [Netencoding.Html] | |
| decrement [Netplex_semaphore] | 
Decrement the named semaphore by 1, and return the new value.
 | 
| decrypt [Rpc_key_service] | 
This function is used if this program is a server and wants to check
 the identity of a contacting client.
 | 
| decrypt [Netmech_scram.AES_CTS] | |
| decrypt_and_verify [Netmech_scram.Cryptosystem] | 
Decrypts the ciphertext and verifies the attached signature.
 | 
| decrypt_and_verify_mstrings [Netmech_scram.Cryptosystem] | 
Same, but with data representation as  mstring list | 
| decrypt_mstrings [Netmech_scram.AES_CTS] | |
| def_process [Netmcore_process] | let (fp,jp) = def_process proc: Defines a process (which must happen
      in the master process), so that: | 
| def_process [Netmcore] | let fork_point, join_point = def_process f:
      Defines process types, i.e. | 
| default_block_size [Netsys_mem] | 
The default block size, normally 64 K (or better, 16 times the
      page size)
 | 
| default_config [Netcgi1_compat.Netcgi_env] | |
| default_config [Netcgi] | 
The default configuration is:  tmp_directory:Netsys_tmp.tmp_directory(),tmp_prefix: "netcgi",permitted_http_methods:`GET,`HEAD,`POST.,permitted_input_content_types:"multipart/form-data","application/x-www-form-urlencoded".,input_content_length_limit:maxint(i.e., no limit).,max_arguments = 10000(for security reasons),workarounds: all of them.,default_exn_handler: set totrue.
      To create a custom configuration, it is recommended to use this syntax:(This syntax is also robust w.r.t. | 
| default_connect_options [Uq_engines] | 
Returns the default options
 | 
| default_host [Nethttpd_services] | 
Creates a  hostrecord that matches any request. | 
| default_http_engine_config [Nethttpd_engine] | 
The default config:  config_input_flow_control=false,config_output_flow_control=true | 
| default_http_processor_config [Nethttpd_reactor] | 
Default configuration: Extends
       Nethttpd_kernel.default_http_protocol_configwithconfig_timeout_next_request = 15.0,config_timeout = 300.0,config_cgi = Netcgi.default_config,config_error_response =Nethttpd_util.std_error_response,config_log_error: UsesNethttpd_util.std_error_log_stringto write a log message viaNetlog.,config_log_access: is a no-op | 
| default_http_protocol_config [Nethttpd_kernel] | 
Default config:  config_max_reqline_length = 32768,config_max_header_length = 65536,config_max_trailer_length = 32768,config_limit_pipeline_length = 5,config_limit_pipeline_size = 65536,config_announce_server = `Ocamlnet,config_suppress_broken_pipe = false | 
| default_http_reactor_config [Nethttpd_reactor] | 
Default configuration: Extends
       Nethttpd_reactor.default_http_processor_configwithconfig_reactor_synch = `Write | 
| default_listen_options [Uq_engines] | 
Returns the default options
 | 
| default_pool [Netsys_mem] | 
The default pool with the default block size.
 | 
| default_resolver [Uq_resolver] | 
The default resolver uses  Unix.gethostbynameto look up names. | 
| default_services [Nethttpd_plex] | 
The default services
 | 
| default_socket_config [Rpc_server] | |
| default_socket_config [Rpc_client] | 
Default configuration with  non_blocking_connect= true | 
| default_url [Neturl] | 
Adds missing components and returns the modified URL.
 | 
| default_value [Netshm_array] | 
Returns the default value
 | 
| del [Uq_libevent.LIBOEVENT] | |
| del_event_source [Netsys_posix] | 
Removes the source from the aggregator
 | 
| delay_engine [Uq_engines] | 
Same as function
 | 
| delete [Netulex.ULB] | 
Deletes the number of characters from  unicode_lexbuf. | 
| delete [Netbuffer] | delete nb k n: Deletes thenbytes at positionkof netbuffernbin-place. | 
| delete_hd [Netpagebuffer] | delete_hd b n: Deletesnbytes from the beginning of the buffer | 
| delete_hd [Netmcore_buffer] | delete_hd b n: Deletesnbytes from the beginning of the buffer. | 
| delete_method [Ftp_client] | 
Deletes the named file
 | 
| delete_var [Netplex_sharedvar] | delete_var name: Deletes the variablename. | 
| der_to_oid [Netgssapi] | 
Convert OID's to/from DER.
 | 
| deref [Netmcore_matrix] | 
Returns the raw array in shared memory for unprotected access
 | 
| deref [Netmcore_array] | 
Returns the raw array in shared memory for unprotected access
 | 
| deref_c [Netmcore_ref] | deref_c sr: Returns a copy of the contents ofsr. | 
| deref_p [Netmcore_ref] | deref_p sr f: Runsfwith the contents ofsr, and returns
      the result off. | 
| deref_ro [Netmcore_ref] | 
Dereferences the variable and returns the contents, comparable to
       !. | 
| derive_key_rfc3961_simplified [Netauth] | 
Derives a special key from a base key, as described in RFC 3961.
 | 
| derive_keys [Netmech_scram.Cryptosystem] | derive_keys protocol_key usage: Returns the specific keys for
	thisprotocol_keyand thisusagenumbers. | 
| derive_rcache [Rpc_proxy.ReliabilityCache] | derive_cache parent config: Returns a new cache that shares the
        error counters withparent. | 
| descr_of_buffer [Netmcore_buffer] | 
Returns the descriptor
 | 
| descr_of_hashtbl [Netmcore_hashtbl] | 
Returns the descriptor
 | 
| descr_of_heap [Netmcore_heap] | 
Get the descriptor of a heap
 | 
| descr_of_sarray [Netmcore_array] | 
Returns the descriptor
 | 
| descr_of_sarray2 [Netmcore_matrix] | 
Returns the descriptor
 | 
| descr_of_squeue [Netmcore_queue] | 
Returns the descriptor
 | 
| descr_of_sref [Netmcore_ref] | 
Returns the descriptor
 | 
| dest_fp4 [Rtypes] | |
| dest_fp4 [Netnumber] | |
| dest_fp8 [Rtypes] | |
| dest_fp8 [Netnumber] | |
| dest_int4 [Rtypes] | |
| dest_int4 [Netnumber] | |
| dest_int8 [Rtypes] | |
| dest_int8 [Netnumber] | |
| dest_uint4 [Rtypes] | |
| dest_uint4 [Netnumber] | |
| dest_uint8 [Rtypes] | dest_<t> destroy integer values and returns the corresponding char
 tuples. | 
| dest_uint8 [Netnumber] | dest_<t> destroy integer values and returns the corresponding char
 tuples. | 
| dest_url_encoded_parameters [Netencoding.Url] | 
The argument is the URL-encoded parameter string.
 | 
| dest_xv_array [Xdr] | |
| dest_xv_array_of_string_fast [Xdr] | |
| dest_xv_double [Xdr] | |
| dest_xv_enum [Xdr] | |
| dest_xv_enum_fast [Xdr] | |
| dest_xv_float [Xdr] | |
| dest_xv_hyper [Xdr] | |
| dest_xv_int [Xdr] | |
| dest_xv_mstring [Xdr] | |
| dest_xv_opaque [Xdr] | |
| dest_xv_string [Xdr] | |
| dest_xv_struct [Xdr] | |
| dest_xv_struct_fast [Xdr] | |
| dest_xv_uhyper [Xdr] | |
| dest_xv_uint [Xdr] | |
| dest_xv_union_over_enum [Xdr] | |
| dest_xv_union_over_enum_fast [Xdr] | |
| dest_xv_union_over_int [Xdr] | |
| dest_xv_union_over_uint [Xdr] | |
| dest_xv_void [Xdr] | |
| destroy [Netplex_semaphore] | 
Destroy this semaphore.
 | 
| destroy [Netmcore_buffer] | 
Destroys the buffer
 | 
| destroy [Netmcore_mutex] | 
Destroys the mutex
 | 
| destroy [Netmcore_sem] | 
Destroys the semaphore
 | 
| destroy [Netmcore_heap] | 
Destroys the heap and gives the memory back to the pool
 | 
| destroy_condition [Netmcore_condition] | |
| destroy_event [Netsys_posix] | 
Releases the OS resources.
 | 
| destroy_event_aggregator [Netsys_posix] | 
Frees all OS resources
 | 
| destroy_resources [Netmcore] | 
Destroys all resources that may be left
 | 
| destroy_wait_set [Netmcore_condition] | 
Destroys these objects
 | 
| detach [Rpc_server] | 
Internal function.
 | 
| device_supports_memory [Uq_io] | 
Returns whether  `Memorybuffers are supported | 
| dim [Netmcore_matrix] | 
Returns the dimenstions
 | 
| disable_all [Netlog.Debug] | 
Disable all modules (the default)
 | 
| disable_for_client [Rpc_client.Debug] | 
Disables all log messages for this client (internally used)
 | 
| disable_for_server [Rpc_server.Debug] | 
Disables logging for this server
 | 
| disable_module [Netlog.Debug] | 
Enable or disable the passed module  M(e.g. | 
| discard_request_body [Netcgi_apache.Apache.Request] | 
Discard client request body.
 | 
| domain [Nethttp.Cookie] | 
The domain of the cookie, if set.
 | 
| domain [Netcgi.Cookie] | 
The domain of the cookie, if set.
 | 
| domain [Netcgi_common.Cookie] | |
| domain_of_inet_addr [Netsys] | 
Returns the socket domain of Internet addresses, i.e.
 | 
| domainname [Rpc_auth_dh] | 
Returns the NIS domain name.
 | 
| drop [Netsys_sem] | 
Drop the semaphores in this container, and delete the container.
 | 
| dummy [Netmcore_mutex] | 
A dummy mutex is non-functional, but can be used to put something
      into  mutex-typed variables | 
| dummy [Netmcore_sem] | 
A dummy semaphore is non-functional, but can be used to put something
      into  semaphore-typed variables | 
| dummy_condition [Netmcore_condition] | 
A dummy condition is non-functional, but can be used to put something
      into  condition-typed variables | 
| dummy_wait_set [Netmcore_condition] | 
A dummy  wait_setis non-functional, but can be used to put something
      intowait_set-typed variables | 
| dump [Rpc_portmapper] | 
returns the list of known mappings.
 | 
| dump [Netshm] | |
| dump [Netplex_sharedvar] | 
Dumps the access counter of this variable to  Netlog. | 
| dump_data [Uq_ssl.Debug] | 
If also  enable, output a full dump of payload data | 
| dynamic_service [Nethttpd_services] | 
Configures the dynamic service.
 | 
| dynamic_workload_manager_factory [Netplex_workload] | 
Reads a workload_manager section like
 | 
| E | |
| emulated_pid [Netsys_win32] | 
Returns the MSVCRT.DLL notion of the process identifier (pid).
 | 
| enable [Shell_sys.Debug] | 
Enables  Netlog-style debugging of this module | 
| enable [Rpc_auth_gssapi.Debug] | |
| enable [Rpc_server.Debug] | 
Whether debug messages of general kind are enabled.
 | 
| enable [Rpc_client.Debug] | 
Whether debug messages are enabled.
 | 
| enable [Rpc_transport.Debug] | 
Enables  Netlog-style debugging | 
| enable [Netsys_sem.Debug] | |
| enable [Netsys_signal.Debug] | 
Enables  Netlog-style debugging of this module | 
| enable [Netsys_pollset_win32.Debug] | 
Enables  Netlog-style debugging of this module | 
| enable [Netsys_win32.Debug] | 
Enables  Netlog-style debugging of the Ocaml wrapper | 
| enable [Netsys_posix.Debug] | 
Enables  Netlog-style debugging | 
| enable [Netsys.Debug] | 
Enables  Netlog-style debugging | 
| enable [Netstring_str.Debug] | |
| enable [Netplex_cenv.Debug] | 
Enables  Netlog-style debugging | 
| enable [Netplex_container.Debug] | 
Enables debug logging of containers
 | 
| enable [Netplex_controller.Debug] | |
| enable [Netmcore_condition.Debug] | |
| enable [Netmcore_heap.Debug] | |
| enable [Netmcore_mempool.Debug] | 
Enable debugging
 | 
| enable [Netmcore.Debug] | |
| enable [Netmech_scram.Debug] | 
Enable debugging of this module
 | 
| enable [Nethttpd_services.Debug] | |
| enable [Nethttpd_engine.Debug] | 
Enables  Netlog-style debugging of this module | 
| enable [Nethttpd_reactor.Debug] | 
Enables  Netlog-style debugging of this module | 
| enable [Nethttpd_kernel.Debug] | 
Enables  Netlog-style debugging of this module | 
| enable [Ftp_client.Debug] | 
Enables  Netlog-style debugging of this module | 
| enable [Telnet_client.Debug] | 
Enables  Netlog-style debugging of this module  By default,
        the exchanged Telnet commands are logged. | 
| enable [Http_client.Debug] | 
Enables  Netlog-style debugging of this module | 
| enable [Netcamlbox.Debug] | |
| enable [Uq_ssl.Debug] | 
Enables  Netlog-style debugging of this module | 
| enable [Uq_engines.Debug] | 
Enables  Netlog-style debugging | 
| enable [Unixqueue.Debug] | 
Enable  Netlogdebugging | 
| enable [Equeue.Debug] | 
Enable  Netlogdebugging | 
| enable_all [Netlog.Debug] | 
Enable all modules
 | 
| enable_alloc [Netmcore_mempool.Debug] | 
Trace allocation and deallocation
 | 
| enable_ctrace [Rpc_server.Debug] | 
Whether debug messages are enabled that trace connection events.
 | 
| enable_fd_tracking [Netlog.Debug] | 
By setting to true, each  track_fdandrelease_fdis 
        logged. | 
| enable_module [Netlog.Debug] | |
| enable_ptrace [Rpc_server.Debug] | 
Whether the procedure trace is enabled.
 | 
| enable_ptrace [Rpc_client.Debug] | 
Whether the procedure trace is enabled as debug messages.
 | 
| encode [Nethtml] | 
Converts problematic characters to their corresponding
 entities.
 | 
| encode [Netencoding.Html] | 
The input string that is encoded as  in_encis recoded toout_enc, and the following characters are encoded as HTML
 entity (&name;or&#num;): The ASCII characters contained inunsafe_chars, The characters that cannot be represented inout_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 passout_enc=`Enc_utf8, all characters
   can be represented.
 For example, the string"(a<b) & (c>d)"is encoded as"(a<b) & (c>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_exported_name [Netgssapi] | |
| 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
 inhdrthe unencoded MIME body written to ch' is encoded and transferred
 to ch. | 
| encoding_of_glob_expr [Netglob] | 
Returns the encoding
 | 
| encoding_of_string [Netconversion] | 
Returns the encoding of the name of the encoding.
 | 
| encrypt [Rpc_key_service] | 
This function is used if this program is a client and wants to contact
 a server.
 | 
| encrypt [Netmech_scram.AES_CTS] | |
| encrypt_and_sign [Netmech_scram.Cryptosystem] | 
Encrypts the plaintext message and adds a signature to the
	ciphertext.
 | 
| encrypt_and_sign_mstrings [Netmech_scram.Cryptosystem] | 
Same, but with data representation as  mstring list | 
| encrypt_mstrings [Netmech_scram.AES_CTS] | |
| enforce_unavailability [Rpc_proxy.ManagedClient] | 
Enforces that all pending procedure calls get the
         Service_unavailableexception, and that the client is shut down. | 
| ensure_absolute_url [Neturl] | 
If the anonymous URL is absolute, it is just returned as result of
 this function.
 | 
| eof_as_none [Uq_io] | 
Represents EOF as  None. | 
| eps_e [Uq_engines.Operators] | 
Same as  epsilon_engine | 
| epsilon [Unixqueue] | 
The execution of the function is pushed onto the event queue
      (minimal delay)
 | 
| epsilon_engine [Uq_engines] | 
Same as function
 | 
| err_headers_out [Netcgi_apache.Apache.Request] | request_recerr_headers_outfield. | 
| error_page [Netcgi_common] | error_page env status fields msg detail: Logs an error message and
      outputs an error page viaenv. | 
| event_aggregator_fd [Netsys_posix] | 
Returns the underlying file descriptor.
 | 
| event_descr [Netsys_win32] | 
Returns the proxy descriptor for the event.
 | 
| event_system [Rpc_proxy.ManagedSet] | 
Return the event system
 | 
| event_system [Rpc_proxy.ManagedClient] | 
Return the event system
 | 
| event_system [Rpc_client] | 
Returns the unixqueue to which the client is attached
 | 
| event_wait [Netsys_win32] | 
Wait until the event is set to signaled state.
 | 
| execute [Shell_fs] | 
Starts this command.
 | 
| exists_resource [Unixqueue] | 
Find out if a specific resource already exists (or better: is
 already watched by an operation).
 | 
| exn_handler_default [Netcgi_common] | exn_handler_default env ~exn_handler ~finally run_cgiwill
      basically executeexn_handler env run_cgi. | 
| expand_glob_expr [Netglob] | 
Resolve generative sub expressions by expanding them.
 | 
| expanded_xdr_type [Xdr] | |
| expanded_xdr_type_term [Xdr] | |
| extract_call_gssapi_header [Rpc_packer] | |
| extract_config [Netplex_controller] | 
Extracts the controller config
 | 
| extract_url_scheme [Neturl] | 
Returns the URL scheme from the string representation of an URL.
 | 
| F | |
| faccessat [Netsys_posix] | 
Same as  Unix.accessbut the file is taken relative to the directory
      given by first argument | 
| factory [Netcgi_plex] | 
Reads a Netplex configuration section like
   | 
| fadvise [Netsys_posix] | 
Advises to load pages into the page table from the file, or to remove
      such pages.
 | 
| fake_pmanage [Netsys_pmanage] | 
A pseudo manager that does not save anything to a text file
 | 
| fallocate [Netsys_posix] | 
Allocate space for the file and the specified file region
 | 
| fcgi_processor [Netcgi_plex] | |
| fchdir [Netsys_posix] | 
Set the current directory to the directory referenced by the
      file descriptor
 | 
| fd_event_source [Netsys_posix] | 
Wraps a file descriptor as event_source, and monitors the
      events in  poll_req_events. | 
| fd_string [Netlog.Debug] | 
Return a string for generating debug messages.
 | 
| fd_table [Netlog.Debug] | 
Returns the table of descriptors as list of lines.
 | 
| fdatasync [Netsys_posix] | 
Syncs only data to disk.
 | 
| fdopendir [Netsys_posix] | 
Make a directory handle from a file descriptor.
 | 
| feat_method [Ftp_client] | 
Get the list of feature tokens (see also
       Ftp_client.ftp_state.ftp_features) | 
| fg_blue [Netsys_win32] | |
| fg_green [Netsys_win32] | |
| fg_intensity [Netsys_win32] | |
| fg_red [Netsys_win32] | |
| fields [Netcgi_apache.Apache.Table] | Table.fields tblreturns a list of(key, value)pairs
          consisting of all entries of the tabletbl. | 
| file_descr_of_int [Netsys_posix] | 
Make a file descriptor from an integer
 | 
| file_logger [Netplex_log] | 
Writes messages to this file
 | 
| file_logger_factory [Netplex_log] | 
Reads a logging section like
 | 
| file_logger_from_obj [Netplex_log] | 
Writes messages to this file
 | 
| file_service [Nethttpd_services] | 
Configures a file service
 | 
| file_translator [Nethttpd_services] | 
Translates an URI path to a file name.
 | 
| file_url_of_local_path [Neturl] | 
Generates a URL with "file" scheme from the passed path name.
 | 
| filename [Netcgi_apache.Apache.Request] | request_recfilenamefield. | 
| fill_random [Netsys_rng] | 
Fills this string with random bytes
 | 
| fill_random [Netsys_win32] | 
Fills the string with random bytes.
 | 
| filter_out_buffer [Uq_io] | filter_out_buffer ~max p d: The data written to this device is
      redirected via pipepand finally written tod. | 
| find [Netshm_hashtbl] | find tbl key: Finds the current binding ofkeyintblor
 raisesNot_foundif no such binding exists. | 
| find [Netshm] | find tbl key: Finds the current binding ofkeyintblor
 raisesNot_foundif no such binding exists. | 
| find_all [Netshm_hashtbl] | find_all tbl keyreturns the list of all data
 associated withkeyintbl. | 
| find_all [Netshm] | find_all tbl keyreturns the list of all data
 associated withkeyintbl. | 
| find_all_c [Netmcore_hashtbl] | 
Version of  find_allwith copied result | 
| find_all_p [Netmcore_hashtbl] | 
Version of  find_allwith pinned result | 
| find_all_ro [Netmcore_hashtbl] | Hashtbl.find_all tbl xreturns the list of all data
   associated withxintbl. | 
| find_c [Netmcore_hashtbl] | 
Like  findbut returns a copy of the binding in normal RAM | 
| find_double_line_start [Mimestring] | find_double_line_start s pos len: Searches two adjacent line ends
      (each may be a CR/LF combination or a single LF), and returns the
      position after the second line end. | 
| find_line_end [Mimestring] | find_line_end s pos len: Searches the next line end (CR/LF or
      only LF), and returns the position. | 
| find_line_start [Mimestring] | find_line_start s pos len: Searches the next start, and returns its
      position. | 
| find_p [Netmcore_hashtbl] | find_p tbl x flooks up the current binding ofxintbl,
      and callsfwith this binding as argument. | 
| find_pattern [Netaux.KMP] | |
| find_ro [Netmcore_hashtbl] | find_ro tbl xreturns the current binding ofxintbl,
   or raisesNot_foundif no such binding exists. | 
| finfo [Netcgi_apache.Apache.Request] | request_recfinfofield. | 
| finish_job [Shell_sys] | 
This creates a  job_engineinternally and runs until it is
 finished, i.e. | 
| first_chars [Netstring_pcre] | 
The last  ncharacters of a string | 
| first_chars [Netstring_str] | 
Same as  string_before | 
| fix_MSIE_Content_type_bug [Netcgi_common] | fix_MSIE_Content_type_bug cttransforms the content-type
      stringctto fix the MSIE Content-Type bug. | 
| fixup_url_string [Neturl] | 
Escapes some unsafe or "unwise" characters that are commonly used
 in URL strings: space, < > { } ^ \\ | and double quotes.
 | 
| float_of_fp4 [Rtypes] | |
| float_of_fp4 [Netnumber] | |
| float_of_fp8 [Rtypes] | |
| float_of_fp8 [Netnumber] | |
| float_var [Netplex_cenv] | |
| flush_e [Uq_io] | let e = flush_e d: Ifdhas an internal buffer, all data is
      written out tod. | 
| fmap_engine [Uq_engines] | 
Same as function
 | 
| fold [Netshm_hashtbl] | fold f tbl initcomputes(f kN dN ... (f k1 d1 init)...),
 wherek1 ... kNare the keys of all bindings intbl,
 andd1 ... dNare the associated values. | 
| fold [Netshm] | fold f tbl initcomputes(f kN dN ... (f k1 d1 init)...),
 wherek1 ... kNare the keys of all bindings intbl,
 andd1 ... dNare the associated values. | 
| fold [Netmcore_queue] | fold f accu q | 
| fold_header [Mimestring] | fold_header f acc0 s pos len:
      Parses a MIME header in the stringsfromposto exactlypos+len. | 
| fold_lines [Mimestring] | fold_lines f acc0 s pos len: Splits the substring ofsfrompostopos+leninto lines, and folds over these lines likeList.fold_left. | 
| fold_lines_p [Mimestring] | fold_lines_p f acc0 s pos len: Splits the substring ofsfrompostopos+leninto lines, and folds over these lines likeList.fold_left. | 
| foreground [Netplex_main] | 
Returns whether the daemon runs in the foreground
 | 
| forget_subprocess [Netsys_posix] | 
Frees OS resources.
 | 
| format [Netdate] | 
Format a date/time record as a string
 | 
| format_camlbox [Netcamlbox] | format_camlbox addr fd n size: The filefdis mapped into memory,
      and formatted as camlbox. | 
| format_field_value [Netsendmail] | 
To put  sval, ans_token list, into the header fieldname,
 call | 
| format_timestamp [Netlog] | format_timestamp fmt digits (seconds,nanos): Formats the timestamp(seconds,nanos)and returns the string. | 
| format_to [Netdate] | 
Format a date/time record according to the format string and outputs
 the resulting string to the channel.
 | 
| fp4_as_string [Rtypes] | |
| fp4_as_string [Netnumber.ENCDEC] | |
| fp4_of_float [Rtypes] | |
| fp4_of_float [Netnumber] | |
| fp4_of_fp8 [Rtypes] | 
Note  fp4_of_fp8: This conversion is not exact. | 
| fp4_of_fp8 [Netnumber] | 
Note  fp4_of_fp8: This conversion is not exact. | 
| fp8_as_string [Rtypes] | |
| fp8_as_string [Netnumber.ENCDEC] | |
| fp8_of_float [Rtypes] | |
| fp8_of_float [Netnumber] | 
Note fp4_of_float: The same problems as in fp4_of_fp8 may arise
 | 
| fp8_of_fp4 [Rtypes] | |
| fp8_of_fp4 [Netnumber] | |
| free_mem [Netmcore_mempool] | 
Frees this allocated block
 | 
| free_wait_entry [Netmcore_condition] | 
Frees a  wait_entry | 
| free_wait_entry_e [Netmcore_condition] | 
Frees a  wait_entry_e. | 
| from_dev_null [Shell] | 
A producer taking the data from  /dev/null. | 
| from_fd [Shell] | 
Creates a producer taking the data from the file descriptor passed
 to this function.
 | 
| from_file [Shell] | 
Creates a producer taking the data from the file whose name is
 passed to this function.
 | 
| from_function [Shell] | 
Creates a producer taking the data from a function.
 | 
| from_function [Netulex.ULB] | 
Creates a  unicode_lexbufto analyse strings of the 
 passedencodingcoming from therefillfunction. | 
| from_in_obj_channel [Netulex.ULB] | 
Creates a  unicode_lexbufto analyse strings of the 
 passedencodingcoming from the object channel. | 
| from_stream [Shell] | 
Creates a producer taking the data from a stream of strings.
 | 
| from_stream [Shell_sys] | from_stream ?epipe sreturns a function which can be
 used asproducerargument foradd_producer. | 
| from_string [Shell] | 
Creates a producer taking the data from a string  s. | 
| from_string [Shell_sys] | from_string ?pos ?len ?epipe sreturns a function which can be
 used asproducerargument foradd_producer. | 
| from_string [Netulex.ULB] | 
Creates a  unicode_lexbufanalysing the passed string encoded in
 the passed encoding. | 
| from_string_inplace [Netulex.ULB] | 
Creates a  unicode_lexbufanalysing the passed string encoded in
 the passed encoding. | 
| from_ulb_lexbuf [Netulex.Ulexing] | 
Creates a new  lexbuffrom theunicode_lexbuf. | 
| from_unicode [Netconversion] | 
Maps the Unicode code point to the corresponding code point of
 the charset, or raises  Cannot_representwhen there is no such
 corresponding code point. | 
| fsync [Netsys_posix] | 
Sync data and metadata to disk
 | 
| ftp_fs [Ftp_fs] | 
Same as function
 | 
| full_split [Netstring_pcre] | 
Splits into at most  nsubstrings, based onsplit_delim | 
| full_split [Netstring_str] | 
Like  split_delim, but returns the delimiters in the result | 
| fwd_dlogger [Netlog.Debug] | 
The standard debug logger simply prepends the module name to the
        message (separated by ": "), and calls the current logger to
        print it
 | 
| G | |
| gai_resolver [Uq_resolver] | 
This resolver uses  Unix.getaddrinfo. | 
| gc [Netmcore_heap] | 
Lock the heap and do a GC pass
 | 
| gclose [Netsys] | 
Shuts down the system object referenced by the descriptor so far
      possible, and closes the descriptor.
 | 
| ge_uint4 [Rtypes] | 
Other comparisons
 | 
| ge_uint4 [Netnumber] | 
Other comparisons
 | 
| ge_uint8 [Netnumber] | 
Other comparisons
 | 
| generate [Rpc_key_service] | 
Generates a new conversation key (a 64 bit random number)
 | 
| get [Netbuffer] | get nb pos: Get the character atpos | 
| get [Netshm_array] | get a k: Returns the contents of the array element numberkwhere0 <= k < length a. | 
| get [Netplex_semaphore] | 
Get the value of the named semaphore.
 | 
| get [Netplex_cenv.VAR_TYPE] | |
| get [Netcgi_dbi.DBI_POOL] | 
Example:  module MyPool = DbiPool(Dbi_postgres) | 
| get [Netcgi_common.Cookie] | 
Decode the cookie header, may they be version 0 or 1.
 | 
| get [Netcgi_apache.Apache.Table] | Table.get tbl keyreturns the corresponding entry in the
          table. | 
| get_accept [Nethttp.Header] | 
Returns the  Acceptheader as list of triples(media_range,
 media_range_params, accept_params). | 
| get_accept_charset [Nethttp.Header] | 
Returns the  Accept-charsetheader as list of pairs(charset,params). | 
| get_accept_encoding [Nethttp.Header] | 
Returns the  Accept-encodingheader as list of pairs(coding,params). | 
| get_accept_language [Nethttp.Header] | 
Returns the  Accept-languageheader as list of pairs(lang_range,params). | 
| get_accept_ranges [Nethttp.Header] | 
Returns the  Accept-rangesheader as list of tokens. | 
| get_active_code_page [Netsys_win32] | 
Get the active code page.
 | 
| get_age [Nethttp.Header] | 
Returns the  Ageheader as number | 
| get_all [Netcgi_apache.Apache.Table] | Table.get_all tbl keysame asTable.get tbl keyexcept
          it returns all values corresponding to thekey. | 
| get_allow [Nethttp.Header] | 
Returns the  Allowheader as list of tokens. | 
| get_arguments [Shell_sys] | 
Returns the argument array of the command (skipping the command name)
 | 
| get_assignments [Shell_sys] | 
Returns the list of assignments   (fd_from,fd_to)  | 
| get_auth_method [Rpc_server] | 
Returns the method that was used to authenticate the user.
 | 
| get_authorization [Nethttp.Header] | 
Returns the  Authorizationheader as pair(auth_scheme,auth_params),
 or raisesNot_foundif not present. | 
| get_basic_auth_pw [Netcgi_apache.Apache.Request] | 
Get the password sent in basic authentication.
 | 
| get_c [Netmcore_matrix] | get_c sa k1 k2: Gets a copy of the(k1,k2)-th element of the matrixsæ | 
| get_c [Netmcore_array] | get_c sa k: Gets a copy of thek-th element of the shared arraysæ | 
| get_cache_control [Nethttp.Header] | 
Returns the  Cache-controlheader as list of tokens. | 
| 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_charset [Ftp_client] | |
| get_chdir [Shell_sys] | 
Returns the  chdirparameter of the command | 
| get_client_block [Netcgi_apache.Apache.Request] | 
Get client request data.
 | 
| get_client_block_buf [Netcgi_apache.Apache.Request] | get_client_block_buf r buf ofs lenread a chunk of data
	  and puts it inbuf.[ofs .. ofs+len-1]. | 
| get_cmdname [Shell_sys] | 
Returns the name of the command
 | 
| 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_conn_peer_name [Rpc_server] | 
Return the address of the socket serving the connection, and the client
 socket, resp.
 | 
| get_conn_socket_name [Rpc_server] | |
| get_connection [Nethttp.Header] | 
Returns the  Connectionheader as list of tokens. | 
| get_connection_id [Rpc_server] | 
Get the connection_id
 | 
| get_console_attr [Netsys_win32] | |
| get_console_info [Netsys_win32] | 
Get r/o console info.
 | 
| get_console_input [Netsys_win32] | 
Get the input stream of the console.
 | 
| get_console_mode [Netsys_win32] | |
| get_console_output [Netsys_win32] | 
Get the output stream of the console.
 | 
| get_content_encoding [Nethttp.Header] | 
Returns the  Content-encodingheader as list of tokens. | 
| get_content_language [Nethttp.Header] | 
Returns the  Content-languageheader as list of tokens. | 
| get_content_length [Nethttp.Header] | 
Returns the  Content-lengthheader as number. | 
| get_content_location [Nethttp.Header] | 
Returns the  Content-locationheader as string. | 
| get_content_md5 [Nethttp.Header] | 
Returns the  Content-MD5header as string. | 
| get_content_range [Nethttp.Header] | 
Returns the  Content-rangeheader as`Bytes(byte_range_resp_spec, instance_length). | 
| get_content_type [Nethttp.Header] | 
Returns the  Content-typeheader as pair(media_type, params). | 
| get_cookie [Nethttp.Header] | 
Get the (Netscape) cookies as (name,value) pairs (or Not_found).
 | 
| get_cookie_ct [Nethttp.Header] | 
Get the cookies in the  Nethttp.Cookie.trepresentation
        (the suffix "_ct" reminds ofCookie.t). | 
| get_create [Ftp_client] | |
| get_custom_ops [Netsys_mem] | 
Returns custom ops for a sample value (or  Invalid_argument) | 
| get_date [Nethttp.Header] | 
Returns the  Dateheader as number (seconds since the Epoch). | 
| get_decoded_word [Mimestring] | |
| get_descriptors [Shell_sys] | 
Returns the list of active descriptors
 | 
| get_ec [Netmech_scram.Cryptosystem] | let ec = get_ec e_keys n:
        Returns the required value for the "extra count" field of
	RFC 4121 if the plaintext message has sizen. | 
| get_enc_lazily [Netplex_sharedvar] | 
Same for encapsulated values
 | 
| get_enc_value [Netplex_sharedvar] | get_enc_value name: Gets the value of the variablename. | 
| get_env [Shell_sys] | 
Gets the contents of the environment as string array
 | 
| get_env_var [Shell_sys] | 
Returns the value of the variable in the environment
 | 
| get_environment [Shell_sys] | 
Returns the designated environment of the command
 | 
| get_etag [Nethttp.Header] | 
Returns the  Etagheader. | 
| get_event_fd [Netsys_posix] | 
Returns a duplicate of the underlying file descriptor.
 | 
| get_event_system [Rpc_server] | 
Find out the event system that contains the 'session'
 | 
| get_expect [Nethttp.Header] | 
Returns the  Expectheader as list of triples(token,value,params). | 
| get_expires [Nethttp.Header] | 
Returns the  Expiresheader as number (seconds since the Epoch). | 
| get_fd_of_event_source [Netsys_posix] | 
Get the file descriptor wrapped by this event source
 | 
| get_fd_style [Netsys] | 
Get the file descriptor style
 | 
| get_file [Netmcore] | 
Gets the file with this ID (or raises  No_resource). | 
| get_filename [Shell_sys] | 
Returns the file name of the executable
 | 
| get_from [Nethttp.Header] | 
Returns the  Fromheader as string. | 
| get_from_unicode [Netmappings] | |
| get_host [Nethttp.Header] | 
Returns the  Hostheader as pair(host,port). | 
| get_host_by_name [Uq_resolver] | 
Look up the host, and return the host entry
      or raise the exception  Host_not_found. | 
| get_if_match [Nethttp.Header] | 
Returns the  If-matchheader. | 
| get_if_modified_since [Nethttp.Header] | 
Returns the  If-modified-sinceheader as number (seconds
 since the Epoch). | 
| get_if_none_match [Nethttp.Header] | 
Returns the  If-none-matchheader. | 
| get_if_range [Nethttp.Header] | 
Returns the  If-rangeheader. | 
| get_if_unmodified_since [Nethttp.Header] | 
Returns the  If-unmodified-sinceheader as number (seconds
 since the Epoch). | 
| get_lang [Ftp_client] | |
| get_language [Mimestring] | 
Returns the language if the token is an  EncodedWord, and""for
 all other tokens. | 
| get_last_modified [Nethttp.Header] | 
Returns the  Last-modifiedheader as number (seconds since the Epoch). | 
| get_last_proc_info [Rpc_server] | 
Get a debug string describing the last invoked procedure
 | 
| get_lazily [Netplex_sharedvar] | get_lazily name f: Uses the variablenameto ensure thatfis only invoked whenget_lazilyis called for the first time,
      and that the value stored in the variable is returned the
      next times. | 
| 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_localzone [Netdate] | 
Retrieves the current offset for the local time zone, taking
      daylight savings into account.
 | 
| get_location [Nethttp.Header] | 
Returns the  Locationheader as string. | 
| get_main_socket_name [Rpc_server] | 
Returns the address of the server socket, or the address of the
 bidirectional pipe.
 | 
| get_max_forwards [Nethttp.Header] | 
Returns the  Max-forwardsheader as number. | 
| get_media_type [Ftp_client] | |
| get_method [Ftp_client] | 
This FTP method walks to the right directory and gets  filefrom
 the server. | 
| get_mic [Netmech_scram.Cryptosystem] | 
Returns a message integrity code
 | 
| get_mic_mstrings [Netmech_scram.Cryptosystem] | 
Same, but with data representation as  mstring list | 
| get_modify [Ftp_client] | |
| get_name [Ftp_client] | |
| get_nonblock [Netsys_posix] | 
Returns whether the nonblock flag is set
 | 
| get_p [Netmcore_matrix] | get_p sa k1 k2 f: Gets the(k1,k2)-th element of the matrixsaand callfwith this element, and returns the result off. | 
| get_p [Netmcore_array] | get_p sa k f: Gets thek-th element of the shared arraysaand callfwith this element, and returns the result off. | 
| get_peer_credentials [Rpc_auth_local] | 
Return the pair (euid,egid) for a Unix domain socket.
 | 
| get_peer_name [Rpc_server] | 
Return the address of the socket serving the session, and the client
 socket, resp.
 | 
| get_peer_name [Rpc_client] | 
Return the addresses of the client socket and the server socket, resp.
 | 
| get_perm [Ftp_client] | |
| get_poll_cell [Netsys_posix] | get_poll_cell a k: Returns the poll cellk. | 
| 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_pragma [Nethttp.Header] | 
Returns the  Pragmaheader as list of pairs(token,value). | 
| get_process_status [Netsys_win32] | 
Returns the process result if the process is finished, and  Noneotherwise | 
| get_protocol [Rpc_server] | 
Return whether Tcp or Udp
 | 
| get_protocol [Rpc_client] | 
Get the protocol flavour
 | 
| get_proxy_authenticate [Nethttp.Header] | 
Returns the  Proxy-authenticateheader as list of challenges(auth_scheme,auth_params). | 
| get_proxy_authorization [Nethttp.Header] | 
Returns the  Proxy-authorizationheader as pair(auth_scheme,auth_params). | 
| get_range [Nethttp.Header] | 
Returns the  Rangeheader as`Bytes ranges, where the listrangeshas elements of the form(Some first_pos, Some last_pos),(Some first_pos, None)(prefix range), or(None, Some
 last_pos)(suffix range). | 
| get_referer [Nethttp.Header] | 
Returns the  Refererheader as string. | 
| get_referrer [Nethttp.Header] | 
Same, for addicts of correct orthography
 | 
| get_resource [Netmcore] | 
Retrieves the resource by ID.
 | 
| get_retry_after [Nethttp.Header] | 
Returns the  Retry-afterheader. | 
| get_ro [Netmcore_matrix] | get_ro sa k1 k2: Gets the(k1,k2)-th element of the matrixsa. | 
| get_ro [Netmcore_array] | get_ro sa k: Gets thek-th element of the shared arraysa. | 
| get_sem [Netmcore] | 
gets the semaphore with this ID (or raises  No_resource). | 
| get_sem_container [Netmcore] | 
Get the semaphore container
 | 
| get_sender_of_last_response [Rpc_client] | 
Return the address of the sender of the last received response.
 | 
| get_server [Rpc_server] | 
Returns the server instance of the session
 | 
| get_server [Nethttp.Header] | 
Returns the  Serverheader as uninterpreted string (including
 comments). | 
| get_set_cookie [Nethttp.Header] | 
Get the  Set-Cookieheader | 
| get_shm [Netmcore] | 
Gets the shm object with this ID (or raises  No_resource). | 
| get_size [Ftp_client] | |
| get_socket_name [Rpc_server] | |
| get_socket_name [Rpc_client] | |
| get_srv_event_system [Rpc_server] | 
Returns the event system
 | 
| get_subprocess_status [Netsys_posix] | 
If the subprocess is terminated, this function returns the status.
 | 
| get_te [Nethttp.Header] | 
Returns the  TEheader as list of triples(te_token, te_params, accept_params). | 
| get_to_unicode [Netmappings] | |
| get_token [Mimestring] | 
Return the  s_tokenwithin thes_extended_token | 
| get_trailer [Nethttp.Header] | 
Returns the  Trailerheader as list of field names. | 
| get_transfer_encoding [Nethttp.Header] | 
Returns the  Transfer-encodingheader as list of pairs(token, params). | 
| get_type [Ftp_client] | |
| get_unique [Ftp_client] | |
| get_unix_gid [Ftp_client] | |
| get_unix_mode [Ftp_client] | |
| get_unix_uid [Ftp_client] | |
| get_upgrade [Nethttp.Header] | 
Returns the  Upgradeheader as list of products. | 
| get_user [Rpc_server] | 
Returns the user name as returned by the authentication method.
 | 
| get_user_agent [Nethttp.Header] | 
Returns the  User-agentheader as uninterpreted string
 (including comments). | 
| get_value [Netplex_sharedvar] | get_value name: Gets the value of the variablename. | 
| get_vary [Nethttp.Header] | 
Returns the  Varyheader. | 
| get_www_authenticate [Nethttp.Header] | 
Returns the  WWW-Authenticateheader as list of challenges(auth_scheme,auth_params). | 
| get_xid [Rpc_server] | 
Returns the session ID.
 | 
| get_xid_of_last_call [Rpc_client] | 
Returns the session identifier used in the just made call
 | 
| getpagesize [Netsys_mem] | 
Returns the size of a page as reported by  sysconf. | 
| getpeername [Netsys] | 
like  Unix.getpeername, but errors are fixed up. | 
| getpgid [Netsys_posix] | 
Return the process group ID of the process with the passed PID.
 | 
| getpgrp [Netsys_posix] | 
Same as  getpgid 0, i.e. | 
| getport [Rpc_portmapper] | getport pm_client program_nr version_nr protocol:
 finds out the port where the given service runs. | 
| getsid [Netsys_posix] | 
Returns the session ID of the process with the passed PID.
 | 
| getvalue [Netmcore_sem] | 
Returns the value of the semaphore
 | 
| glob [Netglob] | 
Forms a set of filenames as described below, and matches this set
 against the pattern.
 | 
| global_rcache [Rpc_proxy.ReliabilityCache] | 
The global cache.
 | 
| global_rcache_config [Rpc_proxy.ReliabilityCache] | 
Returns the global config:  policy = `None,disable_timeout_min = 1.0,disable_timeout_max = 64.0,threshold = 1,availability = fun _ _ -> true | 
| global_replace [Netstring_pcre] | 
Returns the position where the substring matching the nth
 group ends
 | 
| global_replace [Netstring_str] | global_replace re templ s: Replaces all matchings ofreinsbytempl. | 
| global_substitute [Netstring_pcre] | replace_first re templ s: Replaces the first match ofreinsbytempl. | 
| global_substitute [Netstring_str] | global_substitute re subst s: Applies the substitution functionsubstto all matchings ofreins, and returns the 
 transformed string. | 
| grab [Netsys_mem] | grab addr len: Interprets the address range fromaddrtoaddr+len-1asmemorybigarray. | 
| grantpt [Netsys_posix] | 
Grant access to this PTY
 | 
| gread [Netsys] | gread fd_style fd s pos len: Reads up tolenbytes from 
      descriptorfdwhich is supposed to support the I/O stylefd_style, i.e. | 
| group [Netshm] | 
Execute a sequence of operations in a group:
 | 
| group_beginning [Netstring_pcre] | 
Extracts the substring the nth group matches from the whole
 string.
 | 
| 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 begins
 | 
| group_end [Netstring_str] | 
Returns the position where the substring matching the nth
 group ends
 | 
| grow [Netmcore_array] | grow sa n x: Grows the array tonelements. | 
| gshutdown [Netsys] | gshutdown fd_style fd cmd: If there is the possibility to shut down
      the connection for this kind of descriptor, the shutdown is tried. | 
| gt_uint4 [Rtypes] | |
| gt_uint4 [Netnumber] | |
| gt_uint8 [Netnumber] | |
| gwrite [Netsys] | gwrite fd_style fd s pos len: Writes up tolenbytes to
      descriptorfdwhich is supposed to support the I/O stylefd_style, i.e. | 
| H | |
| handle_request [Netcgi_fcgi] | handle_request config output_type arg_store eh f ~max_conns
        ~log fd: This is a lower-level interface that processes
        exactly one request arriving on the existing connectionfd. | 
| handle_request [Netcgi_scgi] | handle_request config output_type arg_store eh f ~log fd:
      This is a 
      lower-level interface that processes exactly one request arriving 
      on the existing connectionfd. | 
| handle_request [Netcgi_ajp] | handle_request config output_type arg_store eh f ~log fd: This
      is a lower-level interface that processes exactly one request
      arriving on the existing connectionfd. | 
| has_console [Netsys_win32] | 
True if there is a console
 | 
| hashtbl_of_descr [Netmcore_hashtbl] | 
Look up the hash table for this descriptor
 | 
| have_anon_posix_semaphores [Netsys_posix] | 
Returns  trueif anonymous POSIX semaphores are supported on this 
      system | 
| have_anon_semaphores [Netsys_sem] | 
Returns  trueif anonymous semaphores are supported on this 
      system, either natively or emulated via named semaphores. | 
| have_at [Netsys_posix] | 
Whether the  *atfunctions are available (they were only recently
      standardized and cannot be expected on all OS yet) | 
| have_event_aggregation [Netsys_posix] | 
Whether there is an implementation for this OS
 | 
| have_fadvise [Netsys_posix] | 
Returns whether the OS supports the fadvise POSIX option
 | 
| have_fallocate [Netsys_posix] | 
Returns whether the OS supports the fallocate POSIX option
 | 
| have_ioprio [Netsys_posix] | 
Returns  trueif the system callioprio_getis supported | 
| have_named_posix_semaphores [Netsys_posix] | 
Returns  trueif named POSIX semaphores are supported on this system | 
| have_poll [Netsys_posix] | 
Whether there is a native  pollimplementation on this OS | 
| have_posix_semaphores [Netsys_posix] | 
Returns  trueif both kinds of semaphores are supported on this system | 
| have_posix_shm [Netsys_posix] | 
Returns whether the OS supports POSIX shared memory
 | 
| have_posix_shm [Netsys] | |
| have_posix_timer [Netsys_posix] | |
| hdr_address [Netsys_mem] | 
These two functions return the address of the  Obj.tand the
      address of the header of theObj.t, respectively. | 
| header [Netmcore_hashtbl] | 
Returns the header
 | 
| header [Netmcore_matrix] | 
Returns the header
 | 
| header [Netmcore_buffer] | 
Returns the header
 | 
| header [Netmcore_queue] | 
Returns the header
 | 
| header [Netmcore_array] | 
Returns the header
 | 
| header_only [Netcgi_apache.Apache.Request] | request_recheader_onlyfield. | 
| headers_in [Netcgi_apache.Apache.Request] | request_recheaders_infield. | 
| headers_out [Netcgi_apache.Apache.Request] | request_recheaders_outfield. | 
| heap [Netmcore_hashtbl] | 
Returns the heap backing this data structure
 | 
| heap [Netmcore_matrix] | 
Return the backing heap structure
 | 
| heap [Netmcore_buffer] | 
Returns the underlying heap
 | 
| heap [Netmcore_queue] | 
Returns the underlying heap
 | 
| heap [Netmcore_array] | 
Return the backing heap structure
 | 
| heap [Netmcore_ref] | 
Returns the backing heap structure
 | 
| heap_of_descr [Netmcore_heap] | heap_of_descr pool d:
      Get the heap for a descriptor. | 
| hex_dump_m [Rpc_util] | |
| hex_dump_s [Rpc_util] | 
Format the contents as hex sequence
 | 
| hmac [Netauth] | 
The HMAC algorithm of RFC 2104.
 | 
| host_distributor [Nethttpd_services] | 
Configures virtual hosting
 | 
| host_is_enabled [Rpc_proxy.ReliabilityCache] | 
Returns whether the host is enabled
 | 
| hostname [Netcgi_apache.Apache.Request] | request_rechostnamefield -- hostname to which the
	  request was made. | 
| hostname [Netcgi_apache.Apache.Server] | server_hostnamefield (as declared in Apache configuration file). | 
| html40_dtd [Nethtml] | 
The (transitional) HTML 4.0 DTD, expressed as  simplified_dtd | 
| http_cb_id [Http_client] | 
Identifies a channel binding to pure HTTP (without SSL), with or
      without web proxies
 | 
| http_delete [Http_client.Convenience] | 
Does a "DELETE" request with the given URL and returns the response
 body.
 | 
| http_delete_message [Http_client.Convenience] | 
Does a "DELETE" request with the given URL and returns the reply.
 | 
| http_fs [Http_fs] | 
Same as normal function
 | 
| http_get [Http_client.Convenience] | 
Does a "GET" request with the given URL and returns the message
 body
 | 
| http_get_message [Http_client.Convenience] | 
Does a "GET" request with the given URL and returns the message
 | 
| http_head_message [Http_client.Convenience] | 
Does a "HEAD" request with the given URL and returns the reply.
 | 
| http_password [Http_client.Convenience] | 
The default password if authentication is required
 | 
| http_post [Http_client.Convenience] | 
Does a "POST" request with the given URL and returns the response body.
 | 
| http_post_message [Http_client.Convenience] | 
Does a "POST" request with the given URL and returns the reply.
 | 
| http_put [Http_client.Convenience] | 
Does a "PUT" request with the given URL and returns the response body.
 | 
| http_put_message [Http_client.Convenience] | 
Does a "PUT" request with the given URL and returns the reply.
 | 
| http_status_of_int [Nethttp] | 
Returns the status value for an integer code, or raises  Not_found | 
| http_transport_channel_type [Http_client] | 
Transport via HTTP
 | 
| http_trials [Http_client.Convenience] | 
number of times every request is tried.
 | 
| http_user [Http_client.Convenience] | 
The default user if authentication is required
 | 
| http_verbose [Http_client.Convenience] | 
Turns on debug messages on stderr.
 | 
| https_cb_id [Http_client] | 
Identifies a channel binding to anonymous HTTPS (i.e.
 | 
| https_transport_channel_type [Https_client] | 
Configures a TLS tunnel for this context.
 | 
| I | |
| id [Rpc_program] | 
The ID identifies the program (used in  Rpc_client) | 
| idempotent_async_call [Rpc_proxy.ManagedSet] | idempotent_async_call
           mset async_call arg emit: Picks a newmclientand callsasync_call mclient arg emit. | 
| idempotent_sync_call [Rpc_proxy.ManagedSet] | 
Synchronized version.
 | 
| ignore_subprocess [Netsys_posix] | 
Changes the arrangement so that the termination of the subprocess
      is no longer reported by the file descriptor.
 | 
| in_buffer_blit [Uq_io] | 
Blit to a string or memory buffer
 | 
| in_buffer_fill_e [Uq_io] | 
Requests that the buffer is filled more than currently, and
      transitions to  `Done eofwhen there is more data, or the
      EOF is reached (eof=true). | 
| in_buffer_length [Uq_io] | 
The length
 | 
| inactivate [Uq_io] | 
Releases the OS resources immediately.
 | 
| incr_rcache_error_counter [Rpc_proxy.ReliabilityCache] | 
Increase the error counter for this sockaddr.
 | 
| increment [Netplex_semaphore] | 
Increment the named semaphore by 1, and return the new value.
 | 
| index_from [Netpagebuffer] | index_from nb k c: Searches the charactercin the buffer beginning
 at positionk. | 
| index_from [Netbuffer] | index_from nb k c: Searches the charactercin the netbuffer beginning
 at positionk. | 
| inet_addr_of_protostring [Netsys] | 
Converts an IP address to the 4 bytes (IPv4) or 16 bytes (IPv6)
      representation in network byte order, and vice-versa
 | 
| init [Netgzip] | 
By calling this function it is enforced that the (de)-compression
      algorithms are registered at  Netcompression. | 
| init [Netsys_signal] | 
Call this function to ensure that this module is initialized.
 | 
| init [Netmcore_matrix] | init pool_id n1 n2 f h:
      Creates a matrix of the passed number of elements (n1 * n2),
      and for getting the element at positionkthe functionf kis run, and the copy of the result is written to the
      position. | 
| init [Netmcore_array] | init pool_id n f h:
      Creates a shared array of the passed number of elements, 
      and for getting the element at positionkthe functionf kis run, and the copy of the result is written to the
      position. | 
| init_array [Netsys_mem] | let voffset, bytelen = init_array mem offset size: 
      Initializes the memory atoffsetand following bytes as Ocaml array withsizeelements. | 
| init_array_bytelen [Netsys_mem] | 
Returns  bytelenifinit_arraywas called with the passedsize. | 
| init_console_codepage [Netsys_win32] | 
Sets the code page of the console to the ANSI code page of the
      system.
 | 
| init_float_array [Netsys_mem] | 
Same for arrays of floats
 | 
| init_float_array_bytelen [Netsys_mem] | 
Same for arrays of floats
 | 
| init_header [Netsys_mem] | init_header mem offset tag size: Initializes the word atmem+offsetas an Ocaml value header with the giventagand the givensize(in words). | 
| init_string [Netsys_mem] | let voffset, bytelen = init_string mem offset len: 
      Initializes the memory atoffsetand following bytes as Ocaml string with lengthlen. | 
| init_string_bytelen [Netsys_mem] | 
Returns  bytelenifinit_stringwas called with the passedlen. | 
| init_value [Netsys_mem] | let voffset, bytelen = init_value mem offset v flags:
      Initializes the memory atoffsetand following bytes as
      copy of the boxed valuev. | 
| initgroups [Netsys_posix] | 
See initgroups(3).
 | 
| input_e [Uq_io] | let e = input_e d s pos len: Reads data fromdand puts it into
     the stringsstarting atposand with maximum lengthlen. | 
| input_line_e [Uq_io] | let e = input_line_e d: Reads the next line fromdand transitions
      to`Done linewhen done. | 
| input_lines_e [Uq_io] | let e = input_lines_e d: Reads as many lines fromdas can be
      found in the buffer ofd, and transitions to`Done lines. | 
| input_stream_adapter [Shell_fs] | 
Arranges that the input of a shell command is made available as
      an  out_obj_channel: | 
| input_thread_event [Netsys_win32] | 
This event is signaled when there is data to read, or the EOF
     is reached, or there is an error condition
 | 
| input_thread_proxy_descr [Netsys_win32] | 
Returns the proxy descriptor
 | 
| input_thread_read [Netsys_win32] | input_thread_read t s pos len: Tries to read data from the buffer. | 
| insert_char [Netbuffer] | insert_char nb p c: Inserts charactercat positionpinto
 the netbuffernb | 
| insert_string [Netbuffer] | insert_string nb p s: Inserts the value of stringsat positionpinto the netbuffernb | 
| insert_sub_string [Netbuffer] | insert_string nb p s k n: Inserts a substring of stringsat positionpinto the netbuffernb. | 
| install_job_handlers [Shell_sys] | 
Installs handlers as configured before.
 | 
| install_subprocess_handler [Netsys_posix] | 
Installs a SIGCHLD handler for watching subprocesses.
 | 
| int32_array_manager [Netshm_data] | 
The identity representation manager
 | 
| int32_manager [Netshm_data] | 
Represents an  int32as one-elementint32_array | 
| int32_of_int4 [Rtypes] | |
| int32_of_int4 [Netnumber] | |
| int32_of_int8 [Rtypes] | |
| int32_of_int8 [Netnumber] | |
| int32_of_uint4 [Rtypes] | |
| int32_of_uint4 [Netnumber] | |
| int32_of_uint8 [Rtypes] | |
| int32_of_uint8 [Netnumber] | |
| int4_as_string [Rtypes] | |
| int4_as_string [Netnumber.ENCDEC] | |
| int4_of_int [Rtypes] | |
| int4_of_int [Netnumber] | |
| int4_of_int32 [Rtypes] | |
| int4_of_int32 [Netnumber] | |
| int4_of_int64 [Rtypes] | |
| int4_of_int64 [Netnumber] | |
| int64_manager [Netshm_data] | 
Represents an  int64as two-elementint32_array | 
| int64_of_file_descr [Netsys] | 
Returns the file descriptor as int64 number.
 | 
| int64_of_int4 [Rtypes] | |
| int64_of_int4 [Netnumber] | |
| int64_of_int8 [Rtypes] | |
| int64_of_int8 [Netnumber] | |
| int64_of_uint4 [Rtypes] | |
| int64_of_uint4 [Netnumber] | |
| int64_of_uint8 [Rtypes] | |
| int64_of_uint8 [Netnumber] | |
| int8_as_string [Rtypes] | |
| int8_as_string [Netnumber.ENCDEC] | |
| int8_of_int [Rtypes] | |
| int8_of_int [Netnumber] | |
| int8_of_int32 [Rtypes] | |
| int8_of_int32 [Netnumber] | |
| int8_of_int64 [Rtypes] | |
| int8_of_int64 [Netnumber] | |
| int_blit [Netaux.ArrayAux] | 
A specialisation of  Array.blitfor int arrays. | 
| int_manager [Netshm_data] | 
Uses either  int32_managerorint64_managerto representint,
 depending on the size ofint. | 
| int_of_act_events [Netsys_posix] | |
| int_of_file_descr [Netsys_posix] | 
Return the file descriptor as integer.
 | 
| int_of_http_status [Nethttp] | 
Returns the integer code for a status value
 | 
| int_of_int4 [Rtypes] | |
| int_of_int4 [Netnumber] | |
| int_of_int8 [Rtypes] | |
| int_of_int8 [Netnumber] | |
| int_of_req_events [Netsys_posix] | |
| int_of_uint4 [Rtypes] | |
| int_of_uint4 [Netnumber] | |
| int_of_uint8 [Rtypes] | |
| int_of_uint8 [Netnumber] | |
| int_series [Netaux.ArrayAux] | int_series src srcpos dst dstpos len n:
 Computes for everyi,0 <= i < len:dst.(dstpos+i) = n + SUM(j=0..(i-1): src.(srcpos+j))  | 
| int_var [Netplex_cenv] | |
| internal_redirect [Netcgi_apache.Apache.Request] | 
Internally redirects immediately to  uri. | 
| internal_redirect_handler [Netcgi_apache.Apache.Request] | 
Internally redirects immediately to  uriusing handler specified
          byr. | 
| interrupt_event_aggregator [Netsys_posix] | 
If  create_event_aggregatorwas called withtrueas argument, the
      aggregator is interruptible, and this function interrupts it. | 
| invoke_method [Ftp_client] | 
This FTP method simply invokes  command. | 
| ioprio_get [Netsys_posix] | 
Retrieve the priority of the target.
 | 
| ioprio_set [Netsys_posix] | 
Sets the priority of the target processes.
 | 
| ip_url_syntax [Neturl] | 
Syntax for IP based protocols.
 | 
| ipproto_tcp [Rpc_portmapper_aux] | |
| ipproto_udp [Rpc_portmapper_aux] | |
| is_MSIE [Netcgi_common] | is_MSIE user_agenttells whether theuser_agentis Microsoft
      Internet Explorer. | 
| is_absolute [Netsys] | 
Whether this file path is absolute.
 | 
| 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_bigarray [Netsys_mem] | 
Checks whether the objects ia actually a bigarray
 | 
| is_cgi [Netcgi_cgi] | is_cgisays whether the script is run in a CGI environment. | 
| is_console [Netsys_win32] | 
Tests whether the descriptor is the input or the output stream of the
      console.
 | 
| is_crt_fd [Netsys_win32] | 
Tests whether the descriptor has a certain CRT counterpart.
 | 
| is_dummy [Rpc_server] | 
Whether this is a server in  `Dummymode. | 
| is_empty [Netmcore_queue] | 
Tests whether the queue is empty
 | 
| is_executable [Shell_sys] | 
Returns  trueif there is an executable file for the command, and
 it is permitted to run this file (as stated by the file permissions). | 
| is_ipv4_inet_addr [Netsys] | 
Whether the address is an IPv4 address
 | 
| is_ipv6_inet_addr [Netsys] | 
Whether the address is an IPv6 address
 | 
| is_multicast_inet_addr [Netsys] | 
Whether the address is a multicast address (either IPv4 or IPv6)
 | 
| is_prefix [Netcgi_common] | is_prefix pre schecks whetherpreis a prefix ofs. | 
| is_prird [Netsys] | 
Test whether the descriptor would not block if one of the input,
      output, or priority input operations were done.
 | 
| is_readable [Netsys] | |
| is_running [Unixqueue] | 
Whether the event loop is running
 | 
| is_running [Equeue] | 
Returns whether the event loop is active
 | 
| is_single_byte [Netconversion] | 
Returns whether the encoding is a single-byte encoding
 | 
| is_stderr [Netsys] | 
Returns whether the descriptors are stdin/stdout/stderr
 | 
| is_stdin [Netsys] | |
| is_stdout [Netsys] | |
| is_up [Rpc_client] | 
Return whether the client is up
 | 
| is_virtual [Netcgi_apache.Apache.Server] | is_virtualfield. | 
| is_writable [Netsys] | |
| iso8601_week_pair [Netdate] | 
Returns  (week_number, year)for the ISO-8601 definition of weeks. | 
| iter [Netfs] | iter pre fs start: Iterates over the file hierarchy atstart. | 
| iter [Netshm_hashtbl] | iter f tblappliesfto all bindings in tabletbl. | 
| iter [Netshm] | iter f tblappliesfto all bindings in tabletbl. | 
| iter [Netmcore_hashtbl] | Hashtbl.iter f tblappliesfto all bindings in tabletbl. | 
| iter [Netmcore_queue] | iter f q: Iterates over the elements of the queue and callsf xfor each elementx. | 
| iter_env [Shell_sys] | 
Iterates over the strings of the environment, and calls
  f sfor every strings. | 
| iter_env_vars [Shell_sys] | 
Iterates over the variables of the environment, and calls
  f name valuefor every variable withnameandvalue. | 
| iter_keys [Netshm_hashtbl] | iter_keys f tblappliesfto all keys in tabletbl. | 
| iter_keys [Netshm] | iter_keys f tblappliesfto all keys in tabletbl. | 
| iter_lines [Mimestring] | iter_lines f s pos len: Splits the substring ofsfrompostopos+leninto lines, and callsf linefor each
      line. | 
| J | |
| job_status [Shell_sys] | 
Returns the status.
 | 
| join [Netmcore_process] | let r_opt = join jp pid: Waits until the processpidfinishes,
      and uses the join pointjpto extract the result. | 
| join [Netmcore] | let res_opt = join join_point pid: Waits until the processpidis done, and returns the result value if any. | 
| join_nowait [Netmcore_process] | 
Like  join, but it is not waited for the termination of the process. | 
| join_nowait [Netmcore] | let res_opt = join_nowait join_point pid: Checks if the processpidis done, and returns the result value if so. | 
| join_path [Neturl] | 
Concatenates the path components (reverse function of split_path).
 | 
| K | |
| keep_away_from [Netsys_signal] | keep_away_from signo: This signalsignois added to the 
      "keep away list". | 
| keep_away_list [Netsys_signal] | 
Returns the "keep away list".
 | 
| key [Http_client] | 
Create a key object
 | 
| keyserv_connector [Rpc_xti_client] | 
Returns a connector that can be used to call the
 keyserv daemon.
 | 
| kill [Shell_sys] | 
Sends a signal to the passed process.
 | 
| kill_all_subprocesses [Netsys_posix] | kill_all_subprocess signal override nogroup: 
      Sends a signal to potentially
      all subprocesses. | 
| kill_process_group [Shell_sys] | 
Kills the process group if it is still (at least partially) running.
 | 
| kill_processes [Shell_sys] | 
Kills the individual processes of the job which are still running.
 | 
| kill_subprocess [Netsys_posix] | 
Sends this signal to the subprocess if this process still exists.
 | 
| killpg_all_subprocesses [Netsys_posix] | killpg_all_subprocess signal override: Sends a signal to potentially
      all subprocesses belonging to a process group (i.e. | 
| killpg_subprocess [Netsys_posix] | 
Sends this signal to the process group of the subprocess if there
      is still a watched subprocess belonging to this group.
 | 
| L | |
| l9n_from_locale [Netdate] | 
Retrieves the localization from the passed locale (use "" for the
      standard locale).
 | 
| last_chars [Netstring_pcre] | 
Same as  string_before | 
| last_chars [Netstring_str] | 
Same as  string_after | 
| le_uint4 [Rtypes] | |
| le_uint4 [Netnumber] | |
| le_uint8 [Netnumber] | |
| left_pair_manager [Netshm_data] | 
Uses the same representation as  pair_manager, but the resulting
 data manager only reads the left value of the pair. | 
| length [Netpagebuffer] | 
The length
 | 
| length [Netbuffer] | 
Returns the logical length of the buffer
 | 
| length [Netshm_array] | 
Returns the length of the array
 | 
| length [Netshm_hashtbl] | length tblreturns the number of bindings intbl. | 
| length [Netshm] | length tblreturns the number of bindings intbl. | 
| length [Netmcore_hashtbl] | Hashtbl.length tblreturns the number of bindings intbl. | 
| length [Netmcore_buffer] | 
Returns the length
 | 
| length [Netmcore_queue] | 
Returns the number of elements in the queue (O(1))
 | 
| length [Netmcore_array] | 
Returns the length
 | 
| length_mstrings [Xdr_mstring] | 
returns the sum of the lengths of the mstrings
 | 
| length_of_packed_value [Rpc_packer] | |
| level_names [Netlog] | 
The level names indexed by weight
 | 
| level_of_string [Netlog] | |
| level_of_string [Netplex_log] | 
Convert a string to a level
 | 
| level_weight [Netlog] | 
A number correspondig to the level
 | 
| level_weight [Netplex_log] | 
An integer corresponding to the level
 | 
| 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_channelorraw_in_channel, depending on the passed
 variant, into a fullin_obj_channelobject. | 
| lift_out [Netchannels] | 
Turns a  rec_out_channelorraw_out_channel, depending on the passed
 variant, into a fullout_obj_channelobject. | 
| linear_distributor [Nethttpd_services] | 
Configures linear distribution
 | 
| lines_of_in_obj_channel [Netchannels] | 
Reads from the input channel until EOF and returns the lines
 as string list.
 | 
| linkat [Netsys_posix] | linkat olddirfd oldpath newdirfd newpath flags | 
| list [Netsys_signal] | 
Returns the list of signal handlers
 | 
| list_header [Mimestring] | list_header s pos len: Returns the headers as list of pairs(name,value). | 
| list_method [Ftp_client] | 
Lists the contents of the directory  dirusing the LIST command. | 
| listener [Uq_engines] | 
This engine creates a server socket listening on the  listen_address. | 
| literal_glob_expr [Netglob] | 
Returns an expression that matches literally the passed string
 | 
| local_fs [Netfs] | local_fs(): Returns a filesystem object for the local filesystem. | 
| local_fsys [Netglob] | 
Accesses the local filesystem
 | 
| local_interpreter [Shell_fs] | 
Executes commands on the local machine
 | 
| local_path_of_file_url [Neturl] | 
Extracts the path from an absolute file URL, and returns a
 correct path name.
 | 
| local_user_info [Netglob] | 
Get the home directory of a user from the local user database.
 | 
| localzone [Netdate] | 
The offset in minutes for the local time zone from the UTC.
 | 
| localzone_nodst [Netdate] | 
Returns the offset for the local time zone for the case that
      daylight savings are not effective.
 | 
| lock [Netmappings] | |
| lock [Netplex_mutex] | 
Wait until the mutex is free, and locks it
 | 
| lock [Netmcore_mutex] | 
Locks the mutex
 | 
| log [Netlog.Debug] | 
Writes a log message
 | 
| log [Netlog] | 
Writes a log message
 | 
| log [Netplex_cenv] | 
Writes a log message
 | 
| logand_inet_addr [Netsys] | 
Returns the bitwise AND of the two argument addresses
 | 
| logf [Netlog.Debug] | 
Writes a log message like  printf | 
| logf [Netlog] | 
Writes a log message like  printf | 
| logf [Netplex_cenv] | 
Writes a log message like  printf | 
| logger_factories [Netplex_log] | 
All built-in logger factories
 | 
| logical_int32_of_uint4 [Rtypes] | |
| logical_int32_of_uint4 [Netnumber] | |
| logical_int64_of_uint8 [Rtypes] | |
| logical_int64_of_uint8 [Netnumber] | |
| logical_uint4_of_int32 [Rtypes] | |
| logical_uint4_of_int32 [Netnumber] | |
| logical_uint8_of_int64 [Rtypes] | |
| logical_uint8_of_int64 [Netnumber] | |
| login_method [Ftp_client] | 
This FTP method logs the  userin. | 
| lognot_inet_addr [Netsys] | 
Returns the bitwise NOT of the argument address
 | 
| logor_inet_addr [Netsys] | 
Returns the bitwise OR of the two argument addresses
 | 
| logxor_inet_addr [Netsys] | 
Returns the bitwise XOR of the two argument addresses
 | 
| lookup [Netsys_win32] | 
Returns the real object behind a proxy descriptor, or raises
       Not_found. | 
| lookup [Netplex_cenv] | lookup service_name protocol_nametries to find a Unix domain
      socket for the service and returns it. | 
| lookup_camlbox_address [Netmcore_camlbox] | 
Returns the address of the camlbox identified by this resource ID
 | 
| lookup_camlbox_sender [Netmcore_camlbox] | lookup_camlbox_sender res_id: 
      Returns the sender object of the camlbox identified by this resource ID | 
| lookup_container_sockets [Netplex_cenv] | lookup_container_sockets service_name protocol_name: returns
      the Unix Domain paths of all container sockets for this service and
      protocol. | 
| lookup_decoder [Netcompression] | 
Returns the decoder, or raises  Not_found | 
| lookup_encoder [Netcompression] | 
Returns the encoder, or raises  Not_found | 
| lookup_event [Netsys_win32] | |
| lookup_executable [Shell_sys] | 
Searches an executable file.
 | 
| lookup_input_thread [Netsys_win32] | |
| lookup_output_thread [Netsys_win32] | 
Returns the real object.
 | 
| lookup_pipe [Netsys_win32] | |
| lookup_pipe_server [Netsys_win32] | |
| lookup_process [Netsys_win32] | |
| loop [Uq_libevent.LIBOEVENT] | |
| lt_uint4 [Rtypes] | lt_uint4is true iff the first value is less than the second value 
      as unsigned int | 
| lt_uint4 [Netnumber] | lt_uint4is true iff the first value is less than the second value 
      as unsigned int | 
| lt_uint8 [Netnumber] | lt_uint8is true iff the first value is less than the second value 
      as unsigned int | 
| M | |
| m [Netmech_scram.AES_CTS] | |
| main [Netcgi_apache.Apache.Request] | request_recmainfield. | 
| make [Nethttp.Cookie] | make ?expires ?domain ?path ?secure name valuecreates a new
        cookie with namenameholdingvalue. | 
| make [Netmcore_matrix] | make pool_id n1 n2 x h:
      Creates a matrix of the passed number of elements (n1 * n2), 
      copies the elementx, and initializes each element of the new array
      with the single copy ofx. | 
| make [Netmcore_array] | make pool_id n x h:
      Creates a shared array of the passed number of elements, 
      copies the elementx, and initializes each element of the new array
      with the single copy ofx. | 
| make [Netcgi.Cookie] | make ?expires ?domain ?path ?secure name valuecreates a new
        cookie with namenameholdingvalue. | 
| make [Netcgi_common.Cookie] | |
| make_pattern [Netaux.KMP] | |
| make_temporary_file [Netchannels] | 
Creates a temporary file in the directory  tmp_directorywith a name
 prefixtmp_prefixand a unique suffix. | 
| make_url [Neturl] | 
Creates a URL from components:
 | 
| make_var_type [Netplex_cenv] | 
Create get and set functions for any (monomorphic) type.
 | 
| makechar [Netconversion] | makechar enc i:Creates the string representing the Unicode code pointiin encodingenc. | 
| manage [Netshm_array] | 
Manages a shared memory object as an array,
 including the representation of arbitrary O'Caml values.
 | 
| manage [Netshm_hashtbl] | 
Manages a shared memory object as a hash table like  Netshm.manage,
 and additionally represent arbitrary O'Caml values. | 
| manage [Netshm] | 
Starts managing an open shared memory object as  shm_table. | 
| manage_file [Netmcore] | 
hands over a file to the manager
 | 
| manage_sem [Netmcore] | 
hands over a named semaphore to the manager
 | 
| manage_shm [Netmcore] | 
hands over a named shm object to the manager
 | 
| manage_shm_sc [Netmcore] | 
hands over a named shm object plus semaphore container to the manager
 | 
| map_engine [Uq_engines] | 
Same as function
 | 
| map_list [Nethtml] | map_list f doclst:
 Appliesfto all attribute values and data strings (except
 the attributes of "?", "!", or "--" nodes). | 
| map_xv_enum_fast [Xdr] | 
Works for both  XV_enumandXV_enum_fast | 
| map_xv_struct_fast [Xdr] | 
Works for both  XV_structandXV_struct_fast | 
| map_xv_union_over_enum_fast [Xdr] | 
Works for both  XV_union_over_enumandXV_union_over_enum_fast. | 
| match_beginning [Netstring_pcre] | 
Extracts the matched part from the string.
 | 
| match_beginning [Netstring_str] | 
Returns the position where the matched part begins
 | 
| match_end [Netstring_pcre] | 
Returns the position where the matched part begins
 | 
| match_end [Netstring_str] | 
Returns the position where the matched part ends
 | 
| match_glob_expr [Netglob] | 
Matches the glob_expr against a string.
 | 
| matched_group [Netstring_pcre] | 
Returns the position where the matched part ends
 | 
| matched_group [Netstring_str] | 
Extracts the substring the nth group matches from the whole
 string.
 | 
| matched_string [Netstring_pcre] | 
Searches a match of the string with the regexp, starting at
 the position and in backward direction.
 | 
| matched_string [Netstring_str] | 
Extracts the matched part from the string.
 | 
| max_age [Nethttp.Cookie] | 
The expiration time of the cookie, in seconds.
 | 
| max_age [Netcgi.Cookie] | 
The expiration time of the cookie, in seconds.
 | 
| max_age [Netcgi_common.Cookie] | 
The expiration time of the cookie, in seconds.
 | 
| max_int4 [Netnumber] | |
| max_int8 [Netnumber] | |
| max_uint4 [Netnumber] | |
| max_uint8 [Netnumber] | |
| mcast_add_membership [Netsys] | 
Join a multicast group.
 | 
| mcast_drop_membership [Netsys] | 
Leave a multicast group.
 | 
| mcast_set_loop [Netsys] | 
Whether sent multicast messages are received by the sending host
 | 
| mcast_set_ttl [Netsys] | 
Set TTL/hops value
 | 
| mclient_serial [Rpc_proxy.ManagedClient] | 
Get the serial number of the connection.
 | 
| mclient_state [Rpc_proxy.ManagedClient] | 
Get the state
 | 
| mdtm_method [Ftp_client] | 
Determines the date and time of the last modification of  file. | 
| mem [Netshm_hashtbl] | mem tbl keychecks ifkeyis bound intbl. | 
| mem [Netshm] | mem tbl keychecks ifkeyis bound intbl. | 
| mem [Netmcore_hashtbl] | 
Safe version of  mem_roin the presence of parallel modifications. | 
| mem_read [Netsys_mem] | 
A version of  Unix.readthat uses amemorybuffer. | 
| mem_recv [Netsys_mem] | |
| mem_ro [Netmcore_hashtbl] | Hashtbl.mem tbl xchecks ifxis bound intbl. | 
| mem_send [Netsys_mem] | 
Versions of  Unix.recv, andUnix.sendusingmemorybuffers. | 
| mem_write [Netsys_mem] | 
A version of  Unix.single_writethat uses amemorybuffer. | 
| memory [Netshm] | |
| memory_address [Netsys_mem] | 
Returns the start address of the buffer
 | 
| memory_based_mstrings [Xdr_mstring] | 
Uses memory to represent mstrings.
 | 
| memory_map_file [Netsys_mem] | memory_map_file fd shared size: Mapssizebytes of the filefdinto memory, and returns the memory buffer likeBigarray.Array1.map_file. | 
| memory_of_bigarray [Netsys_mem] | |
| memory_of_bigarray_1 [Netsys_mem] | |
| memory_of_bigarray_2 [Netsys_mem] | |
| memory_of_bigarray_3 [Netsys_mem] | 
These functions return an arbitrary bigarray as  memory. | 
| memory_pool_based_mstrings [Xdr_mstring] | 
Uses memory to represent mstrings.
 | 
| memory_to_mstring [Xdr_mstring] | 
Represent memory as mstring (no copy)
 | 
| memory_unmap_file [Netsys_mem] | 
Unmaps the file.
 | 
| meta_engine [Uq_engines] | 
Same as function
 | 
| method_distributor [Nethttpd_services] | 
Configures method distribution
 | 
| method_name [Netcgi_apache.Apache.Request] | request_recmethodfield. | 
| method_number [Netcgi_apache.Apache.Request] | request_recmethod_numberfield (given symbolically
          instead of a number). | 
| mime [Netcgi.Argument] | mime_arg ?name msgcreates a MIME-structured CGI argument
	callednamewith contentsmsg. | 
| min_int4 [Netnumber] | |
| min_int8 [Netnumber] | |
| min_uint4 [Netnumber] | |
| min_uint8 [Netnumber] | |
| minimum_size [Netmcore_heap] | 
Returns the  sizevalue one must pass tocreate_heapat minimum
      to put this root element onto the heap. | 
| mk_date [Netdate] | 
Format the seconds (plus nanos if present) as a string
 | 
| mk_dlog [Netlog.Debug] | let dlog = mk_dlog "M" enable: The conditional debug function | 
| mk_dlogr [Netlog.Debug] | let dlogr = mk_dlog "M" enable: The conditional debug function | 
| mk_fp4 [Rtypes] | |
| mk_fp4 [Netnumber] | |
| mk_fp8 [Rtypes] | |
| mk_fp8 [Netnumber] | |
| mk_int4 [Rtypes] | |
| mk_int4 [Netnumber] | |
| mk_int8 [Rtypes] | |
| mk_int8 [Netnumber] | |
| mk_internet_date [Netdate] | 
Convert the time (seconds since the epoch) to a date string that
 conforms to RFC 3339.
 | 
| 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_uint4 [Rtypes] | |
| mk_uint4 [Netnumber] | |
| mk_uint8 [Rtypes] | mk_<t> create integer values from character tuples. | 
| mk_uint8 [Netnumber] | mk_<t> create integer values from character tuples. | 
| 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).
 | 
| mkdir_method [Ftp_client] | 
Creates the named directory
 | 
| mkdirat [Netsys_posix] | 
Same as  Unix.mkdirbut the file is taken relative to the directory
      given by first argument | 
| mkfifoat [Netsys_posix] | mkfifoat dirfd path mode | 
| mknod [Netsys_posix] | 
Creates the node with the given permissions and the given type
 | 
| mlsd_method [Ftp_client] | 
Gets the entries for this directory.
 | 
| mlst_method [Ftp_client] | 
Get the file entry for  file. | 
| modify [Netplex_main] | 
Modifies the command-line configuration object
 | 
| modify [Netmcore_heap] | modify h mutate: This function locks the heap so that this process
      has exclusive write access to it for the duration of themutatefunction. | 
| modify_close_on_exec [Netsys_win32] | 
Sets the close-on-exec flag, i.e.
 | 
| modify_fd_event_source [Netsys_posix] | 
Modifies the set of events monitored at this event source
 | 
| modify_url [Neturl] | 
Modifies the passed components and returns the modified URL.
 | 
| moncontrol [Netsys] | 
Interface to the  moncontrolroutine of the GPROF profiler. | 
| monitor_async [Uq_mt] | let result = monitor_async f arg: For calling RPC-style 
      asynchronous clients. | 
| monitor_do [Uq_mt] | let result = monitor_do mon f arg: Just runsf argin the
      scope of the monitor, and returns the result. | 
| monitor_run [Uq_mt] | let result = monitor_run mon f outer_esys arg: 
      Runs another engine within the
      monitor. | 
| move [Netconversion] | 
Moves the cursor one character to the right, or if  numis passed,
 this number of characters to the right. | 
| mp [Netplex_mp] | 
Uses  Unix.forkto create new threads. | 
| mset_load [Rpc_proxy.ManagedSet] | 
Returns the number of pending calls per service
 | 
| mset_pick [Rpc_proxy.ManagedSet] | 
Pick an mclient for another call, or raise  Cluster_service_unavailable. | 
| mset_services [Rpc_proxy.ManagedSet] | 
Returns the service array
 | 
| mstrings_of_packed_value [Rpc_packer] | |
| msync_engine [Uq_engines] | 
Same as function
 | 
| mt [Netplex_mt] | 
Uses  Thread.createto create new threads | 
| multi_file_logger [Netplex_log] | |
| multi_file_logger_factory [Netplex_log] | 
Reads a logging section like
 | 
| mut_pool [Netmcore_heap] | 
Return the pool ID
 | 
| mut_sem_container [Netmcore_heap] | 
Return the semaphore container
 | 
| N | |
| n_fold [Netauth] | 
Blumenthal's n-fold algorithm for an n that is divisible by 8.
 | 
| name [Nethttp.Cookie] | 
The name of the cookie.
 | 
| name [Netcgi.Cookie] | 
The name of the cookie.
 | 
| name [Netcgi_common.Cookie] | |
| name_of_shm [Netshm] | 
Returns the name of an object
 | 
| names [Netlog.Debug] | 
Return the possible module names for  enable_moduleanddisable_module | 
| nanosleep [Netsys_posix] | nanosleep t t_rem: Sleeps fortseconds. | 
| nativeint_manager [Netshm_data] | 
Uses either  int32_managerorint64_managerto representnativeint,
 depending on the size ofnativeint. | 
| net_get [Rpc_key_service] | |
| nethttpd_factory [Nethttpd_plex] | 
Factory for a web server component.
 | 
| nethttpd_processor [Nethttpd_plex] | netplex_processor mk_config http_service: Creates a Netplex processor
 for Nethttpd. | 
| new_cb_id [Http_client] | 
Allocates and returns a new ID
 | 
| new_group [Unixqueue] | 
Create a new, empty group for the event system
 | 
| new_job [Shell_sys] | 
Creates a new job descriptor.
 | 
| new_serial [Netlog.Debug] | 
Create new serial number
 | 
| new_wait_id [Unixqueue] | 
Create a new unique wait identifier
 | 
| next [Netcgi_apache.Apache.Request] | request_recnextfield. | 
| nlst_method [Ftp_client] | 
Lists the contents of the directory  dirusing the NLST command
 Therepresentationmust not be`Image. | 
| norm_path [Neturl] | 
Removes  "."and".."from the path if possible. | 
| note_auth_failure [Netcgi_apache.Apache.Request] | 
Set headers to tell browser that authentication failed.
 | 
| note_basic_auth_failure [Netcgi_apache.Apache.Request] | 
Set headers to tell browser that basic authentication failed.
 | 
| note_digest_auth_failure [Netcgi_apache.Apache.Request] | 
Set headers to tell browser that digest authentication failed.
 | 
| notes [Netcgi_apache.Apache.Request] | request_recnotesfield. | 
| nt_anonymous [Netgssapi] | 
anonymous name
 | 
| nt_export_name [Netgssapi] | 
an export name
 | 
| nt_hostbased_service [Netgssapi] | 
names like "service
 | 
| nt_machine_uid_name [Netgssapi] | 
user ID in host byte order
 | 
| nt_string_uid_name [Netgssapi] | 
user ID as string of digits
 | 
| nt_user_name [Netgssapi] | 
names like "username"
 | 
| nth [Netbuffer] | 
Alias for  get | 
| null [Rpc_portmapper] | 
Calls the 'NULL' procedure of the portmapper.
 | 
| null_dlogger [Netlog.Debug] | 
The "logger" not printing anything
 | 
| null_proc_name [Rpc_program] | 
Returns the name of procedure 0 (or  Noneif not found) | 
| null_url [Neturl] | 
A URL without any component and  null_url_syntax | 
| null_url_syntax [Neturl] | 
An URL syntax that recognizes nothing.
 | 
| O | |
| obj_address [Netsys_mem] | |
| of_compat_activation [Netcgi1_compat.Netcgi_types] | 
Portage:  of_compat_activationconverts an old style 
        cgi_activation to a new CGI-like object. | 
| of_compat_argument [Netcgi1_compat.Netcgi_types] | 
Portage:  of_compat_argument aconverts an old style argumentato a new style one. | 
| of_compat_config [Netcgi1_compat.Netcgi_env] | 
Portage:  of_compat_config ctransform the old configurationcinto one suitable for the new interface. | 
| of_compat_environment [Netcgi1_compat.Netcgi_env] | 
Portage:  of_compat_environment econverts the old environmenteto the new interface. | 
| of_netscape_cookie [Nethttp.Cookie] | 
Convert a Netscape cookie to the new representation
 | 
| of_netscape_cookie [Netcgi.Cookie] | 
Convert a Netscape cookie to the new representation
 | 
| of_record [Netcgi_common.Cookie] | 
Conversion from the deprecated style of cookie.
 | 
| of_stream_fs [Netglob] | 
Use an arbitrary network filesystem for globbing
 | 
| oid_to_der [Netgssapi] | |
| oid_to_string [Netgssapi] | |
| once [Unixqueue] | 
Arranges that the callback function is called once after the 
 passed period of time (the  floatargument) has elapsed. | 
| open_shm [Netshm] | 
Opens the shared memory object.
 | 
| openat [Netsys_posix] | 
Same as  Unix.openfilebut open relative to the directory given
      by first argument | 
| openlog [Netsys_posix] | openlog ident options facility: Opens a log stream. | 
| option_manager [Netshm_data] | 
Creates a data manager from an input data manager for optional values
 | 
| option_of_char [Telnet_client] | 
Converts a character representing an option to the internal option
 name.
 | 
| options_service [Nethttpd_services] | 
This service responds to "OPTIONS *" requests, and nothing else
 | 
| output [Netcgi_apache.Apache.Request] | output r s ofs lensends[ofs .. len-1]back to the
	  client. | 
| output_e [Uq_io] | let e = output_e d s pos len: Outputs data todand takes it
      from the stringsstarting atposand with maximum lengthlen. | 
| output_file_response [Nethttpd_types] | 
Outputs the contents of a file as response body, together with the given status and
 the header (optional).
 | 
| output_memory_e [Uq_io] | let e = output_string_e d m: Outputs the bigarraymtod,
      and transitions to`Done()when done. | 
| output_netbuffer_e [Uq_io] | let e = output_string_e d b: Outputs the contents ofbtod,
      and transitions to`Done()when done. | 
| output_static_response [Nethttpd_types] | 
Outputs the string argument as response body, together with the given status and
 the header (optional).
 | 
| output_std_response [Nethttpd_types] | 
Outputs a "standard response" for the  http_status. | 
| output_stream_adapter [Shell_fs] | 
Arranges that the output of a shell command is made available as
      an  in_obj_channel: | 
| output_string_e [Uq_io] | let e = output_string_e d s: Outputs the stringstod,
      and transitions to`Done()when done. | 
| output_thread_event [Netsys_win32] | 
This event is signaled when there is space in the buffer,
      or when there is an error condition
 | 
| output_thread_proxy_descr [Netsys_win32] | 
Returns the proxy descriptor
 | 
| output_thread_write [Netsys_win32] | output_thread_write t s pos len: Tries to write data to the buffer. | 
| P | |
| pack_accepting_reply [Rpc_packer] | |
| pack_call [Rpc_packer] | |
| pack_call_gssapi_header [Rpc_packer] | |
| pack_rejecting_reply [Rpc_packer] | |
| pack_successful_reply [Rpc_packer] | |
| pack_successful_reply_raw [Rpc_packer] | |
| pack_xdr_value [Xdr] | |
| pack_xdr_value_as_mstrings [Xdr] | 
The concatanated mstrings are the packed representation
 | 
| pack_xdr_value_as_string [Xdr] | 
rm: If true, four null bytes are prepended to the string for the
        record mark
 | 
| packed_value_of_mstrings [Rpc_packer] | |
| packed_value_of_string [Rpc_packer] | |
| page_for_additions [Netpagebuffer] | let (m,pos,len) = page_for_additions b: Returns the last page 
      inm, the first free byte on the page inpos, and 
      the number of free bytes on the page inlen. | 
| page_for_consumption [Netpagebuffer] | let (m,pos,len) = page_for_consumption b: Returns the first page 
      inm, the first used byte on the page inpos, and 
      the number of used bytes on the page inlen. | 
| pagesize [Netsys_mem] | 
The best guess at the page size
 | 
| pair_manager [Netshm_data] | 
Creates a compound manager for pairs from two input managers
 | 
| paligned_memory_based_mstrings [Xdr_mstring] | 
Uses memory to represent mstrings.
 | 
| 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] | |
| params [Xdr] | 
return the  X_paramparameters contained in the type | 
| 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  lexbufand returns it. | 
| parse_epoch [Netdate] | 
Parse a string and return the time (integral seconds since the epoch)
 | 
| parse_epoch_approx [Netdate] | 
Parse a string and return the time (approximate seconds since the epoch)
 | 
| parse_epoch_timespec [Netdate] | 
Parse a string and return the time (seconds and nanos since the epoch)
 | 
| parse_glob_expr [Netglob] | 
Parses the glob expression.
 | 
| parse_hostbased_service [Netgssapi] | 
Returns ( service,host) for "service | 
| parse_mic_token_header [Netgssapi] | 
Returns the triple
      ( sent_by_acceptor,acceptor_subkey,sequence_number) from
      the header of a MIC token that is passed to this function as
      string. | 
| parse_mlsd_document [Ftp_client] | 
Returns the entries contained in the output of  `MLSD | 
| parse_nlst_document [Ftp_client] | 
Returns the filenames contained in the output of  `NLST | 
| parse_no_proxy [Http_client] | 
Parses the value of an environment variable like  no_proxy. | 
| parse_proxy_setting [Http_client] | 
Parses the value of an environment variable like  http_proxy,
      i.e. | 
| parse_url [Neturl] | 
Parses the string and returns the URL the string represents.
 | 
| parse_user_name [Rpc_auth_sys] | 
Parses a user name as returned by  Rpc_server.get_userin conjunction
 with the AUTH_SYS authentication and`Fullformatting. | 
| parse_wrap_token_header [Netgssapi] | let (sent_by_acceptor, sealed, acceptor_subkey, sequence_number) =
      parse_wrap_token_header token | 
| partial_url_syntax [Neturl] | 
Transforms the syntax into another syntax where all required parts are
 changed into optional parts.
 | 
| path [Nethttp.Cookie] | 
The path of the cookie, if set.
 | 
| path [Netcgi.Cookie] | 
The path of the cookie, if set.
 | 
| path [Netcgi_common.Cookie] | |
| path_info [Netcgi_apache.Apache.Request] | request_recpath_infofield. | 
| peek_auth_error [Rpc_packer] | |
| peek_xid [Rpc_packer] | |
| pending_calls [Rpc_proxy.ManagedClient] | 
Returns the number of pending calls
 | 
| performance_event_system [Unixqueue] | 
Same as function
 | 
| performance_pollset [Netsys_pollset_generic] | 
Returns the best available pollset on this platform for high performance
      servers that have to deal with many different file descriptors.
 | 
| pidfile [Netplex_main] | 
Returns the location of the PID file (if any)
 | 
| pin [Netmcore_heap] | pin m x: Pins a shared valuexso it cannot be deleted by
      the garbage collector. | 
| ping [Netcgi_dbi.DBI_DRIVER] | |
| pipe_accept [Netsys_win32] | 
Waits until the connect event is signaled (usually meaning that
      a new client connection is available), and returns the new
      pipe.
 | 
| pipe_connect [Netsys_win32] | pipe_connect name mode: Creates a client pipe handle, and tries
      to connect to the pipe servername. | 
| pipe_connect_event [Netsys_win32] | 
The event object signals when a new client connection is available
 | 
| pipe_descr [Netsys_win32] | 
Returns the proxy descriptor for the pipe.
 | 
| pipe_listen [Netsys_win32] | 
Creates the backlog queue with  nprepared server endpoints. | 
| pipe_mode [Netsys_win32] | |
| pipe_name [Netsys_win32] | |
| pipe_name [Netmcore_condition] | 
Returns the name of the pipe
 | 
| pipe_pair [Netsys_win32] | 
Returns a pair of connected pipes (using automatically generated
      names).
 | 
| pipe_rd_event [Netsys_win32] | |
| pipe_read [Netsys_win32] | pipe_read p s pos len: Tries to read data from the pipe. | 
| pipe_server_descr [Netsys_win32] | 
Returns the proxy descriptor for the pipe server.
 | 
| pipe_server_mode [Netsys_win32] | 
Returns the pipe/server mode
 | 
| pipe_server_name [Netsys_win32] | 
Returns the name of the pipe
 | 
| pipe_shutdown [Netsys_win32] | 
Cancels all pending I/O operations and closes the pipe handle.
 | 
| pipe_shutdown_server [Netsys_win32] | 
Closes the pipe server: All endpoints in the backlog queue are
      shutdown.
 | 
| pipe_wait_connect [Netsys_win32] | 
Wait until a client connects to this server.
 | 
| pipe_wait_rd [Netsys_win32] | |
| pipe_wait_wr [Netsys_win32] | 
Wait until the pipe becomes readable or writable.
 | 
| pipe_wr_event [Netsys_win32] | 
The event objects signaling that read and write operations are possible.
 | 
| pipe_write [Netsys_win32] | pipe_write p s pos len: Tries to write data to the pipe. | 
| plugin [Netplex_mbox] | 
To enable message boxes, call the controller's  add_pluginmethod
      with this object as argument. | 
| plugin [Netplex_mutex] | 
To enable mutexes, call the controller's  add_pluginmethod 
      with this object as argument. | 
| plugin [Netplex_sharedvar] | 
To enable shared variables, call the controller's  add_pluginmethod
      with this object as argument. | 
| plugin [Netplex_semaphore] | 
To enable semaphores, call the controller's  add_pluginmethod 
      with this object as argument. | 
| pmanage [Netsys_pmanage] | 
Create a new manager for persistent kernel objects.
 | 
| pmanage [Netplex_cenv] | 
Access the manager for persistent kernel objects with limited
      lifetime.
 | 
| pmap_port [Rpc_portmapper_aux] | |
| pmapproc_callit [Rpc_portmapper_clnt.PMAP.V2] | |
| pmapproc_callit [Rpc_portmapper_clnt.Make'PMAP.V2] | |
| pmapproc_callit'async [Rpc_portmapper_clnt.PMAP.V2] | |
| pmapproc_callit'async [Rpc_portmapper_clnt.Make'PMAP.V2] | |
| pmapproc_dump [Rpc_portmapper_clnt.PMAP.V2] | |
| pmapproc_dump [Rpc_portmapper_clnt.Make'PMAP.V2] | |
| pmapproc_dump'async [Rpc_portmapper_clnt.PMAP.V2] | |
| pmapproc_dump'async [Rpc_portmapper_clnt.Make'PMAP.V2] | |
| pmapproc_getport [Rpc_portmapper_clnt.PMAP.V2] | |
| pmapproc_getport [Rpc_portmapper_clnt.Make'PMAP.V2] | |
| pmapproc_getport'async [Rpc_portmapper_clnt.PMAP.V2] | |
| pmapproc_getport'async [Rpc_portmapper_clnt.Make'PMAP.V2] | |
| pmapproc_null [Rpc_portmapper_clnt.PMAP.V2] | |
| pmapproc_null [Rpc_portmapper_clnt.Make'PMAP.V2] | |
| pmapproc_null'async [Rpc_portmapper_clnt.PMAP.V2] | |
| pmapproc_null'async [Rpc_portmapper_clnt.Make'PMAP.V2] | |
| pmapproc_set [Rpc_portmapper_clnt.PMAP.V2] | |
| pmapproc_set [Rpc_portmapper_clnt.Make'PMAP.V2] | |
| pmapproc_set'async [Rpc_portmapper_clnt.PMAP.V2] | |
| pmapproc_set'async [Rpc_portmapper_clnt.Make'PMAP.V2] | |
| pmapproc_unset [Rpc_portmapper_clnt.PMAP.V2] | |
| pmapproc_unset [Rpc_portmapper_clnt.Make'PMAP.V2] | |
| pmapproc_unset'async [Rpc_portmapper_clnt.PMAP.V2] | |
| pmapproc_unset'async [Rpc_portmapper_clnt.Make'PMAP.V2] | |
| poll [Netsys_posix] | poll a n tmo: Poll for the events of the cells 0 ton-1of 
      poll arraya, and set thepoll_act_eventsmember of all cells. | 
| poll_array_length [Netsys_posix] | 
Return the number of cells in the poll array
 | 
| poll_based_pollset [Netsys_pollset_posix] | 
Returns a poll set whose implementation is based on the  pollsystem
      call. | 
| poll_err_result [Netsys_posix] | |
| poll_event_sources [Netsys_posix] | poll_event_sources ea tmo: First, all modifications are pushed
      to the kernel, and polling is set up to get events. | 
| poll_hup_result [Netsys_posix] | |
| poll_null_events [Netsys_posix] | 
Create an empty set of  poll_act_events, for initilization
      of poll cells. | 
| poll_nval_result [Netsys_posix] | 
Look for the bit in  poll_act_eventsand return the status | 
| poll_pri_result [Netsys_posix] | |
| poll_rd_result [Netsys_posix] | |
| poll_req_events [Netsys_posix] | poll_req_events rd wr pri: Create a set of in events consisting
      of the bitsrd,wr, andpri. | 
| poll_req_triple [Netsys_posix] | 
Looks into a  poll_req_eventsvalue, and returns the triple(rd,wr,pri). | 
| poll_result [Netsys_posix] | 
Look whether there is any event in  poll_out_events | 
| poll_single [Netsys_posix] | poll_single fd rd wr pri tmo: Polls a single descriptor for the
      events given byrd,wr, andpri. | 
| poll_wr_result [Netsys_posix] | |
| pollset [Netsys_pollset_win32] | 
This is a pollset implementation that works for  sockets, and, named pipes as provided by  Netsys_win32(add the descriptors
         returned bypipe_descrorpipe_server_descrto the pollset)
      The number of descriptors that can be added to the pollset
      has a quite low limit (usually 63 sockets or 31 pipes). | 
| pollset_event_system [Unixqueue_pollset] | 
Implements a unixqueue on top of a pollset.
 | 
| pool [Netmcore_heap] | 
Return the pool ID
 | 
| pool_alloc_memory [Netsys_mem] | let m = pool_alloc_memory p: 
      Gets a memory blockmfrom the poolp. | 
| pool_alloc_memory2 [Netsys_mem] | let m, free = pool_alloc_memory2 p: 
      Gets a memory blockmfrom the poolplikepool_alloc_memory. | 
| pool_block_size [Netsys_mem] | 
Returns the size of the memory blocks in bytes
 | 
| pool_reclaim [Netsys_mem] | 
Reclaim as much memory as possible
 | 
| pool_report [Netsys_mem] | 
Returns a report describing the memory allocation in the pool
 | 
| pop_c [Netmcore_queue] | pop_c q: Takes the first elementxfrom the queue, removes it
      there, and returns a copy ofxin normal memory. | 
| pop_p [Netmcore_queue] | pop_p q f: Takes the first elementxfrom the queue, removes it
      there, and callsf x. | 
| port [Netcgi_apache.Apache.Request] | 
Server port.
 | 
| port_of_program [Rpc_portmapper] | port_of_program program host protocol:
 queries the portmapper running onhostfor theprogramregistered
 forprotocol. | 
| ports [Nethttp.Cookie] | port cthe ports to which the cookie may be returned or[]if
	not set. | 
| ports [Netcgi.Cookie] | port cthe ports to which the cookie may be returned or[]if
	not set. | 
| ports [Netcgi_common.Cookie] | |
| posix_l9n [Netdate] | 
The standard POSIX localization (English names)
 | 
| posix_openpt [Netsys_posix] | posix_openpt noctty: Opens an unused PTY master. | 
| post [Netmcore_sem] | 
Increments the semaphore by one, and notifies one of the waiting
      processes.
 | 
| postprocess_job [Shell] | 
Looks at the error codes of the job, and raises
  Subprocess_errorwhen there is an error that cannot be ignored. | 
| prefix [Netsys_sem] | 
Return the prefix
 | 
| prefix_mstrings [Xdr_mstring] | prefix_mstrings l n: returns the firstnchars of the 
      concatenated mstringslas single string | 
| prefix_of_packed_value [Rpc_packer] | 
The first n bytes of the packed value
 | 
| prev [Netcgi_apache.Apache.Request] | request_recprevfield. | 
| print_buffer [Netbuffer] | 
For the toploop
 | 
| print_char [Netcgi_apache.Apache.Request] | 
Send a character back to the client.
 | 
| print_endline [Netcgi_apache.Apache.Request] | 
Send a string followed by CR LF back to the client.
 | 
| print_float [Netcgi_apache.Apache.Request] | 
Send a floating-point number back to the client.
 | 
| print_glob_expr [Netglob] | 
Prints the glob expression as string.
 | 
| print_in_obj_stream [Netstream] | 
A top-loop printer for streams
 | 
| print_int [Netcgi_apache.Apache.Request] | 
Send a decimal number back to the client.
 | 
| print_newline [Netcgi_apache.Apache.Request] | 
Send a CR LF back to the client.
 | 
| print_s_param [Mimestring] | 
Prints a parameter to the formatter (as toploop printer)
 | 
| print_string [Netcgi_apache.Apache.Request] | 
Send a string back to the client.
 | 
| print_url [Neturl] | 
Printer for the toploop.
 | 
| prioritizer [Uq_engines] | 
Same as function
 | 
| procedure_number [Rpc_program] | procedure_number p namereturns only the procedure number
 of the procedure calledname. | 
| process_connection [Nethttpd_engine] | 
Sets up an engine that processes all requests using the service description.
 | 
| process_connection [Nethttpd_reactor] | 
Processes all HTTP requests in turn arriving at the file descriptor, and
 calls the service provider for every request.
 | 
| process_descr [Netsys_win32] | 
Returns the proxy descriptor of the process
 | 
| process_group_id [Shell_sys] | 
Returns the Unix ID of the process group as number > 1.
 | 
| process_group_leader [Shell_sys] | 
Returns the process group leader process.
 | 
| process_id [Shell_sys] | 
Returns the process ID of the process
 | 
| processes [Shell_sys] | 
Returns the processes that have actually been started for this job
 by  run_job; note that the corresponding Unix process group
 may have additional processes (e.g. | 
| profile [Netmech_scram] | 
Creates a profile
 | 
| program [Rpc_client] | 
Returns the program the client represents.
 | 
| program_PMAP'V2 [Rpc_portmapper_aux] | |
| program_number [Rpc_program] | 
Return the program number
 | 
| programs [Rpc_client] | 
Returns the list of all bound programs
 | 
| props_of_file [Netcgi_ajp] | props_of_file fnameparses the property filefnameand
      returns it as an associative list. | 
| proto_num [Netcgi_apache.Apache.Request] | request_recproto_numfield. | 
| protocol [Netcgi_apache.Apache.Request] | request_recprotocolfield. | 
| protocol_of_string [Nethttp] | 
Parses the protocol string, e.g.
 | 
| protostring_of_inet_addr [Netsys] | |
| provider [Netsys_oothr] | 
Return the multi-threading provider
 | 
| proxy_only_cb_id [Http_client] | 
Identifies a channel binding to web proxy connections.
 | 
| ptrace_verbosity [Rpc_server.Debug] | 
How verbose the ptrace is.
 | 
| ptrace_verbosity [Rpc_client.Debug] | 
How verbose the ptrace is.
 | 
| ptsname [Netsys_posix] | 
Get the name of the slave PTY
 | 
| push [Netmcore_queue] | push x q: Pushes a copy ofxto the end of the queueq | 
| push_event_updates [Netsys_posix] | 
Pushes all modifications of the sources to the kernel
 | 
| put_method [Ftp_client] | 
This FTP method walks to the right directory and puts  fileto
 the server. | 
| put_string [Netbuffer] | put_string nb pos s: Copies the stringsto the positionposof netbuffernb | 
| Q | |
| qseq_engine [Uq_engines] | 
Almost the same as  seq_engine, but this version does not
      propagate working state (i.e. | 
| query_langinfo [Netsys_posix] | query_langinfo locale: Temporarily sets the passedlocaleand
      determines the language attributes. | 
| quit_method [Ftp_client] | 
Quits and disconnects
 | 
| quote [Netstring_pcre] | 
Parses a case-insensitive regexp
 | 
| quote [Netstring_str] | 
Quotes a string such that it can be included in a regexp
 | 
| quote_set [Netstring_str] | 
Returns a regexp (as string) that matches any of the characters in
      the argument.
 | 
| R | |
| rcache_config [Rpc_proxy.ReliabilityCache] | 
Return the config
 | 
| read_blocks [Netshm] | find_blocks tbl key f: The values may be stored in several
 disk blocks. | 
| read_config_file [Netplex_config] | 
Reads a filename and returns the representation object
 | 
| read_dynamic_service_config [Nethttpd_plex] | read_dynamic_service_config handlers cfg addr uri_path:
      Reads theserviceconfiguration section of type "dynamic" from config 
      filecfgat addressaddr. | 
| read_file_service_config [Nethttpd_plex] | read_file_service_config cfg addr uri_path: Reads theserviceconfiguration section of type "file" from config filecfgat addressaddr. | 
| read_fp4 [Rtypes] | |
| read_fp4 [Netnumber.ENCDEC] | |
| read_fp8 [Rtypes] | |
| read_fp8 [Netnumber.ENCDEC] | |
| read_header [Mimestring] | 
This function expects that the current position of the passed
  in_obj_streamis the first byte of the header. | 
| read_int4 [Rtypes] | |
| read_int4 [Netnumber.ENCDEC] | |
| read_int4_unsafe [Rtypes] | |
| read_int4_unsafe [Netnumber.ENCDEC] | |
| read_int8 [Rtypes] | |
| read_int8 [Netnumber.ENCDEC] | |
| read_int8_unsafe [Rtypes] | |
| read_int8_unsafe [Netnumber.ENCDEC] | |
| read_media_types_file [Nethttpd_services] | 
Reads a text file with two columns where the left column is the
 media type and the right column the corresponding suffix.
 | 
| 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.
 | 
| read_netplex_config [Netplex_config] | 
Reads a Netplex configuration file:
 | 
| read_uint4 [Rtypes] | |
| read_uint4 [Netnumber.ENCDEC] | |
| read_uint4_unsafe [Rtypes] | |
| read_uint4_unsafe [Netnumber.ENCDEC] | |
| read_uint8 [Rtypes] | read_<t> create integer values from the characters found at a 
 certain position in the string. | 
| read_uint8 [Netnumber.ENCDEC] | read_<t> create integer values from the characters found at a
	certain position in the string. | 
| read_uint8_unsafe [Rtypes] | 
Same, but no index check
 | 
| read_uint8_unsafe [Netnumber.ENCDEC] | 
Same, but no index check
 | 
| readlinkat [Netsys_posix] | readlinkat dirfd path | 
| real_select [Netsys_win32] | 
Up to Ocaml 3.10, this function is identical to  Unix.select. | 
| really_gread [Netsys] | really_read fd_style fd s pos len: Reads exactlylenbytes fromfdand stores them insstarting atpos. | 
| really_gwrite [Netsys] | really_write fd_style fd s pos len: Writes exactly thelenbytes
      fromstofdstarting atpos. | 
| really_input_e [Uq_io] | let e = input_e d s pos len: Reads data fromdand puts it into
     the stringsstarting atposand with lengthlen. | 
| really_output_e [Uq_io] | let e = really_output_e d s pos len: Outputs data todand takes it
      from the stringsstarting atposand with lengthlen. | 
| really_read [Netsys] | 
Same as  really_gread `Read_write | 
| really_write [Netsys] | 
Same as  really_gwrite `Read_write | 
| realpath [Netsys_posix] | 
Returns a pathname pointing to the same filesystem object so that
      the pathname does not include "." or ".." or symbolic links.
 | 
| receive [Netplex_mbox.MBOX] | 
Receive a message: It is waited until a sender puts a message into
        the box.
 | 
| recode [Netconversion] | 
 Converts the character sequence contained in the at most  in_lenbytes
 ofin_bufstarting at byte positionin_pos, and writes the result 
 into at mostout_lenbytes ofout_bufstarting at byte positionout_pos. | 
| recode_string [Netconversion] | 
Recodes a complete string from  in_enctoout_enc, and returns it. | 
| record_unavailability [Rpc_proxy.ManagedClient] | 
Increases the error counter in the reliability cache for this
        connection.
 | 
| recover_glob_expr [Netglob] | 
Returns the explicit representation
 | 
| refill [Netulex.ULB] | 
Tries to add characters to the  unicode_lexbufby calling theulb_refillfunction. | 
| regexp [Netstring_pcre] | 
The type of matching results
 | 
| regexp [Netstring_str] | 
Parses a regexp
 | 
| regexp_case_fold [Netstring_pcre] | 
Parses a regexp
 | 
| regexp_case_fold [Netstring_str] | 
Parses a case-insensitive regexp
 | 
| regexp_string [Netstring_pcre] | 
Quotes a string such that it can be included in a regexp
 | 
| regexp_string [Netstring_str] | 
Returns a regexp that matches exactly the string
 | 
| regexp_string_case_fold [Netstring_pcre] | 
Returns a regexp that matches exactly the string
 | 
| regexp_string_case_fold [Netstring_str] | 
Returns a case-insensitive regexp that matches exactly the string
 | 
| register [Netcompression] | 
Registers a compression algorithm.
 | 
| register [Netplex_cenv.LEVER] | let reg_lever = register ctrl raw_lever:
        Registersraw_leverin the controllerctrl, so one can callreg_leverto activate it. | 
| register [Netcgi_apache.Handler] | 
Modules may call  register fn nameto register one or more
        handler functions. | 
| register_cleanup [Netcgi_apache.Apache.Request] | 
Register a cleanup function which is called when the current
          request cycle ends.
 | 
| register_exclusive_handler [Netsys_signal] | 
An exclusive handler for a signal is the only handler for the signal.
 | 
| register_handler [Netsys_signal] | 
This function registers a handler called  namefor signal numbersignal. | 
| register_module [Netlog.Debug] | 
Registers the  enablevariable of the named module | 
| register_post_fork_handler [Netsys_posix] | 
Registers a new post fork handler (MT-Safe)
 | 
| register_printer [Netexn] | register e f: Register that the exception type of the sample
      exceptioneis to be printed byf. | 
| register_subprocess_handler [Netsys_posix] | 
Uses the  Netsys_signalframework to manage the installation of
      the SIGCHLD handler. | 
| 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.
 | 
| release [Netmcore] | 
Release the resource with this ID.
 | 
| release_fd [Netlog.Debug] | 
Removes this descriptor from the descriptor table.
 | 
| release_fork_point [Netmcore_process] | 
Releases a fork point so it is deleted from the internal
      resource table.
 | 
| release_join_point [Netmcore_process] | 
Releases a join point so it is deleted from the internal
      resource table.
 | 
| remote_host [Netcgi_apache.Apache.Connection] | conn_recremote_hostfield. | 
| remote_ip [Netcgi_apache.Apache.Connection] | conn_recremote_ipfield. | 
| remote_time [Rpc_time] | 
Returns the time of the passed server in seconds since the epoch.
 | 
| remove [Netshm_hashtbl] | remove tbl keyremoves the current binding ofkeyintbl,
 restoring the previous binding if it exists. | 
| remove [Netshm] | remove tbl keyremoves the current binding ofkeyintbl,
 restoring the previous binding if it exists. | 
| remove [Netmcore_hashtbl] | Hashtbl.remove tbl xremoves the current binding ofxintbl,
   restoring the previous binding if it exists. | 
| remove_from_url [Neturl] | 
Removes the  truecomponents from the URL, and returns the modified
 URL. | 
| remove_post_fork_handler [Netsys_posix] | 
Removes a post fork handler from the registry (MT-Safe)
 | 
| remove_resource [Unixqueue] | 
Removes the operation from the watch list of the group.
 | 
| rename_method [Ftp_client] | 
Renames the  file_fromintofile_to. | 
| renameat [Netsys_posix] | renameat olddirfd oldpath newdirfd newpath | 
| replace [Netshm_hashtbl] | replace tbl key valuereplaces the current binding ofkeyintblby a binding ofkeytovalue. | 
| replace [Netshm] | replace tbl key valuereplaces the current binding ofkeyintblby a binding ofkeytovalue. | 
| replace [Netmcore_hashtbl] | Hashtbl.replace tbl x yreplaces the current binding ofxintblby a binding ofxtoy. | 
| replace_first [Netstring_pcre] | global_replace re templ s: Replaces all matchings ofreinsbytempl. | 
| replace_first [Netstring_str] | replace_first re templ s: Replaces the first match ofreinsbytempl. | 
| reply [Rpc_server] | 
Asynchronous procedures can reply their results with this function.
 | 
| reply_error [Rpc_server] | 
Like  reply, but an error condition is sent back to the caller. | 
| report_connection_string [Netplex_cenv] | 
Output a log line for the  netplex.connectionsadmin message. | 
| report_signal_as_event [Netsys_posix] | report_signal_as_event ev sigInstalls a new signal handler for
      signalsigso thatevis signalled when a signal arrives. | 
| repr_config_file [Netplex_config] | repr_config_file name tree: converts thetreeto a fullconfig_fileobject. | 
| req_events_of_int [Netsys_posix] | |
| request_time [Netcgi_apache.Apache.Request] | request_recrequest_timefield. | 
| reset [Netsys_pollset_posix] | 
This module may keep some global state.
 | 
| reset [Netbuffer] | 
Empty the buffer, deallocate the internal string, and replace it
        with a new string of length  nthat was allocated byNetbuffer.createn. | 
| reset_event [Netsys_win32] | 
Set the object to "non-signaled" state
 | 
| reset_rcache_error_counter [Rpc_proxy.ReliabilityCache] | 
Reset the error counter for this sockaddr.
 | 
| resize [Netshm_array] | resize a n: Resizes the array to lengthn. | 
| resp_100_continue [Nethttpd_kernel] | 
The predefined token for the "100 Continue" response
 | 
| restart [Netsys] | restart f argcallsf arg, and restarts this call if the
 exceptionUnix_error(EINTR,_,_)is caught. | 
| restart_tmo [Netsys] | restart_tmo f tmocallsfwith a timeout argumenttmo, and
 restarted the call if the exceptionUnix_error(EINTR,_,_)is caught. | 
| restarting_poll [Netsys_posix] | 
A wrapper around  pollthat handles theEINTRcondition | 
| restarting_select [Netsys] | 
A wrapper around  Unix.selectthat handles theEINTRcondition. | 
| restarting_sleep [Netsys] | 
Sleep for the passed time.
 | 
| restore_management [Netsys_signal] | restore_management signo: Restores signal handling management forsignoas defined by
      the handler list for this signal. | 
| restrict_dynamic_service_config [Nethttpd_plex] | 
Restricts the subsections and paremeters in the  serviceconfiguration section of type "dynamic" to the allowed ones. | 
| restrict_file_service_config [Nethttpd_plex] | 
Restricts the subsections and paremeters in the  serviceconfiguration section of type "file" to the allowed ones. | 
| rev_mode [Netsys_win32] | 
Reverses the direction
 | 
| rev_split [Netcgi_common] | split_rev is_delim ssplitsat each characteris_delimand returns the list of substrings in reverse order. | 
| rflush [Netcgi_apache.Apache.Request] | 
Flush any buffered data waiting to be written to the client.
 | 
| rm_htspace [Netcgi_common] | rm_htspace is_space s low upreturns the substrings.[low
      .. up - 1]stripped of possible heading and trailing spaces
      identified by the functionis_space. | 
| rmdir_method [Ftp_client] | 
Deletes the named directory
 | 
| rollback [Netcgi_dbi.DBI_DRIVER] | |
| root [Netmcore_heap] | 
Returns the root element
 | 
| rotate_right [Netauth] | 
Rotate the (big-endian) bitstring to the right by n bits.
 | 
| rpc_engine [Rpc_proxy.ManagedClient] | 
Call an RPC function in engine style:
 | 
| rpc_factory [Rpc_netplex] | 
A factory for TCP-based RPC servers.
 | 
| run [Shell_sys] | 
Executes the command concurrently with the current process.
 | 
| run [Netplex_main] | 
Similar to  startup, but this function is tailored for Netplex
      systems that compute results (e.g. | 
| run [Netmcore] | 
This function fixes a design error in  startup, namely that it was
      difficult to get the result of the process(es) back. | 
| run [Netcgi_test] | |
| run [Netcgi_fcgi] | run fregister the functionfas a main function of the
      script. | 
| run [Netcgi_cgi] | run fexecutesf cgifor each cgi request. | 
| run [Netcgi_scgi] | run fexecutesf cgifor each SCGI request. | 
| run [Netcgi_ajp] | run fexecutesf cgifor each AJP request. | 
| run [Netcgi_apache] | run fregister the functionfas a main function of the
      script. | 
| run [Unixqueue] | 
Starts the event loop.
 | 
| run [Equeue] | 
Running a system means that, unless the queue is empty, the events
 at the time of the  runinvocation and all later added events are
 gone through. | 
| run_in_container_context [Netplex_cenv] | run_in_container_context cont f: Arranges thatf()is executed
      in the context of the containercont. | 
| run_in_controller_context [Netplex_cenv] | run_in_controller_context ctrl f: Arranges thatf()is executed
      in the context of the controller. | 
| run_job [Shell_sys] | 
Invokes the commands of the job such that they run concurrently
 with the main process.
 | 
| run_mtests [Netmech_scram.AES_CTS] | |
| run_post_fork_handlers [Netsys_posix] | 
Runs all post fork handlers.
 | 
| run_tests [Netmech_scram.AES_CTS] | |
| S | |
| s_read_int4_64_unsafe [Netsys_xdr] | 
For 64 bit platforms only: Decodes 4 bytes at this string position
      as a signed 32 bit int in network byte order
 | 
| s_read_string_array_unsafe [Netsys_xdr] | let pos' = s_read_string_array s pos len max a: 
      Decodes the XDR repr of an array of strings without length field. | 
| s_write_int4_64_unsafe [Netsys_xdr] | 
For 64 bit platforms only: Encodes 4 bytes at this string position
      as a signed 32 bit int in network byte order
 | 
| salt_password [Netmech_scram] | let salted_password = salt_password password salt iteration_count | 
| same_encoding [Netconversion] | 
Whether both encodings are the same.
 | 
| sarray2_of_descr [Netmcore_matrix] | 
Look up the matrix for this descriptor
 | 
| sarray_of_descr [Netmcore_array] | 
Look up the buffer for this descriptor
 | 
| 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 liketext/plain; charset=iso-8859-1The 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  Endif 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 likename ; 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. | 
| scgi_processor [Netcgi_plex] | |
| scram_mech [Netmech_scram_gssapi] | 
The OID of SCRAM
 | 
| search_backward [Netstring_pcre] | 
Searches a match of the string with the regexp, starting at
 the position and in forward 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] | 
Matches the string at the position with the regexp.
 | 
| search_forward [Netstring_str] | 
Searches a match of the string with the regexp, starting at
 the position and in forward direction.
 | 
| search_path [Netsys_win32] | search_path path_opt name ext_opt: Uses the SearchPath function
      to locate a file. | 
| secure [Nethttp.Cookie] | 
Tells whether the cookie is secure.
 | 
| secure [Netcgi.Cookie] | 
Tells whether the cookie is secure.
 | 
| secure [Netcgi_common.Cookie] | 
Tells whether the cookie is secure.
 | 
| select_based_event_system [Unixqueue_select] | 
Create a new  Unix.select-based event system | 
| select_emulation [Netsys_pollset_generic] | let select = select_emulation pset: Returns a function with the
      same meaning asUnix.select. | 
| self_cont [Netplex_cenv] | 
Returns the container running the code of the caller,
      or raise  Not_in_container_threadif called from outside a 
      container context. | 
| self_obj [Netplex_cenv] | 
Returns the container or the controller running the code of the
      caller, or raise  Not_foundif called from
      neither a container not a controller thread. | 
| self_process_id [Netmcore] | 
Returns the process ID of a worker
 | 
| sem_close [Netsys_posix] | 
Closes a named semaphore.
 | 
| sem_container [Netmcore_heap] | 
Return the semaphore container
 | 
| sem_container [Netmcore_mempool] | 
Returns the semaphore container
 | 
| sem_create [Netsys_posix] | let (sem,name) = sem_create prefix init_value: Creates
      a new semaphore with a unique name. | 
| sem_destroy [Netsys_sem] | 
Destroys the anonymous semaphore
 | 
| sem_destroy [Netsys_posix] | 
Destroys the anonymous semaphore
 | 
| sem_getvalue [Netsys_sem] | 
Returns the value of the semaphore.
 | 
| sem_getvalue [Netsys_posix] | 
Returns the value of the semaphore.
 | 
| sem_init [Netsys_sem] | sem_init cont mem pos pshared init_value: Initializes the memory
      at positionpostopos + sem_size() - 1as anonymous semaphore. | 
| sem_init [Netsys_posix] | sem_init mem pos pshared init_value: Initializes the memory
      at positionpostopos + sem_size() - 1as anonymous semaphore. | 
| sem_open [Netsys_posix] | sem_open name flags mode init_value: Opens a named semaphore
      which is optionally created. | 
| sem_post [Netsys_sem] | 
Unlocks the semaphore (increases the value by 1)
 | 
| sem_post [Netsys_posix] | 
Unlocks the semaphore (increases the value by 1)
 | 
| sem_size [Netsys_sem] | 
The size of an anonymous semaphore in bytes ( sizeof(sem_t)) | 
| sem_size [Netsys_posix] | 
The size of an anonymous semaphore in bytes ( sizeof(sem_t)) | 
| sem_unlink [Netsys_posix] | 
Unlinks the semaphore name
 | 
| sem_value_max [Netsys_sem] | 
The maximum value of a semaphore, but at most  max_int | 
| sem_value_max [Netsys_posix] | 
The maximum value of a semaphore, but at most  max_int | 
| sem_wait [Netsys_sem] | 
Locks the semaphore (decreases the value by 1).
 | 
| sem_wait [Netsys_posix] | 
Locks the semaphore (decreases the value by 1).
 | 
| send [Netplex_mbox.MBOX] | 
Send a message to this box.
 | 
| send_file_response [Nethttpd_kernel] | 
Sends the contents of a file as response body, together with the given status and
 the header (optional).
 | 
| send_http_header [Netcgi_apache.Apache.Request] | 
Send the HTTP headers.
 | 
| send_message [Netplex_cenv] | send_message service_pattern msg_name msg_arguments: Sends
       a message to all services and message receivers matchingservice_pattern. | 
| send_static_response [Nethttpd_kernel] | 
Sends the string argument as response body, together with the given status and
 the header (optional).
 | 
| sendmail [Netsendmail] | 
Sends the passed message.
 | 
| separates_adjacent_encoded_words [Mimestring] | 
True iff the current token is white space (i.e.
 | 
| seq_engine [Uq_engines] | 
Same as function.
 | 
| serialize [Netsys_oothr] | serialize m f arg: Locksm, runsf arg, unlocksm, and returns
      the result. | 
| serializer [Uq_engines] | 
Same as function
 | 
| server [Netcgi_apache.Apache.Request] | request_recserverfield. | 
| server_auth_method [Rpc_auth_gssapi] | 
Creates an authentication method from a GSS-API interface.
 | 
| server_auth_method [Rpc_auth_sys] | 
Pass the result of this function to  Rpc_server.set_auth_methodsto
 configure authentication. | 
| server_auth_method [Rpc_auth_local] | 
Return the authentication method  AUTH_LOCAL. | 
| server_auth_method [Rpc_auth_dh] | 
Pass the result of this function to  Rpc_server.set_auth_methodsto
 configure AUTH_DH for an RPC server. | 
| server_channel_binding [Netmech_scram] | 
Returns the channel binding requirement (the "c" parameter).
 | 
| server_emit_flag [Netmech_scram] | 
Whether  server_emit_messagecan now be called | 
| server_emit_message [Netmech_scram] | 
Emits the next message to be sent to the client
 | 
| server_error_flag [Netmech_scram] | 
Whether an error occurred, and the protocol cannot advance anymore
 | 
| server_error_of_string [Netmech_scram] | 
Conversion
 | 
| server_export [Netmech_scram] | |
| server_finish_flag [Netmech_scram] | 
Whether the client is authenticated
 | 
| server_import [Netmech_scram] | 
Exports a server session as string, and imports the string again.
 | 
| server_protocol_key [Netmech_scram] | 
The 128-bit protocol key for encrypting messages.
 | 
| server_recv_flag [Netmech_scram] | 
Whether  server_recv_messagecan now be called | 
| server_recv_message [Netmech_scram] | 
Receives the next message from the client
 | 
| server_user_name [Netmech_scram] | 
The user name as transmitted from the client.
 | 
| set [Rpc_portmapper] | set pm_client program_nr version_nr protocol port_nr:
 Extends the mapping managed by the portmapper: The triple(program_nr, version_nr, protocol)is mapped to the givenport_nr. | 
| set [Netbuffer] | set nb pos c: Sets the character atpostoc | 
| set [Netshm_array] | set a k x: Sets the contents of the array element numberktoxwhere0 <= k < length a. | 
| set [Netplex_cenv.VAR_TYPE] | |
| set [Netmcore_matrix] | set sa k1 k2 x: Sets the(k1,k2)-thelement of the matrixsato a
      deep copy ofx. | 
| set [Netmcore_array] | set sa k x: Sets thek-thelement of the arraysato a
      deep copy ofx. | 
| set [Netcgi.Argument] | set new_args argscreates a list of argument fromargsdeleting the arguments whose name appears innew_argsand
	adding thenew_argsarguments. | 
| set [Netcgi_common.Cookie] | set http_header cookiessets thecookiesinhttp_headerusing version 0 or version 1 depending on whether version 1
	fields are used. | 
| set [Netcgi_apache.Apache.Table] | Table.set tbl key valuesets the(key, value)pair in
          the tabletbl. | 
| set [Uq_libevent.LIBOEVENT] | |
| set_accept [Nethttp.Header] | 
Sets the  Acceptheader | 
| set_accept_charset [Nethttp.Header] | 
Sets the  Accept-charsetheader | 
| set_accept_encoding [Nethttp.Header] | 
Sets the  Accept-encodingheader | 
| set_accept_language [Nethttp.Header] | 
Sets the  Accept-languageheader | 
| set_accept_ranges [Nethttp.Header] | 
Sets the  Accept-rangesheader | 
| set_age [Nethttp.Header] | 
Sets the  Ageheader | 
| set_allow [Nethttp.Header] | 
Sets the  Allowheader | 
| set_args [Netcgi_apache.Apache.Request] | 
Set  request_recargsfield. | 
| set_arguments [Shell_sys] | 
Sets the argument array
 | 
| set_assignments [Shell_sys] | 
Sets the list of assignments   (fd_from,fd_to)  | 
| set_auth_methods [Rpc_server] | 
Sets the available authentication methods.
 | 
| set_auth_methods [Rpc_client] | 
Set the authentication methods for this client.
 | 
| set_authorization [Nethttp.Header] | 
Sets the  Authorizationheader. | 
| set_batch_call [Rpc_proxy.ManagedClient] | 
The next call is a batch call.
 | 
| set_batch_call [Rpc_client] | 
The next call will be a batch call.
 | 
| set_bool_var [Netplex_cenv] | 
Set a variable with simple type
 | 
| set_cache_control [Nethttp.Header] | 
Sets the  Cache-controlheader | 
| set_chdir [Shell_sys] | 
Sets the  chdirparameter of the command | 
| set_close_on_exec [Netsys] | |
| set_cmdname [Shell_sys] | 
Sets the command name
 | 
| set_color [Netsys_mem] | 
Set the GC color
 | 
| set_comment [Nethttp.Cookie] | set_comment c ssets the comment of the cookiectoswhich must be UTF-8 encoded (RFC 2279). | 
| set_comment [Netcgi.Cookie] | set_comment c ssets the comment of the cookiectoswhich must be UTF-8 encoded (RFC 2279). | 
| set_comment [Netcgi_common.Cookie] | |
| set_comment_url [Nethttp.Cookie] | set_comment_url c urlsame asNetcgi.Cookie.set_commentexcept that the cookie comment is available on the page
	pointed byurl. | 
| set_comment_url [Netcgi.Cookie] | set_comment_url c urlsame asNetcgi.Cookie.set_commentexcept that the cookie comment is available on the page
	pointed byurl. | 
| set_comment_url [Netcgi_common.Cookie] | |
| set_connection [Nethttp.Header] | 
Sets the  Connectionheader | 
| set_console_attr [Netsys_win32] | 
Get/set console attributes.
 | 
| set_console_mode [Netsys_win32] | 
Get/set the console mode.
 | 
| set_content_encoding [Nethttp.Header] | 
Sets the  Content-encodingheader | 
| set_content_language [Nethttp.Header] | 
Sets the  Content-languageheader | 
| set_content_length [Nethttp.Header] | 
Sets the  Content-lengthheader | 
| set_content_location [Nethttp.Header] | 
Sets the  Content-locationheader | 
| set_content_md5 [Nethttp.Header] | 
Sets the  Content-MD5header | 
| set_content_range [Nethttp.Header] | 
Sets the  Content-rangeheader | 
| set_content_type [Nethttp.Header] | 
Sets the  Content-typeheader | 
| set_content_type [Netcgi_apache.Apache.Request] | 
Set  request_reccontent_typefield. | 
| set_cookie [Nethttp.Header] | 
Set the  Cookieheader. | 
| set_current_resolver [Uq_resolver] | 
Set the pluggable resolver
 | 
| set_date [Nethttp.Header] | 
Sets the  Dateheader | 
| set_debug_mode [Unixqueue.Debug] | 
Sets  enable. | 
| set_debug_mode [Equeue.Debug] | 
Sets  enable. | 
| set_debug_target [Unixqueue.Debug] | 
Restricts debugging to this target.
 | 
| set_debug_target [Equeue.Debug] | 
Restricts debugging to this target.
 | 
| set_descriptors [Shell_sys] | 
Sets the list of active descriptors
 | 
| set_dgram_destination [Rpc_client] | set_dgram_destination client addr_opt: This function is required
 for using the client in conjunction with unconnected UDP sockets. | 
| set_domain [Nethttp.Cookie] | 
Cookies are bound to a certain domain, i.e.
 | 
| set_domain [Netcgi.Cookie] | 
Cookies are bound to a certain domain, i.e.
 | 
| set_domain [Netcgi_common.Cookie] | |
| set_enc_value [Netplex_sharedvar] | set_enc_value name value: Sets the variablenametovalue. | 
| set_encoding [Netulex.ULB] | 
Sets the  encodingto the passed value. | 
| set_env [Shell_sys] | 
Sets the contents of the environment to the passed string array
 | 
| set_env_var [Shell_sys] | set_env_var env varname varval: Sets the value of the variablevarnamein the environmentenvtovarval. | 
| set_environment [Shell_sys] | 
Sets the environment
 | 
| set_etag [Nethttp.Header] | 
Sets the  Etagheader | 
| set_event [Netsys_win32] | 
Set the object to "signaled" state
 | 
| set_event [Netsys_posix] | 
Signals the event
 | 
| set_exception_handler [Rpc_server] | 
Sets the exception handler for the server.
 | 
| set_exception_handler [Rpc_client] | 
sets an exception handler (the default prints the exception 
 with  `Critlevel to the logger set inNetlog). | 
| set_expect [Nethttp.Header] | 
Sets the  Expectheader | 
| set_expires [Nethttp.Header] | 
Sets the  Expiresheader | 
| set_filename [Shell_sys] | 
Sets the file name of the executable to start
 | 
| set_filename [Netcgi_apache.Apache.Request] | 
Set  request_recfilenamefield. | 
| set_float_var [Netplex_cenv] | |
| set_from [Nethttp.Header] | 
Sets the  Fromheader | 
| set_global_rcache_config [Rpc_proxy.ReliabilityCache] | 
Sets the new global config.
 | 
| set_host [Nethttp.Header] | 
Sets the  Hostheader | 
| set_if_match [Nethttp.Header] | 
Sets the  If-matchheader | 
| set_if_modified_since [Nethttp.Header] | 
Sets the  If-modified-sinceheader | 
| set_if_none_match [Nethttp.Header] | 
Sets the  If-none-matchheader | 
| set_if_range [Nethttp.Header] | 
Sets the  If-rangeheader | 
| set_if_unmodified_since [Nethttp.Header] | 
Sets the  If-unmodified-sinceheader | 
| set_int_var [Netplex_cenv] | |
| set_last_modified [Nethttp.Header] | 
Sets the  Last-modifiedheader | 
| set_location [Nethttp.Header] | 
Sets the  Locationheader | 
| set_max_age [Nethttp.Cookie] | set_max_age c (Some t)sets the lifetime of the cookiectotseconds. | 
| set_max_age [Netcgi.Cookie] | set_max_age c (Some t)sets the lifetime of the cookiectotseconds. | 
| set_max_age [Netcgi_common.Cookie] | |
| set_max_forwards [Nethttp.Header] | 
Sets the  Max-forwardsheader | 
| set_max_response_length [Rpc_client] | 
Sets the maximum length of responses.
 | 
| set_mode_method [Ftp_client] | 
Requests a certain mode for future file transfers
 | 
| set_mstring_factories [Rpc_server] | 
Sets the mstring factories to use for decoding requests containing
      managed strings
 | 
| set_mstring_factories [Rpc_client] | 
Sets the mstring factory configuration that is used for decoding
      responses containing managed strings.
 | 
| set_nonblock_event [Netsys_posix] | 
Sets the event fd to non-blocking mode
 | 
| set_onclose_action [Rpc_server] | 
Every time a connection is closed, the onclose function is called
 with the closed connection.
 | 
| set_path [Nethttp.Cookie] | 
Cookies are also bound to certain path prefixes, i.e.
 | 
| set_path [Netcgi.Cookie] | 
Cookies are also bound to certain path prefixes, i.e.
 | 
| set_path [Netcgi_common.Cookie] | |
| set_path_info [Netcgi_apache.Apache.Request] | 
Set  request_recpath_infofield. | 
| set_poll_cell [Netsys_posix] | set_poll_cell a k c: Sets the poll cellktoc. | 
| set_ports [Nethttp.Cookie] | set ports c (Some p)says that the cookiecmust only be
	returned if the server request comes from one of the listed
	ports. | 
| set_ports [Netcgi.Cookie] | set ports c (Some p)says that the cookiecmust only be
	returned if the server request comes from one of the listed
	ports. | 
| set_ports [Netcgi_common.Cookie] | |
| set_pragma [Nethttp.Header] | 
Sets the  Pragmaheader | 
| set_proxy_authenticate [Nethttp.Header] | 
Sets the  Proxy-authenticateheader | 
| set_proxy_authorization [Nethttp.Header] | 
Sets the  Proxy-authorizationheader
 The "Basic" authentication scheme is represented as explained forget_proxy_authorization. | 
| set_range [Nethttp.Header] | 
Sets the  Rangeheader | 
| set_referer [Nethttp.Header] | 
Sets the  Refererheader | 
| set_referrer [Nethttp.Header] | 
Same, for addicts of correct orthography
 | 
| set_retry_after [Nethttp.Header] | 
Sets the  Retry-afterheader | 
| set_rng [Netsys_rng] | 
Sets the globally used RNG
 | 
| set_secure [Nethttp.Cookie] | 
Cookies are also bound to the type of the web server:
         set_secure falsemeans servers without SSL,set_secure
        truemeans servers with activated SSL ("https"). | 
| set_secure [Netcgi.Cookie] | 
Cookies are also bound to the type of the web server:
         set_secure falsemeans servers without SSL,set_secure
        truemeans servers with activated SSL ("https"). | 
| set_secure [Netcgi_common.Cookie] | |
| set_server [Nethttp.Header] | 
Sets the  Serverheader | 
| set_session_filter [Rpc_server] | 
If set, the filter function is invoked every time the beginning of a new
 RPC call is received, and the result of the filter function determines
 what to do with the call:
 | 
| set_session_filter_2 [Rpc_server] | 
Same as  set_session_filter, but the filter gets as second argument the
 connection ID. | 
| set_set_cookie [Nethttp.Header] | 
Set the  Set-Cookieheader | 
| set_set_cookie_ct [Nethttp.Header] | 
Set the  Set-CookieandSet-Cookie2headers: | 
| set_status [Netcgi_apache.Apache.Request] | 
Set  request_recstatusfield. | 
| set_status_line [Netcgi_apache.Apache.Request] | 
Set  request_recstatus_linefield. | 
| set_string_var [Netplex_cenv] | |
| set_structure_method [Ftp_client] | 
Requests a certain structure for future file transfers
 | 
| set_te [Nethttp.Header] | 
Sets the  TEheader | 
| set_timeout [Rpc_server] | 
Sets the timeout for the transport.
 | 
| set_tmp_directory [Netsys_tmp] | 
Set the directory for temporary files
 | 
| set_trailer [Nethttp.Header] | 
Sets the  Trailerheader | 
| set_transfer_encoding [Nethttp.Header] | 
Sets the  Transfer-encodingheader | 
| set_upgrade [Nethttp.Header] | 
Sets the  Upgradeheader | 
| set_uri [Netcgi_apache.Apache.Request] | 
Set  request_recurifield. | 
| set_user_agent [Nethttp.Header] | 
Sets the  User-agentheader | 
| set_user_name [Rpc_client] | 
Sets the user name, or  None(the default user name). | 
| set_value [Nethttp.Cookie] | set_value c vsets the value of the cookiectov. | 
| set_value [Netplex_sharedvar] | set_value name value: Sets the variablenametovalue. | 
| set_value [Netcgi.Cookie] | set_value c vsets the value of the cookiectov. | 
| set_value [Netcgi_common.Cookie] | |
| set_vary [Nethttp.Header] | 
Sets the  Varyheader | 
| set_www_authenticate [Nethttp.Header] | 
Sets the  WWW-Authenticateheader | 
| setpgid [Netsys_posix] | setpgid pid pgid: Set the process group ID of the processpidtopgid. | 
| setpgrp [Netsys_posix] | 
Same as  setpgid 0 0: A new process group ID is created, and the
 current process becomes its sole member. | 
| setregid [Netsys_posix] | 
Changes both the real and the effective group ID of the current
 process.
 | 
| setreuid [Netsys_posix] | 
Changes both the real and the effective user ID of the current
 process.
 | 
| setup_client_block [Netcgi_apache.Apache.Request] | 
Setup for reading client request.
 | 
| setup_job [Shell] | 
Creates a job like  call, but does not execute it. | 
| shared_sub_mstring [Xdr_mstring] | shared_sub_mstring ms pos len: returns an mstring that includes
      a substring ofms, starting atpos, and withlenbytes. | 
| shared_sub_mstrings [Xdr_mstring] | 
Same for a list of mstrings
 | 
| shell_fs [Shell_fs] | 
The shell filesystem.
 | 
| shm_create [Netsys_posix] | let (fd,name) = shm_create prefix size: Creates an shm object
      with a unique name. | 
| shm_name [Netmcore_mempool] | 
Returns the name of the shared memory object
 | 
| shm_open [Netsys_posix] | 
Opens a shared memory object.
 | 
| shm_open [Netsys] | |
| shm_table [Netshm_array] | 
Returns the underlying shared memory table used to implement hash
 tables
 | 
| shm_table [Netshm_hashtbl] | 
Returns the underlying shared memory table used to implement hash
 tables.
 | 
| shm_type_of_name [Netshm] | |
| shm_unlink [Netsys_posix] | 
Unlinks the name for a shared memory object
 | 
| shm_unlink [Netsys] | |
| should_client_block [Netcgi_apache.Apache.Request] | 
Returns true if there is any client request data.
 | 
| shut_down [Rpc_proxy.ManagedSet] | |
| shut_down [Rpc_proxy.ManagedClient] | |
| shut_down [Rpc_portmapper] | 
Shuts down the connection to the portmapper.
 | 
| shut_down [Rpc_simple_client] | 
Shut the connection down.
 | 
| shut_down [Rpc_client] | 
Shuts down the connection.
 | 
| shut_down [Rpc_key_service] | |
| shutdown_connector [Rpc_client] | 
The default implementation to shut down the connector.
 | 
| shutdown_e [Uq_io] | 
Performs a regular shutdown of the device.
 | 
| signal [Netmcore_condition] | signal crestarts one of the processes waiting on the
      condition variablec. | 
| signal_engine [Uq_engines] | let (se, signal) = signal_engine esys: Same as function | 
| signature [Rpc_program] | |
| simple [Netcgi.Argument] | simple_arg name valuecreates an unstructured CGI argument
	callednamewith contentsvalue. | 
| simple_listing [Nethttpd_services] | 
Simple listing generator for  `Enable_listings | 
| since_epoch [Netdate] | 
Convert a date/time record into the time (seconds since the epoch),
      rounded down to the next integral number.
 | 
| since_epoch_approx [Netdate] | 
Same, but the nanos are added to the seconds.
 | 
| since_epoch_timespec [Netdate] | 
Returns the seconds since the epoch as pair  (seconds,nanos) | 
| size_mem [Netmcore_mempool] | 
Returns the size of this block, or raises  Not_found | 
| size_mem_at_addr [Netmcore_mempool] | 
Returns the size of the block at this address, or raises  Not_found | 
| size_method [Ftp_client] | 
Determines the size of  file. | 
| skip_line_ends [Mimestring] | skip_line_ends s pos len: Skips over adjacent line ends (terminated
      by CR/LF or plain LF), and returns the position after the last
      line end. | 
| skip_whitespace_left [Mimestring] | skip_whitespace_left s pos len: Returns the smallestpwithp >= pos && p < pos+lenso thats.[p]is not
      a whitesapce character (space, TAB, CR, LF), ands.[q]is a whitespace character for allq<p. | 
| skip_whitespace_right [Mimestring] | skip_whitespace_right s pos len: Returns the biggestpwithp >= pos && p < pos+lenso thats.[p]is not
      a whitesapce character (space, TAB, CR, LF), ands.[q]is a whitespace character for allq>p. | 
| sleep [Netsys] | |
| small_block_size [Netsys_mem] | 
The block size of  small_pool, normally 4K (or better, the
      page size) | 
| small_pool [Netsys_mem] | 
Another standard pool where the blocks are smaller than in
       default_pool. | 
| sockaddr_is_enabled [Rpc_proxy.ReliabilityCache] | 
Returns whether the sockaddr is enabled.
 | 
| sockaddr_of_socksymbol [Uq_resolver] | 
Use the resolver to look up names in  Netsockaddr.socksymbol,
      and convert the symbol to aUnix.sockaddronly containing IP
      addresses. | 
| sockspec_of_sockaddr [Uq_engines] | 
Converts a normal socket address to the extended form
 | 
| sockspec_of_socksymbol [Uq_engines] | 
Converts a  Netsockaddr.socksymbolto this form | 
| socksymbol_of_string [Netsockaddr] | 
Parses designations of the forms:  <IPv4>:port,[<IPv4_or_IPv6]:port,<name>:port,/path,./pathRaisesFailureon parse error. | 
| spawn [Netsys_posix] | spawn cmd args: Fork the process and execcmdwhich gets the
      argumentsargs. | 
| specials_rfc2045 [Mimestring] | 
The sets of special characters defined by the RFCs 822 and 2045.
 | 
| specials_rfc822 [Mimestring] | |
| split [Netstring_pcre] | substitute_first re subst s: Applies the substitution functionsubstto the first matching ofreins, and returns the 
 transformed string. | 
| split [Netstring_str] | 
Splits the string according to the regexp in substrings.
 | 
| split_delim [Netstring_pcre] | 
Splits into at most  nsubstrings, based onsplit | 
| split_delim [Netstring_str] | 
Same as  split, but occurrences of the delimiter at the beginning 
 and the end are returned as empty strings | 
| split_glob_expr [Netglob] | 
Splits the glob expression into filename components separated by
 literal  /characters. | 
| split_host_port [Nethttp] | 
Splits the  Hostheader in hostname and optional port number. | 
| 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.
 | 
| squeue_of_descr [Netmcore_queue] | 
Look up the queue for this descriptor
 | 
| sref [Netmcore_ref] | 
The shared version of  ref: Creates a mutable shared variable in
      the given memory pool | 
| sref_of_descr [Netmcore_ref] | 
Look up the reference for this descriptor
 | 
| ssh_interpreter [Shell_fs] | 
Executes commands via ssh on the machine  hostasuser(defaults
      to current user). | 
| ssl_accept_engine [Uq_ssl] | 
This engine performs the server handshake.
 | 
| ssl_client_socket_config [Rpc_ssl] | 
SSL configuration object for clients
 | 
| ssl_connect_engine [Uq_ssl] | 
This engine performs the client handshake.
 | 
| ssl_server_socket_config [Rpc_ssl] | 
SSL configuration object for servers
 | 
| standard_event_system [Unixqueue] | 
Create a new, empty, standard event system
 | 
| standard_pollset [Netsys_pollset_generic] | 
Returns a good standard implementation of pollset for this platform.
 | 
| start [Netmcore_process] | let pid = start fp arg: Starts a new process at the fork pointfpwith argumentarg. | 
| start [Netmcore_buffer] | 
Returns the start index
 | 
| start [Netmcore] | let pid = start fork_point arg: Starts the process with the
      givenfork_pointand the argumentarg. | 
| startup [Netplex_main] | 
Establishes a configuration and starts the Netplex daemon.
 | 
| startup [Netmcore] | 
This function makes the current process the master process.
 | 
| stats [Netmcore_mempool] | 
Returns  (total, free, contiguous)wheretotalis the total size of the pool,freeis the number of free bytes,contiguousis the size of the largest contiguous free block | 
| status [Shell_sys] | 
Reports the status so far known: If the process 
 has terminated, the status of the process is returned.
 | 
| status [Netcgi_apache.Apache.Request] | request_recstatusfield. | 
| status_line [Netcgi_apache.Apache.Request] | request_recstatus_linefield. | 
| status_of_bad_request_error [Nethttpd_kernel] | 
Returns the best response code for the error
 | 
| status_of_cgi_header [Nethttp] | 
Returns the status code and the status text corresponding to the
  Statusheader | 
| std_access_log_string [Nethttpd_util] | 
Returns a log line for access logging
 | 
| std_activation [Nethttpd_services] | 
Create the function for  dyn_activationfrom astd_activationtag. | 
| std_debug_access_log_string [Nethttpd_util] | 
Returns a log string for extended access logging (multi-line)
 | 
| std_error_log_string [Nethttpd_util] | 
Returns a log line for error logging
 | 
| std_error_response [Nethttpd_util] | 
Returns the HTML text of the standard error response
 | 
| std_error_response [Nethttpd_plex] | 
A sample error response function
 | 
| std_log_access [Nethttpd_plex] | 
Returns a function that logs accesses using the  log_subchmethod of
      the passed container | 
| std_log_error [Nethttpd_plex] | 
Returns a function that logs errors using the  log_subchmethod of
      the passed container | 
| stderr [Shell] | 
The standard descriptors; defined here for convenience.
 | 
| stderr_logger_factory [Netplex_log] | 
Reads a logging section like
 | 
| stdin [Shell] | |
| stdout [Shell] | |
| stop_connection [Rpc_server] | 
Schedules a special event that causes the connection to be stopped in the
 very near future.
 | 
| stop_server [Rpc_server] | 
Stops the server: If a TCP server socket is listening, it is immediately
 closed.
 | 
| storage [Netmime] | 
Creates a new storage facility for a mime body according to  store. | 
| stream_rpc_multiplex_controller [Rpc_transport] | 
The multiplex controller for stream encapsulation
 | 
| stream_seq_engine [Uq_engines] | 
Same as function
 | 
| string_after [Netstring_pcre] | 
The first  ncharacters of a string | 
| string_after [Netstring_str] | 
The last  ncharacters of a string | 
| string_based_mstrings [Xdr_mstring] | 
Uses strings to represent mstrings
 | 
| string_before [Netstring_pcre] | 
Splits into at most  nsubstrings, based onfull_split | 
| string_before [Netstring_str] | 
The first  ncharacters of a string | 
| string_manager [Netshm_data] | 
Represents a string in the following way.
 | 
| string_match [Netstring_pcre] | 
Returns a case-insensitive regexp that matches exactly the string
 | 
| string_match [Netstring_str] | 
Matches the string at the position with the regexp.
 | 
| string_of_bad_request_error [Nethttpd_kernel] | 
Convert error to a string, for logging
 | 
| string_of_calling_error [Netgssapi] | |
| string_of_encoding [Netconversion] | 
Returns the name of the encoding.
 | 
| string_of_fatal_error [Nethttpd_kernel] | 
Convert error to a string, for logging
 | 
| string_of_fd [Netsys] | 
Return a string describing the descriptor (for debugging)
 | 
| string_of_fd_style [Netsys] | 
Returns a string describing the fd style (debugging)
 | 
| string_of_http_method [Netcgi_common] | 
Returns the string value of the method
 | 
| string_of_http_status [Nethttp] | 
Returns the informational text for a status value
 | 
| string_of_in_obj_channel [Netchannels] | 
Reads from the input channel until EOF and returns the characters
 as string.
 | 
| string_of_level [Netlog] | 
Convert level names to strings and vice versa
 | 
| string_of_major_status [Netgssapi] | |
| string_of_output_state [Nethttpd_types] | 
Debugging
 | 
| string_of_packed_value [Rpc_packer] | |
| string_of_protocol [Nethttp] | 
Returns the string representation, e.g.
 | 
| string_of_req_token [Nethttpd_kernel] | 
For debugging
 | 
| string_of_request [Rpc_util] | 
Return the string representation of this call request
 | 
| string_of_request_method [Netcgi_common] | |
| string_of_response [Rpc_util] | 
Return the string representation of this call response
 | 
| string_of_routine_error [Netgssapi] | |
| string_of_server_error [Rpc] | 
returns a string for debug purposes
 | 
| string_of_server_error [Netmech_scram] | |
| string_of_sockaddr [Rpc_transport] | 
Convert to string, for debugging purposes
 | 
| string_of_sockaddr [Netsys] | 
Returns a human-readable string describing the address
      (for debug messages)
 | 
| string_of_socksymbol [Netsockaddr] | 
The reverse function
 | 
| string_of_state [Uq_engines] | 
For debug purposes: Returns a string describing the state
 | 
| string_of_suppl_status [Netgssapi] | |
| string_of_url [Neturl] | 
Returns the URL as string
 | 
| string_of_value [Rpc_util] | 
Return a string representation of the value which must have the
       passed type
 | 
| string_to_mstring [Xdr_mstring] | 
Represent a string as mstring (no copy)
 | 
| string_to_oid [Netgssapi] | 
Convert OID's to/from curly brace notation
 | 
| string_var [Netplex_cenv] | |
| strong_validator_match [Nethttp] | 
Whether the tags match strongly (see RFC 2616 for definition)
 | 
| sub [Netpagebuffer] | 
Returns a substring
 | 
| sub [Netbuffer] | sub nb k n: returns the n characters starting at positionnfrom 
 netbuffernbas fresh string | 
| sub [Netmcore_buffer] | 
Returns a substring
 | 
| sub_lexeme [Netulex.Ulexing] | 
Returns a substring of the lexeme as array of Unicode
 code points.
 | 
| subprocess_env [Netcgi_apache.Apache.Request] | request_recsubprocess_envfield. | 
| substitute_first [Netstring_pcre] | global_substitute re subst s: Applies the substitution functionsubstto all matchings ofreins, and returns the 
 transformed string. | 
| substitute_first [Netstring_str] | substitute_first re subst s: Applies the substitution functionsubstto the first matching ofreins, and returns the 
 transformed string. | 
| supported_types [Netshm] | 
The types supported for this OS
 | 
| symlinkat [Netsys_posix] | symlinkat oldpath newdirfd newpath flags | 
| sync_call [Rpc_client] | |
| sync_engine [Uq_engines] | 
Same as function
 | 
| sync_shutdown [Rpc_proxy.ManagedSet] | |
| sync_shutdown [Rpc_proxy.ManagedClient] | |
| sync_shutdown [Rpc_client] | 
Enforces a synchronous shutdown of the connection.
 | 
| synchronize [Rpc_client] | 
Turns an async call into a synchronous call
 | 
| sysconf_open_max [Netsys_posix] | 
Return the maximum number of open file descriptor per process.
 | 
| syslog [Netsys_posix] | syslog facility level message: Logsmessageatlevelforfacility | 
| syslog_logger [Netplex_log] | 
Creates a logger writing to syslog
 | 
| syslog_logger_factory [Netplex_log] | 
Reads a logging section like
 | 
| system_restart [Netplex_cenv] | 
Initiates a system restart (like the  restartmethod of the
      controller) | 
| system_shutdown [Netplex_cenv] | 
Initiates a system shutdown (like the  shutdownmethod of the
      controller) | 
| T | |
| tcgetpgrp [Netsys_posix] | 
Return the process group ID of the foreground process group of
 the session associated with the file descriptor, which must be
 a tty.
 | 
| tcp_port [Netsmtp] | 
default TCP port for SMTP
 | 
| tcp_port [Netpop] | 
Default TCP port for POP version 3
 | 
| tcsetpgrp [Netsys_posix] | 
Sets the foreground process group ID of the session associated
 with the file descriptor, which must be a tty.
 | 
| tempfile_transactional_optype [Netcgi1_compat.Netcgi] | |
| tempfile_transactional_optype [Netcgi] | 
Deprecated name for  tempfile_transactional_outtype | 
| tempfile_transactional_outtype [Netcgi] | 
The  output_typeimplementing transactions with a tempfile-based
      buffer | 
| template [Netcgi_modtpl] | 
Compile the template from a named file.
 | 
| template_from_channel [Netcgi_modtpl] | 
Compile the template from a channel.
 | 
| template_from_string [Netcgi_modtpl] | 
Compile the template from a literal string.
 | 
| terminate_process [Netsys_win32] | 
Terminates the process
 | 
| test_close_on_exec [Netsys_win32] | 
Tests whether the handle is not inheritable
 | 
| test_event [Netsys_win32] | 
Test whether the object is in signaled state
 | 
| tests [Netmech_scram.AES_CTS] | |
| the_request [Netcgi_apache.Apache.Request] | request_recthe_requestfield. | 
| threaded_pollset [Netsys_pollset_win32] | 
This implementation overcomes the limit on the number of descriptors 
      one can add
      to the set.
 | 
| timeout_engine [Uq_engines] | 
Same as function
 | 
| timer_create [Netsys_posix] | 
Create a new timer that will report expiration as given by the arg:  TEXP_NONE: no notification,TEXP_EVENT e: thenot_eventeis signalled,TEXP_EVENT_CREATE: a specialnot_eventis created for the timer.
        (Get the event viatimer_event, see below.),TEXP_SIGNAL n: the signalnis sent to the process
      Note thatTEXP_EVENT_CREATEis much faster on Linux thanTEXP_EVENT, because it can be avoided to start a new thread
      whenever the timer expires. | 
| timer_delete [Netsys_posix] | 
Deletes the timer
 | 
| timer_event [Netsys_posix] | 
Returns the notification event for the timer styles  TEXP_EVENTandTEXP_EVENT_CREATE. | 
| timer_gettime [Netsys_posix] | 
Returns the number of seconds until the expiration, or  (0.0,0)if the timer is off | 
| timer_id [Netplex_cenv] | 
Returns an ID, e.g.
 | 
| timer_settime [Netsys_posix] | timer_settime tm abstime interval value: | 
| tmp_directory [Netsys_tmp] | 
Return the directory for temporary files.
 | 
| tmp_prefix [Netsys_tmp] | tmp_prefix p: Enhance the prefix for temporary files by appending
      some digits top. | 
| to_buffer [Shell] | 
Creates a consumer writing the data into the passed buffer.
 | 
| to_buffer [Shell_sys] | to_buffer breturns a function which can be
 used asconsumerargument foradd_consumer. | 
| to_compat_activation [Netcgi1_compat.Netcgi_types] | 
Portage:  to_compat_activationconverts a new style 
        cgi object to an old cgi_activation object. | 
| to_compat_argument [Netcgi1_compat.Netcgi_types] | 
Portage:  to_compat_argument aconverts a new style argumentato an old style one. | 
| to_compat_config [Netcgi1_compat.Netcgi_env] | 
Portage:  to_compat_config ctransform the new configurationcinto one suitable for the old interface. | 
| to_compat_environment [Netcgi1_compat.Netcgi_env] | 
Portage:  to_compat_environment econverts the new environmenteto the old interface. | 
| to_dev_null [Shell] | 
A consumer redirecting the data to  /dev/null. | 
| to_fd [Shell] | 
Creates a consumer redirecting the data to the file descriptor
 | 
| to_file [Shell] | 
Creates a consumer writing the data into the file whose name is
 passed to this function.
 | 
| to_function [Shell] | 
Creates a consumer writing the data by calling a function.
 | 
| to_lower [Netunichar] | 
Converts the input letter to lowercase.
 | 
| to_netscape_cookie [Nethttp.Cookie] | 
Convert to Netscape cookie (with information loss)
 | 
| to_netscape_cookie [Netcgi.Cookie] | 
Convert to Netscape cookie (with information loss)
 | 
| to_record [Netcgi_common.Cookie] | 
Conversion to the deprecated style of cookie (some parameters
        are dropped).
 | 
| to_string [Netexn] | 
Prints the exception as string, using the registered printer functions,
      or  Printexc.to_stringas fallback if there is no better printer | 
| to_title [Netunichar] | 
Same for titlecase conversion
 | 
| 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. | 
| to_upper [Netunichar] | 
Same for uppercase conversion
 | 
| top_c [Netmcore_queue] | pop_p q f: Takes the first elementxof the queue, 
      and callsf x, without removingxfrom the queue. | 
| top_p [Netmcore_queue] | pop_p q f: Takes the first elementxof the queue, 
      and callsf x, without removingxfrom the queue. | 
| track_fd [Netlog.Debug] | track_fd ~owner ~descr fd: Enters the descriptorfdinto the
        descriptor table. | 
| trigger_shutdown [Rpc_proxy.ManagedSet] | 
Shut down the managed set.
 | 
| trigger_shutdown [Rpc_proxy.ManagedClient] | 
Shut down the managed client.
 | 
| trigger_shutdown [Rpc_client] | 
Triggers the shutdown, and calls the passed function back when it is
 done.
 | 
| 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. | 
| tty_read_password [Netsys_posix] | tty_read_password prompt: Ifttyis a terminal, thepromptis printed, and a password is read from the terminal (echo off). | 
| ttyname [Netsys_posix] | 
Returns the name of the controlling tty referred to by the
 file descriptor.
 | 
| 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.
 | 
| uint4_as_string [Rtypes] | |
| uint4_as_string [Netnumber.ENCDEC] | |
| uint4_of_int [Rtypes] | |
| uint4_of_int [Netnumber] | |
| uint4_of_int32 [Rtypes] | |
| uint4_of_int32 [Netnumber] | |
| uint4_of_int64 [Rtypes] | |
| uint4_of_int64 [Netnumber] | |
| uint8_as_string [Rtypes] | 
<t> _as_string: Returns the corresponding string in network byte
 order for an integer value | 
| uint8_as_string [Netnumber.ENCDEC] | 
<t> _as_string: Returns the corresponding string for an integer value | 
| uint8_of_int [Rtypes] | |
| uint8_of_int [Netnumber] | |
| uint8_of_int32 [Rtypes] | |
| uint8_of_int32 [Netnumber] | |
| uint8_of_int64 [Rtypes] | |
| uint8_of_int64 [Netnumber] | |
| unbind [Rpc_server] | 
Unbinds the program if it is bound by the server
 | 
| unbound_async_call [Rpc_client.USE_CLIENT] | unbound_ssync_call client pgm proc arg emit: Invoke the remote 
        procedureprocof the programpgmviaclient. | 
| unbound_async_call [Rpc_client] | unbound_ssync_call client pgm proc arg emit: Invoke the remote 
      procedureprocof the programpgmviaclient. | 
| unbound_create [Rpc_client] | 
Creates an unbound client.
 | 
| unbound_sync_call [Rpc_client.USE_CLIENT] | unbound_sync_call client pgm proc arg: Invoke the remote procedureprocof the programpgmviaclient. | 
| unbound_sync_call [Rpc_client] | unbound_sync_call client pgm proc arg: Invoke the remote procedureprocof the programpgmviaclient. | 
| undefault_url [Neturl] | 
Removes components from the URL if they have the passed value, and
 returns the modified URL.
 | 
| unix_error_of_code [Netsys] | 
Converts an integer error into the corresponding variant
 | 
| unlink [Netsys_sem] | 
Unlinks the identified container if it exists, and unlinks all
      possible named semaphores.
 | 
| unlink_camlbox [Netcamlbox] | 
Removes the global name of the camlbox.
 | 
| unlink_mempool [Netmcore_mempool] | 
Deletes the persistent objects of this pool
 | 
| unlink_shm [Netshm] | 
Removes the name permanently from the system
 | 
| unlink_this [Netsys_pmanage] | 
Unlinks this object
 | 
| unlinkat [Netsys_posix] | 
Same as  Unix.unlinkbut unlink the file relative to the directory
      given by first argument | 
| unlock [Netmappings] | |
| unlock [Netplex_mutex] | 
Unlocks the mutex.
 | 
| unlock [Netmcore_mutex] | 
Unlocks the mutex
 | 
| unlockpt [Netsys_posix] | 
Unlock a PTY master/slave pair
 | 
| unpack_call [Rpc_packer] | |
| unpack_call_body [Rpc_packer] | |
| unpack_call_body_raw [Rpc_packer] | |
| unpack_call_frame [Rpc_packer] | |
| unpack_call_frame_l [Rpc_packer] | |
| unpack_reply [Rpc_packer] | |
| unpack_reply_verifier [Rpc_packer] | |
| unpack_xdr_value [Xdr] | |
| unpack_xdr_value_l [Xdr] | prefix: whether it is ok that the string is longer than the message
   (default: false) | 
| unpredictable_pipe_name [Netsys_win32] | 
Returns a valid pipe name that can practically not be predicted
 | 
| unregister [Netsys_win32] | 
Removes this descriptor from the lookup table.
 | 
| 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.
 | 
| unset [Rpc_portmapper] | unset pm_client program_nr version_nr protocol port_nr:
 removes the mapping. | 
| unset [Netcgi_apache.Apache.Table] | Table.unset tbl keydelete every key/value pair associated
          with thekeyfrom the tabletbl. | 
| unwrap [Netplex_encap.ENCAP] | 
Raises  Netplex_encap.Type_mismatchif the value does not fit | 
| unwrap_wrap_token_conf [Netgssapi] | 
Unwraps the  tokenusing the decryption functiondecrypt_and_verifyfrom the cryptosystem. | 
| update [Rpc_program] | 
Modifies program and/or version number.
 | 
| update_alist [Nethttpd_types] | update_alist updl l: Returns the alist with all elements ofupdland all elements oflthat are not member ofupdl. | 
| update_props_inheader [Netcgi_common] | update_props_inheader (name, value) (props, inheader)returns(props, inheader)to which the new parametername-valuehas been added -- topropsorinheader, depending onname. | 
| uri [Netcgi_apache.Apache.Request] | request_recurifield. | 
| uri_distributor [Nethttpd_services] | 
Configures URI distribution.
 | 
| uripath_decode [Nethttp] | 
Decodes %XX sequences in URI paths.
 | 
| uripath_encode [Nethttp] | 
Encodes unsafe characters in URI paths.
 | 
| url_addr [Neturl] | 
If the  hostpart of the URL is an IP address, the address is returned. | 
| url_encode [Netencoding.Base64] | 
Same as  encodebut 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  trueiff the URL has all of the components passed withtruevalue. | 
| url_query [Neturl] | |
| url_scheme [Neturl] | |
| url_socksymbol [Neturl] | url_socksymbol url default_port: Returns thehostandportparts
      of the URL assocksymbol. | 
| url_syntax_is_valid [Neturl] | 
Checks whether the passed  url_syntaxis valid. | 
| url_syntax_of_url [Neturl] | 
Returns the  url_syntaxrecord of a URL. | 
| url_user [Neturl] | |
| url_user_param [Neturl] | |
| use [Rpc_client.USE_CLIENT] | 
Announcement that this program will be used.
 | 
| use [Rpc_client] | 
If there are no bound programs, this is a no-op.
 | 
| user [Netcgi_apache.Apache.Request] | 
The authenticated user.
 | 
| user_encoding [Netconversion] | 
Determines the preferred user encoding:
 | 
| 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 pointiin encodingenc. | 
| ustring_sub [Netconversion] | ustring_sub enc start length s: Returns the substring ofsstarting
 at character countstartand consisting oflengthcharacters. | 
| ustring_to_lower [Netconversion] | 
Converts the input string to lowercase.
 | 
| ustring_to_title [Netconversion] | 
Converts the input string to titlecase.
 | 
| ustring_to_upper [Netconversion] | 
Converts the input string to uppercase.
 | 
| 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  intarguments 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 | |
| validate_glob_expr [Netglob] | 
Checks whether the passed expression is syntactically valid.
 | 
| validate_xdr_type [Xdr] | |
| validate_xdr_type_system [Xdr] | |
| value [Nethttp.Cookie] | 
The value of the cookie.
 | 
| value [Netcgi.Cookie] | 
The value of the cookie.
 | 
| value [Netcgi_common.Cookie] | |
| value_area [Netsys_mem] | 
Marks the memory block as value area.
 | 
| value_matches_type [Xdr] | 
Is the value properly formed with respect to this type? The third
 argument of this function is a list of parameter instances.
 | 
| verbose [Rpc_server] | 
Deprecated.
 | 
| verbose [Rpc_client] | 
set whether you want debug messages or not (same as setting
       Rpc_client.Debug.enable) | 
| verify [Netconversion] | 
Checks whether the string is properly encoded.
 | 
| verify_mic_token [Netgssapi] | 
Verifies the MIC  tokenwithget_mic, and returns true if the
      verification is successful | 
| version_number [Rpc_program] | 
Return the version number
 | 
| W | |
| wait [Shell_fs] | 
Waits until the running command is finished
 | 
| wait [Netmcore_condition] | wait we c matomically unlocks the mutexmand suspends the
      calling process on the condition variablec. | 
| wait [Netmcore_sem] | 
Decrements the semaphore by one.
 | 
| wait_e [Netmcore_condition] | 
Like  wait, but the suspension is done by waiting on a
      named pipe event (i.e. | 
| wait_event [Netsys_posix] | 
If the event fd is not signalled, the function blocks until
      it gets signalled, even in non-blocking mode.
 | 
| wait_for_enc_value [Netplex_sharedvar] | 
Same for encapsulated variables
 | 
| wait_for_value [Netplex_sharedvar] | wait_for_value name: If the variable exists andset_valuehas
      already been called at least once, the current value is returned. | 
| wait_until_connected [Netsys] | 
After a non-blocking connect has been initiated, this function can be
      used to wait until (1) the connect is successful, or (2) the connect
      fails, or (3) the operation times out.
 | 
| wait_until_prird [Netsys] | 
Wait until an operation for a single descriptor becomes possible.
 | 
| wait_until_readable [Netsys] | |
| wait_until_writable [Netsys] | |
| walk_method [Ftp_client] | 
This FTP method walks to the target directory:
 | 
| watch_subprocess [Netsys_posix] | let fd, ws = watch_subprocess pid pgid kill_flag: 
      Enters the subprocesspidinto the watch list. | 
| watchdog [Uq_engines] | 
Same as function
 | 
| weak_once [Unixqueue] | 
Same as  once, but the timer does not keep the event system running
      if it is the only remaining resource. | 
| weak_validator_match [Nethttp] | 
Whether the tags match weakly (see RFC 2616 for definition)
 | 
| week_day [Netdate] | 
Returns the week day.
 | 
| when_state [Uq_engines] | 
Watches the state of the argument engine, and arranges that one of
 the functions is called when the corresponding state change is done.
 | 
| win32_code_pages [Netconversion] | 
Mapping between Win32 code page numbers and Ocamlnet encodings.
 | 
| win_pid [Netsys_win32] | 
Returns the Windows notion of the process identifier (pid)
 | 
| wire_decode_token [Netgssapi] | 
Encode tokens as described in section 3.1 of RFC 2078.
 | 
| wire_encode_token [Netgssapi] | |
| with_in_obj_channel [Netchannels] | with_in_obj_channel ch f:
 Computesf chand closesch. | 
| with_out_obj_channel [Netchannels] | with_out_obj_channel ch f:
 Computesf chand closesch. | 
| with_tty [Netsys_posix] | with_tty f: Runsf fdwherefdis the terminal of the process. | 
| with_value [Netmcore_heap] | with_value h find process: Logically, this runsprocess (find ())and returns the result. | 
| with_value_2 [Netmcore_heap] | |
| with_value_3 [Netmcore_heap] | |
| with_value_4 [Netmcore_heap] | |
| with_value_5 [Netmcore_heap] | 
Same as  with_value, but a tuple of values can be passed down | 
| with_value_n [Netmcore_heap] | 
Same as  with_value, but a list of values can be passed down | 
| workload_manager_factories [Netplex_workload] | 
All built-in workload manager factories
 | 
| wrap [Netplex_encap.ENCAP] | |
| 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_blocks [Netshm] | write_blocks tbl ops key f: Likeread_blocksthis function iterates
 over the blocks of all bindings forkey. | 
| write_eof_e [Uq_io] | let e = write_eof_e d: For devices supporting half-open connections,
      this engine writes the EOF marker and transitions to`Done true. | 
| write_fp4 [Netnumber.ENCDEC] | |
| write_fp8 [Netnumber.ENCDEC] | |
| write_header [Mimestring] | 
This function writes the header to the passed  out_obj_channel. | 
| write_int4 [Rtypes] | |
| write_int4 [Netnumber.ENCDEC] | |
| write_int4_unsafe [Rtypes] | |
| write_int4_unsafe [Netnumber.ENCDEC] | |
| write_int8 [Rtypes] | |
| write_int8 [Netnumber.ENCDEC] | |
| write_int8_unsafe [Rtypes] | |
| write_int8_unsafe [Netnumber.ENCDEC] | |
| write_mime_message [Netmime] | 
Writes the MIME message to the output channel.
 | 
| write_uint4 [Rtypes] | |
| write_uint4 [Netnumber.ENCDEC] | |
| write_uint4_unsafe [Rtypes] | |
| write_uint4_unsafe [Netnumber.ENCDEC] | |
| write_uint8 [Rtypes] | write_<t> copies the characters corresponding to the integer values 
 into the string at the given positions. | 
| write_uint8 [Netnumber.ENCDEC] | write_<t> copies the characters corresponding to the integer values 
	into the string at the given positions. | 
| write_uint8_unsafe [Rtypes] | write_<t>_unsafe: Same, but no index check. | 
| write_uint8_unsafe [Netnumber.ENCDEC] | write_<t>_unsafe: Same, but no index check. | 
| write_value [Mimestring] | 
Writes the list of  s_tokento theout_obj_channel. | 
| wsa_enum_network_events [Netsys_win32] | 
Checks whether an event has been recorded
 | 
| wsa_event_select [Netsys_win32] | 
associate event objects with socket conditions
 | 
| wsa_maximum_wait_events [Netsys_win32] | 
max size of the array passed to  wsa_wait_for_multiple_events | 
| wsa_wait_for_multiple_events [Netsys_win32] | 
Waits until one of the events in the array is in signaled state,
        or until a timeout happens.
 | 
| X | |
| x_array_max [Xdr] | 
Common abbreviation for arrays of arbitrary length
 | 
| x_bool [Xdr] | 
Common abbreviation for boolean types.
 | 
| x_mstring_max [Xdr] | 
Common abbreviation for mstrings of arbitrary length
 | 
| x_opaque_max [Xdr] | 
Common abbreviation for opaque data of arbitrary length
 | 
| x_optional [Xdr] | 
Common abbreviation for optional types.
 | 
| x_string_max [Xdr] | 
Common abbreviation for strings of arbitrary length
 | 
| xdr_type_term [Xdr] | |
| xdr_type_term_system [Xdr] | |
| xdrt_PMAP'V2'pmapproc_callit'arg [Rpc_portmapper_aux] | |
| xdrt_PMAP'V2'pmapproc_callit'res [Rpc_portmapper_aux] | |
| xdrt_PMAP'V2'pmapproc_dump'arg [Rpc_portmapper_aux] | |
| xdrt_PMAP'V2'pmapproc_dump'res [Rpc_portmapper_aux] | |
| xdrt_PMAP'V2'pmapproc_getport'arg [Rpc_portmapper_aux] | |
| xdrt_PMAP'V2'pmapproc_getport'res [Rpc_portmapper_aux] | |
| xdrt_PMAP'V2'pmapproc_null'arg [Rpc_portmapper_aux] | |
| xdrt_PMAP'V2'pmapproc_null'res [Rpc_portmapper_aux] | |
| xdrt_PMAP'V2'pmapproc_set'arg [Rpc_portmapper_aux] | |
| xdrt_PMAP'V2'pmapproc_set'res [Rpc_portmapper_aux] | |
| xdrt_PMAP'V2'pmapproc_unset'arg [Rpc_portmapper_aux] | |
| xdrt_PMAP'V2'pmapproc_unset'res [Rpc_portmapper_aux] | |
| xdrt_call_args [Rpc_portmapper_aux] | |
| xdrt_call_result [Rpc_portmapper_aux] | |
| xdrt_mapping [Rpc_portmapper_aux] | |
| xdrt_pmaplist [Rpc_portmapper_aux] | |
| xdrt_pmaplist_p [Rpc_portmapper_aux] | |
| xmap_list [Nethtml] | xmap_list f surrounding_element_opt doclst: Similar tomap_list,
 the functionfis applied to all attribute values and data strings. | 
| xor_s [Netauth] | 
Performs the bitwise XOR of these strings (which must have the same
      length)
 | 
| xv_false [Xdr] | 
See  x_bool | 
| xv_none [Xdr] | |
| xv_some [Xdr] | 
See  x_optional | 
| xv_true [Xdr] | |
| Y | |
| year_day [Netdate] | 
Returns the year day (range 0 to 365)
 | 
| Z | |
| zero_pages [Netsys_mem] | zero_pages m pos len: If possible, the memory pages in the
      rangepostopos+len-1ofmare allocated again, so that
      they replace the previous pages. |