| A | |
| ac_by_host [Nethttpd_services] | The service is protected by the access control rule | 
| ac_by_host_rule [Nethttpd_services] | Access control by host:   | 
| access_description_flag [Netx509] | |
| action [Netsys_signal] | 
 | 
| addr_spec [Netaddress] | The pair  | 
| address [Netsys_gssapi] | Addresses tagged by address types | 
| address [Netplex_types] | |
| advice [Netsys_posix] | |
| alg_id [Netx509_pubkey] | |
| alg_param [Netx509_pubkey] | |
| algorithm [Netsys_crypto_types.PUBKEY_CRYPTO] | |
| announcement [Nethttpd_kernel] | See config | 
| anon_semaphore [Netsys_sem] | |
| anon_semaphore [Netsys_posix] | |
| arg_store [Netcgi] | This is the type of functions  | 
| arg_store [Netcgi_common] | See  | 
| arg_store_type [Netcgi_common] | |
| argument_processing [Netcgi1_compat.Netcgi] | |
| armor_spec [Netascii_armor] | Which types of armor to decode, and how. | 
| armor_type [Netascii_armor] | |
| armored_message [Netascii_armor] | Messages:  | 
| armored_message_ro [Netascii_armor] | The read-only version of  | 
| assignment [Shell] | An assignment redirects file descriptors while calling a process | 
| at_flag [Netsys_posix] | |
| auth_challenge [Nethttp.Header] | The type of a single challenge, used during authentication. | 
| auth_credentials [Nethttp.Header] | The type of a single credentials response, used during authentication. | 
| auth_peeker [Rpc_server] | |
| auth_result [Rpc_server] | |
| auth_status [Nethttp_client] | Status of HTTP-level authentication:  | 
| authority_access_description_flag [Netx509] | |
| authority_key_identifier [Netx509] | |
| B | |
| bad_request_error [Nethttpd_kernel] | A bad request is a violation where the current request cannot be decoded, and it is not possible to accept further requests over the current connection. | 
| bind_creds [Netldap] | |
| binding [Rpc_server] | |
| binding_async [Rpc_server] | |
| binding_sync [Rpc_server] | |
| bitstring_value [Netasn1.Value] | |
| buffer [Netmcore_buffer] | A buffer with a header of type  | 
| buffer_descr [Netmcore_buffer] | The marshallable buffer descriptor | 
| C | |
| cache_control [Netcgi1_compat.Netcgi_types] | |
| cache_control [Netcgi] | This is only a small subset of the HTTP 1.1 cache control features, but they are usually sufficient, and they work for HTTP/1.0 as well. | 
| cache_control [Netcgi_common] | See  | 
| cache_control_token [Nethttp] | The cache control token for the  | 
| call_args [Rpc_portmapper_aux] | |
| call_result [Rpc_portmapper_aux] | |
| calling_error [Netsys_gssapi] | Possible errors caused by the caller | 
| camlbox [Netcamlbox] | A  | 
| camlbox_address [Netcamlbox] | The address of a camlbox is a string that does not contain slashes. | 
| camlbox_sender [Netcamlbox] | An endpoint that may send messages of type  | 
| capacity [Netplex_types] | How many connections a container can accept in addition to the
 existing connections:  | 
| cb [Netsys_sasl_types] | Possible channel bindings:  | 
| cb [Netmech_scram] | Using the same channel binding type as for SASL | 
| cgi_config [Netcgi1_compat.Netcgi_env] | Now simply called  | 
| cgi_cookie [Netcgi1_compat.Netcgi_types] | |
| channel_bindings [Netsys_gssapi] | Channel binding as tuple
	 | 
| charset [Netconversion] | A  | 
| client_session [Netsys_sasl_types.SASL_MECHANISM] | |
| client_session [Netmech_scram] | Session context for clients | 
| client_session [Nethttp.HTTP_CLIENT_MECHANISM] | |
| client_state [Netsys_sasl_types] | The state of the client session:  | 
| clock [Netsys_posix] | |
| clock_id [Netsys_posix] | |
| close_mode [Netchannels] | Whether a  | 
| cmd [Netftp_client] | An FTP command. | 
| cmd_state [Netftp_client] | The command state:  | 
| cmdline_config [Netplex_main] | |
| color [Netsys_mem] | |
| command [Shell_sys] | A command describes how to start a new process | 
| command_context [Shell_fs] | |
| command_interpreter [Shell_fs] | The interpreter runs the command, and fills in  | 
| compiled_localization [Netdate] | |
| complex_mime_body [Netmime] | |
| complex_mime_body_ro [Netmime] | The read-only view of a complex_mime_message | 
| complex_mime_message [Netmime] | |
| complex_mime_message_ro [Netmime] | |
| compute_resource_repr [Netmcore] | Centrally managed resources include:  | 
| compute_resource_type [Netmcore] | |
| condition [Netmcore_condition] | The condition variable | 
| config [Netsys_crypto_types.TLS_PROVIDER] | |
| config [Netcgi] | |
| config [Netcgi_common] | See  | 
| config_error_response [Nethttpd_plex] | Three type abbreviations for logging functions | 
| config_log_access [Nethttpd_plex] | |
| config_log_error [Nethttpd_plex] | |
| config_tree [Netplex_types] | |
| conn_state [Nethttp_client_conncache] | A TCP connection may be either  | 
| connect_address [Uq_engines_compat] | |
| connect_address [Uq_client] | Specifies the service to connect to: | 
| connect_address [Uq_engines] | Moved to  | 
| connect_options [Uq_engines_compat] | |
| connect_options [Uq_client] | |
| connect_options [Uq_engines] | |
| connect_status [Uq_engines_compat] | |
| connect_status [Uq_client] | This type corresponds with  | 
| connect_status [Uq_engines] | Moved to  | 
| connection [Netcgi_dbi.DBI_DRIVER] | |
| connection [Netcgi_dbi.DBI_POOL] | |
| connection_cache [Nethttp_client] | |
| connection_directive [Netcgi] | Directive how to go on with the current connection:  | 
| connection_id [Rpc_server] | identifies the connection of a session. | 
| connector [Rpc_server] | |
| connector [Rpc_client] | |
| const_str_datum_p [Nettls_gnutls_bindings] | |
| consumer [Shell] | A consumer receives data from a called process | 
| container [Netsys_sem] | The container of the semaphore is the shared memory object | 
| container_id [Netplex_types] | Such objects identify containers. | 
| container_state [Netplex_types] | The container state for workload management:  | 
| context [Netsys_gssapi.GSSAPI] | A context is also opaque. | 
| cookie [Nethttp] | Compatibility name. | 
| copy_flag [Netfs] | |
| copy_task [Uq_engines_compat] | |
| copy_task [Uq_transfer] | Specifies the task the  | 
| copy_task [Uq_engines] | Moved to  | 
| create_process_option [Netsys_win32] | |
| cred_type [Nettls_support] | The type of credential types | 
| cred_usage [Netsys_gssapi] | |
| credential [Netsys_gssapi.GSSAPI] | A credential is opaque for the caller of the GSS-API. | 
| credentials [Netsys_sasl] | Credentials are given as list
       | 
| credentials [Netsys_crypto_types.TLS_PROVIDER] | |
| credentials [Netsys_sasl_types.SASL_MECHANISM] | |
| credentials [Netmech_scram] | Two forms of providing credentials:  | 
| credentials [Nettls_support] | The types of credentials | 
| credentials [Nethttp.HTTP_CLIENT_MECHANISM] | |
| crl_list [Netsys_tls] | Certificate revocation lists are given either as: | 
| crl_list [Netsys_crypto_types.TLS_PROVIDER] | Certificate revocation lists are given either as: | 
| crt_list [Netsys_tls] | Certificates are given either as: | 
| crt_list [Netsys_crypto_types.TLS_PROVIDER] | Certificates are given either as: | 
| ctrl_op [Netshm] | |
| cursor [Netconversion] | |
| custom_ops [Netsys_mem] | |
| D | |
| data_chunk [Nethttpd_kernel] | A  | 
| data_manager [Netshm_data] | The data manager consists of several manager functions. | 
| datagram_type [Uq_engines_compat] | |
| datagram_type [Uq_datagram] | -  | 
| datagram_type [Uq_engines] | Moved to  | 
| debug_target [Equeue.Debug] | |
| decoder [Netxdr] | see text above | 
| deref_aliases [Netldap] | What to do when aliases (server-dereferenced symbolic links) are found
      in the tree:  | 
| descr [Netmcore_heap] | A descriptor ("address") pointing to the heap. | 
| descr_state [Netftp_data_endpoint] | Describes the state of the socket used for data transfers. | 
| dh_params [Netsys_tls] | Diffie-Hellman parameters: | 
| dh_params [Netsys_crypto_types.TLS_PROVIDER] | Diffie-Hellman parameters: | 
| digest [Netsys_crypto_types.DIGESTS] | Describes a digest | 
| digest_ctx [Netsys_crypto_types.DIGESTS] | A digest context stores state while digesting data | 
| digests [Netsys_crypto_types] | |
| dlogger [Netlog.Debug] | Debug logger: The first string is the module name, and the second is the message | 
| dn [Netdn] | This is the raw version of the DN: a sequence of relative DNs, and a relative DN is a set of (type,value) pairs. | 
| document [Nethtml] | The type  | 
| domain [Netaddress] | The domain of the mailbox | 
| dynamic_service [Nethttpd_services] | |
| E | |
| element_class [Nethtml] | Element classes are a property used in the HTML DTD. | 
| empty_flags [Nettls_gnutls_bindings] | |
| empty_flags_flag [Nettls_gnutls_bindings] | |
| encap [Netplex_encap] | An encapsulated value with a type identifier | 
| encap [Netplex_types] | |
| encap [Nethttpd_plex] | |
| encoder [Netxdr] | see text above | 
| encoding [Netconversion] | The polymorphic variant enumerating the supported encodings. | 
| encrypt_alg [Netx509_pubkey] | |
| endpoint [Netsys_crypto_types.TLS_PROVIDER] | |
| engine_req_state [Nethttpd_engine] | |
| engine_state [Uq_engines_compat] | |
| engine_state [Uq_engines] | The type of states with result values of type  | 
| engine_state [Uq_resolver] | |
| entity_set [Netencoding.Html] | |
| entry [Netsys_signal] | |
| entry [Netftp_client] | A file entry  | 
| entry_perm [Netftp_client] | Permissions:  | 
| entry_type [Netftp_client] | Types:  | 
| environment [Shell_sys] | The abstract type of a process environment | 
| eq [Netplex_types] | Equality witness | 
| error_code [Nettls_gnutls_bindings] | |
| etag [Nethttp] | Entity tags can be weak or strong | 
| event [Uq_libevent.LIBOEVENT] | |
| event [Unixqueue] | An  | 
| event_aggregator [Netsys_posix] | |
| event_callback [Uq_libevent.LIBOEVENT] | |
| event_flags [Uq_libevent.LIBOEVENT] | |
| event_source [Netsys_posix] | |
| exn_handler [Netcgi] | A function of type  | 
| ext_key_usage_flag [Netx509] | |
| extended_address [Netplex_types] | Possible addresses:  | 
| extfd [Netplex_types] | Internally used | 
| F | |
| fatal_error [Nethttpd_kernel] | These are the serious protocol violations after that the daemon stops any further processing. | 
| fd_action [Netsys_posix] | |
| fd_style [Netsys] | Some information what kind of operations are reasonable for descriptors:  | 
| file_kind [Netfs] | |
| file_option [Nethttpd_services] | Add-on features for file services:  | 
| file_service [Nethttpd_services] | Describes a file service | 
| file_tls_endpoint [Netsys_crypto_types] | |
| filename [Netftp_client] | There are several methods how to specify filenames:  | 
| filter [Netldap] | Filter:  | 
| final_state [Uq_engines_compat] | |
| final_state [Uq_engines] | Same as  | 
| flags [Netgss_bindings] | |
| flags_flag [Netgss_bindings] | |
| fork_point [Netmcore_process] | A fork point can start a new process with argument  | 
| form_code [Netftp_client] | The  | 
| format [Netlog] | |
| fp4 [Netnumber] | single precision float (IEEE "float") | 
| fp8 [Netnumber] | double precision float (IEEE "double") | 
| from_uni_list [Netmappings] | |
| front_token [Nethttpd_kernel] | Tokens generated by  | 
| ftp_auth [Netftp_client] | |
| ftp_data_prot [Netftp_client] | Meaning:  | 
| ftp_data_prot [Netftp_data_endpoint] | |
| ftp_method [Netftp_client] | An  | 
| ftp_protector [Netftp_data_endpoint] | The functions for encrypting (wrapping) and decrypting (unwrapping) messages when an RFC 2228 security layer is active. | 
| ftp_state [Netftp_client] | The ftp_state reflects the knowledge of the client about what has been agreed upon with the server. | 
| fwd_mode [Shell_sys] | Determines whether and how keyboard signals (SIGINT, SIGQUIT) are forwarded from the caller to the new child. | 
| G | |
| general_name [Netx509] | General names:  | 
| glob_expr [Netglob] | |
| glob_expr_atom [Netglob] | Atoms: | 
| glob_mode [Netglob] | Modes:  | 
| glob_set [Netglob] | A set of code points is given as a list of ranges  | 
| gnutls_alert_description_t [Nettls_gnutls_bindings] | |
| gnutls_alert_level_t [Nettls_gnutls_bindings] | |
| gnutls_anon_client_credentials_t [Nettls_gnutls_bindings] | |
| gnutls_anon_server_credentials_t [Nettls_gnutls_bindings] | |
| gnutls_certificate_credentials_t [Nettls_gnutls_bindings] | |
| gnutls_certificate_import_flags [Nettls_gnutls_bindings] | |
| gnutls_certificate_import_flags_flag [Nettls_gnutls_bindings] | |
| gnutls_certificate_print_formats_t [Nettls_gnutls_bindings] | |
| gnutls_certificate_request_t [Nettls_gnutls_bindings] | |
| gnutls_certificate_status_t [Nettls_gnutls_bindings] | |
| gnutls_certificate_status_t_flag [Nettls_gnutls_bindings] | |
| gnutls_certificate_type_t [Nettls_gnutls_bindings] | |
| gnutls_certificate_verify_flags [Nettls_gnutls_bindings] | |
| gnutls_certificate_verify_flags_flag [Nettls_gnutls_bindings] | |
| gnutls_channel_binding_t [Nettls_gnutls_bindings] | |
| gnutls_cipher_algorithm_t [Nettls_gnutls_bindings] | |
| gnutls_cipher_hd_t [Nettls_gnutls_bindings] | |
| gnutls_close_request_t [Nettls_gnutls_bindings] | |
| gnutls_compression_method_t [Nettls_gnutls_bindings] | |
| gnutls_credentials [Nettls_gnutls_bindings] | |
| gnutls_credentials_type_t [Nettls_gnutls_bindings] | |
| gnutls_dh_params_t [Nettls_gnutls_bindings] | |
| gnutls_digest_algorithm_t [Nettls_gnutls_bindings] | |
| gnutls_ecc_curve_t [Nettls_gnutls_bindings] | |
| gnutls_handshake_description_t [Nettls_gnutls_bindings] | |
| gnutls_info_access_what_t [Nettls_gnutls_bindings] | |
| gnutls_init_flags [Nettls_gnutls_bindings] | |
| gnutls_init_flags_flag [Nettls_gnutls_bindings] | |
| gnutls_kx_algorithm_t [Nettls_gnutls_bindings] | |
| gnutls_mac_algorithm_t [Nettls_gnutls_bindings] | |
| gnutls_params_type_t [Nettls_gnutls_bindings] | |
| gnutls_pk_algorithm_t [Nettls_gnutls_bindings] | |
| gnutls_pkcs_encrypt_flags_t [Nettls_gnutls_bindings] | |
| gnutls_pkcs_encrypt_flags_t_flag [Nettls_gnutls_bindings] | |
| gnutls_priority_t [Nettls_gnutls_bindings] | |
| gnutls_privkey_t [Nettls_gnutls_bindings] | |
| gnutls_privkey_type_t [Nettls_gnutls_bindings] | |
| gnutls_protocol_t [Nettls_gnutls_bindings] | |
| gnutls_psk_client_credentials_t [Nettls_gnutls_bindings] | |
| gnutls_psk_key_flags [Nettls_gnutls_bindings] | |
| gnutls_psk_server_credentials_t [Nettls_gnutls_bindings] | |
| gnutls_pubkey_t [Nettls_gnutls_bindings] | |
| gnutls_sec_param_t [Nettls_gnutls_bindings] | |
| gnutls_server_name_type_t [Nettls_gnutls_bindings] | |
| gnutls_session_t [Nettls_gnutls_bindings] | |
| gnutls_sign_algorithm_t [Nettls_gnutls_bindings] | |
| gnutls_srp_client_credentials_t [Nettls_gnutls_bindings] | |
| gnutls_srp_server_credentials_t [Nettls_gnutls_bindings] | |
| gnutls_supplemental_data_format_type_t [Nettls_gnutls_bindings] | |
| gnutls_x509_crl_t [Nettls_gnutls_bindings] | |
| gnutls_x509_crt_fmt_t [Nettls_gnutls_bindings] | |
| gnutls_x509_crt_t [Nettls_gnutls_bindings] | |
| gnutls_x509_privkey_t [Nettls_gnutls_bindings] | |
| gnutls_x509_subject_alt_name_t [Nettls_gnutls_bindings] | |
| group [Unixqueue] | A group is an abstract tag for a set of events, resources, and event handlers. | 
| group_action [Shell_sys] | Determines in which process group the new process will run | 
| group_mode [Shell_sys] | Specifies how the job instance is related to process groups | 
| gss_OID [Netgss_bindings] | |
| gss_OID_set [Netgss_bindings] | |
| gss_buffer_t [Netgss_bindings] | |
| gss_channel_bindings_t [Netgss_bindings] | |
| gss_cred_id_t [Netgss_bindings] | |
| gss_cred_usage_t [Netgss_bindings] | |
| gss_ctx_id_t [Netgss_bindings] | |
| gss_name_t [Netgss_bindings] | |
| gss_qop_t [Netgss_bindings] | |
| H | |
| hash_function [Netx509_pubkey] | |
| header_kind [Nethttp_client] | The  | 
| heap [Netmcore_heap] | A heap where the type of the root element is  | 
| host [Nethttpd_services] | For name- and IP-based virtual hosting this record describes the individual host. | 
| host_distributor [Nethttpd_services] | Describes virtual hosting by pairs  | 
| how_to_reconnect [Nethttp_client] | How to deal with automatic reconnections, especially when the connection crashes. | 
| how_to_redirect [Nethttp_client] | |
| http_method [Nethttp] | Method name, URI | 
| http_method [Netcgi] | |
| http_method [Netcgi_common] | |
| http_options [Nethttp_client] | Options for the whole pipeline. | 
| http_service_reaction [Nethttpd_types] | Indicates the immediate reaction upon an arriving HTTP header:  | 
| http_status [Nethttp] | HTTP response status: | 
| httpd_factory [Nethttpd_plex] | The type of the  | 
| I | |
| iana_hash_fn [Netsys_digests] | The hash functions contained in the IANA registry (http://www.iana.org/assignments/hash-function-text-names/hash-function-text-names.xhtml). | 
| identity [Rpc_auth_sys] | Specifies the user:  | 
| in_bdevice [Uq_io] | Devices with look-ahead | 
| in_buffer [Uq_io] | |
| in_device [Uq_io] | Currently supported devices for input:  | 
| in_record [Rpc_transport] | |
| in_rule [Rpc_transport] | |
| inactive_data [Nethttp_client_conncache] | |
| inetspec [Uq_engines_compat] | |
| inetspec [Uq_client] | |
| inetspec [Uq_engines] | Moved to  | 
| inherit_request [Netmcore] | |
| init_credentials [Netsys_sasl.Server] | A function for preparing credentials, provided by the mechanism. | 
| init_value_flag [Netsys_mem] | |
| input_mode [Netcgi1_compat.Netcgi_env] | This is not used anywhere. | 
| input_result [Netchannels] | This type is for the method  | 
| input_state [Netcgi1_compat.Netcgi_env] | This is not the business of the user. | 
| int32_array [Netshm] | |
| int4 [Netnumber] | 32 bit signed integer | 
| int8 [Netnumber] | 64 bit signed integer | 
| int_value [Netasn1.Value] | |
| internal_pipe [Rpc_server] | |
| internal_pipe [Rpc_client] | |
| internal_pipe [Rpc_transport] | |
| internal_socket [Rpc_server] | |
| internal_socket [Rpc_client] | |
| interprocess_token [Netsys_gssapi] | Interprocess tokens. | 
| io_device [Uq_io] | Bidirectional devices | 
| ioprio [Netsys_posix] | |
| ioprio_target [Netsys_posix] | |
| J | |
| job [Shell_sys] | |
| job_instance [Shell_sys] | |
| job_status [Shell_sys] | Indicates the status of the job | 
| join_point [Netmcore_process] | A join point can wait until a process finishes with a result  | 
| K | |
| kex_alg [Netx509_pubkey] | |
| key_type [Netauth] | Key types:  | 
| key_usage [Nettls_gnutls_bindings] | |
| key_usage_flag [Nettls_gnutls_bindings] | |
| key_usage_flag [Netx509] | |
| kind_check [Netplex_types] | Helper type for a polymorphic check whether a kind this the expected kind | 
| L | |
| langinfo [Netsys_posix] | |
| ldap_connection [Netldap] | |
| level [Netlog] | The log levels (syslog-like) | 
| level [Netsys_posix] | |
| level [Netplex_types] | Log levels, modeled after syslog | 
| lexbuf [Netulex.Ulexing] | |
| linear_distributor [Nethttpd_services] | Services are selected by calling the selector function. | 
| listen_address [Uq_engines_compat] | |
| listen_address [Uq_server] | Specifies the resource to listen on: | 
| listen_address [Uq_engines] | Moved to  | 
| listen_options [Uq_engines_compat] | |
| listen_options [Uq_server] | |
| listen_options [Uq_engines] | |
| local_part [Netaddress] | Usually the user name | 
| local_receiver [Netftp_data_endpoint] | The  | 
| local_sender [Netftp_data_endpoint] | The  | 
| localization [Netdate] | |
| locking_method [Netshm] | The locking method is used to ensure that parallel read and write operations to the memory object do not interfer with each other. | 
| logger [Netlog] | A logging function takes a level, and the message | 
| lookup [Netsys_sasl.Server] | see  | 
| loop_flags [Uq_libevent.LIBOEVENT] | |
| M | |
| major_status [Netsys_gssapi] | The major status consists of these three elements. | 
| mapping [Rpc_portmapper_aux] | |
| maskgen_function [Netx509_pubkey] | |
| match_result [Nethttp] | |
| mbox [Netplex_mbox.MBOX] | The type of the mailboxes | 
| mclient [Rpc_proxy.ManagedClient] | A managed client | 
| mclient_config [Rpc_proxy.ManagedClient] | |
| memory [Nettls_gnutls_bindings] | |
| memory [Netsys_mem] | We consider 1-dimensional bigarrays of chars as memory buffers. | 
| memory [Netsys_types] | We consider 1-dimensional bigarrays of chars as memory buffers. | 
| memory [Netgss_bindings] | |
| memory_pool [Netsys_mem] | A pool of  | 
| message [Netsys_gssapi] | Messages are represented as lists of  | 
| method_distributor [Nethttpd_services] | The first service is selected for which the method filter accepts the request | 
| method_filter [Nethttpd_services] | The request is only accepted if listed (for  | 
| mime_message [Netmime] | Simple MIME message, in a form that is compatible with complex ones. | 
| mime_message_ro [Netmime] | Read-only variant of simple messages | 
| mime_scanner [Netmime_string] | The opaque type of a scanner for structured values | 
| minor_status [Netsys_gssapi] | The minor status is provider-specific. | 
| mkdir_flag [Netfs] | |
| mode [Rpc] | |
| mode2 [Rpc_server] | Determines the type of the server for  | 
| mode2 [Rpc_client] | Determines the type of the client for  | 
| model_constraint [Nethtml] | Model constraints define the possible sub elements of an element:  | 
| monitor [Uq_mt] | A thread monitor governs which threads have access to a set of engines running together on an event system | 
| mountpoint [Netcgi_plex] | |
| mset [Rpc_proxy.ManagedSet] | a managed set | 
| mset_config [Rpc_proxy.ManagedSet] | |
| mset_policy [Rpc_proxy.ManagedSet] | Sets in which order managed clients are picked from the 
             | 
| multipart_style [Netmime_channels] | How to parse multipart messages:  | 
| mutator [Netmcore_heap] | Mutators allow it to push new values onto the heap. | 
| mutex [Netplex_mutex] | |
| mutex [Netmcore_mutex] | |
| mutex_type [Netmcore_mutex] | Types:  | 
| N | |
| name [Netsys_gssapi.GSSAPI] | A name is also opaque | 
| named_mstring_factories [Netxdr_mstring] | |
| named_semaphore [Netsys_posix] | |
| net_nettle_cipher_ctx_t [Nettls_nettle_bindings] | |
| net_nettle_cipher_t [Nettls_nettle_bindings] | |
| net_nettle_gcm_aes_ctx_t [Nettls_nettle_bindings] | |
| net_nettle_hash_ctx_t [Nettls_nettle_bindings] | |
| net_nettle_hash_t [Nettls_nettle_bindings] | |
| netbuf [Rpc_portmapper_aux] | |
| netscape_cookie [Nethttp] | These are old-style cookies, as introduced by Netscape. | 
| node_type [Netsys_posix] | |
| not_event [Netsys_posix] | |
| O | |
| oid [Netsys_gssapi] | OIDs like "1.3.6.1.5.6.2" as array of int's. | 
| oid [Netx509_pubkey] | OIDs are just integer sequences | 
| oid [Netx509] | OIDs are just integer sequences | 
| oid [Netdn] | |
| oid_set [Netsys_gssapi] | A set of OID's. | 
| onshutdown_in_spec [Uq_engines_compat] | |
| onshutdown_in_spec [Uq_transfer] | See class  | 
| onshutdown_in_spec [Uq_engines] | Moved to  | 
| onshutdown_out_spec [Uq_engines_compat] | |
| onshutdown_out_spec [Uq_transfer] | See class  | 
| onshutdown_out_spec [Uq_engines] | Moved to  | 
| operating_type [Netcgi1_compat.Netcgi] | |
| operation [Netldap] | |
| operation [Unixqueue] | An  | 
| other_url_spec [Netcgi1_compat.Netcgi_types] | |
| other_url_spec [Netcgi] | Determines how an URL part is generated:  | 
| other_url_spec [Netcgi_common] | |
| out_buffer [Uq_io] | Buffers that can be attached to a  | 
| out_device [Uq_io] | Currently supported devices for output:  | 
| output_mode [Netcgi1_compat.Netcgi_env] | This is not used anywhere. | 
| output_state [Nethttpd_types] | |
| output_state [Netcgi1_compat.Netcgi_env] | This is not the business of the user. | 
| output_type [Netcgi] | The ouput type determines how generated data is buffered. | 
| output_type [Netcgi_common] | See  | 
| P | |
| packed_value [Rpc_packer] | |
| padding [Netsys_ciphers] | Padding schemes: | 
| parallelization_type [Netplex_types] | Type of parallelization:  | 
| param_value [Nethttp.Header] | Some parameters may occur quoted and unquoted. | 
| param_value [Netplex_types] | |
| param_value_or_any [Netplex_types] | |
| pattern [Netglob] | Input for  | 
| pattern [Netaux.KMP] | |
| pc [Netasn1.Value] | |
| peer [Nethttp_client_conncache] | |
| pg_spec [Netsys_posix] | |
| pin_callback [Netsys_crypto_types.PUBKEY_CRYPTO] | |
| pipe_mode [Netsys_win32] | |
| pm_obj [Netsys_pmanage] | |
| pmaplist [Rpc_portmapper_aux] | |
| pmaplist_p [Rpc_portmapper_aux] | |
| poll_act_events [Netsys_posix] | Poll events. | 
| poll_array [Netsys_posix] | The array of  | 
| poll_cell [Netsys_posix] | The poll cell refers to the descriptor  | 
| poll_req_events [Netsys_posix] | |
| poly_cursor [Netconversion] | A cursor denotes a character position in an encoded string. | 
| polyclient [Netsys_polysocket] | A client, connected or unconnected | 
| polyclient_box [Netplex_types] | This type pairs a  | 
| polyendpoint [Netsys_polysocket] | An endpoint is simply a pair  | 
| polypipe [Netsys_polypipe] | |
| polyserver [Netsys_polysocket] | A server | 
| polyserver_box [Netplex_types] | This type pairs a  | 
| polysocket_kind [Netplex_types] | List possible argument types for polysockets ( | 
| polysocket_kind_box [Netplex_types] | Boxed version of  | 
| port [Netftp_client] | The port of the data connection:  | 
| posix_timer [Netsys_posix] | |
| prefix [Netsys_sem] | A name starting with a slash. | 
| private_api [Nethttp_client] | The private part of the  | 
| private_key [Netsys_tls] | Private keys are given either as: | 
| private_key [Netsys_crypto_types.PUBKEY_CRYPTO] | |
| private_key [Netsys_crypto_types.TLS_PROVIDER] | Private keys are given either as: | 
| privkey [Netx509_pubkey] | |
| process [Shell_sys] | A process is the running instance of a command (a Unix process) | 
| process_id [Netmcore] | This tagged integer identifies processes. | 
| producer [Shell] | A producer generates data sent to a called process | 
| profile [Netmech_scram] | Profile | 
| protocol [Rpc] | |
| protocol [Nethttp] | The base protocol. | 
| protocol [Netcgi1_compat.Netcgi_env] | |
| protocol_attribute [Nethttp] | |
| protocol_attribute [Netcgi1_compat.Netcgi_env] | |
| protocol_version [Nethttp] | |
| protocol_version [Netcgi1_compat.Netcgi_env] | |
| proxy_type [Nethttp_client] | |
| ptype [Netmech_scram] | Profile types:  | 
| pubkey [Netx509_pubkey] | Public key info: the key as such plus the algorithm. | 
| pubkey_crypto [Netsys_crypto_types] | |
| public_key [Netsys_crypto_types.PUBKEY_CRYPTO] | |
| Q | |
| qop [Netsys_gssapi] | Quality-of-proctection parameters are mechanism-specific. | 
| query_string_spec [Netcgi1_compat.Netcgi_types] | |
| query_string_spec [Netcgi] | Determines how the query part of URLs is generated:  | 
| query_string_spec [Netcgi_common] | |
| R | |
| r [Netplex_cenv.FUN_TYPE] | result type | 
| r [Netplex_cenv.LEVER] | result type | 
| raw_credentials [Netsys_crypto_types.TLS_PROVIDER] | The encoded credentials:  | 
| raw_credentials [Nettls_support] | The encoded credentials:  | 
| rcache [Rpc_proxy.ReliabilityCache] | The cache | 
| rcache_config [Rpc_proxy.ReliabilityCache] | |
| rcache_policy [Rpc_proxy.ReliabilityCache] | How failures of individual ports are interpreted:  | 
| read_file_flag [Netfs] | |
| read_file_flag [Nethttp_fs] | |
| read_flag [Netfs] | |
| read_flag [Nethttp_fs] | |
| read_policy [Netcgi_apache.Apache.Request] | Policy to apply by  | 
| readdir_flag [Netfs] | |
| readlink_flag [Netfs] | |
| real_value [Netasn1.Value] | |
| regexp [Netstring_str] | The type of regular expressions | 
| regexp [Netstring_pcre] | The type of regular expressions; now based on  | 
| reject_code [Rpc_client] | Reaction on authentication problems:  | 
| remove_flag [Netfs] | |
| rename_flag [Netfs] | |
| reply [Netftp_client] | Reply code plus text | 
| representation [Netftp_client] | The representation of the transferred file:  | 
| representation [Netcgi1_compat.Netcgi_types] | Embedded in the single place of use. | 
| representation [Netcgi_common] | |
| req_flag [Netsys_gssapi] | Flags for the  | 
| req_token [Nethttpd_kernel] | A  | 
| request_line [Nethttpd_kernel] | The method (including the URI), and the HTTP version | 
| request_method [Netcgi1_compat.Netcgi_types] | |
| request_method [Netcgi_common] | |
| res_id [Netmcore] | This tagged integer identifies resources. | 
| resolver [Nethttp_client] | A name resolver is a function  | 
| resp_state [Nethttpd_kernel] | The response state:  | 
| resp_token [Nethttpd_kernel] | The  | 
| response_body_storage [Nethttp_client] | How to create the response body:  | 
| result [Rpc_transport] | |
| result [Netstring_str] | The type of matching results | 
| result [Netstring_pcre] | The type of matching results | 
| result [Netcgi_apache.Handler] | |
| result_code [Netldap] | |
| result_eof [Rpc_transport] | |
| ret_flag [Netsys_gssapi] | Flags for the  | 
| rmdir_flag [Netfs] | |
| routine_error [Netsys_gssapi] | Possible errors caused by the provider | 
| rp__list [Rpc_portmapper_aux] | |
| rpcb [Rpc_portmapper_aux] | |
| rpcb_entry [Rpc_portmapper_aux] | |
| rpcb_entry_list [Rpc_portmapper_aux] | |
| rpcb_entry_list_ptr [Rpc_portmapper_aux] | |
| rpcb_rmtcallargs [Rpc_portmapper_aux] | |
| rpcb_rmtcallres [Rpc_portmapper_aux] | |
| rpcb_stat [Rpc_portmapper_aux] | |
| rpcb_stat_byvers [Rpc_portmapper_aux] | |
| rpcblist_ptr [Rpc_portmapper_aux] | |
| rpcbs_addrlist [Rpc_portmapper_aux] | |
| rpcbs_addrlist_ptr [Rpc_portmapper_aux] | |
| rpcbs_proc [Rpc_portmapper_aux] | |
| rpcbs_rmtcalllist [Rpc_portmapper_aux] | |
| rpcbs_rmtcalllist_ptr [Rpc_portmapper_aux] | |
| rule [Rpc_server] | |
| runner [Uq_tcl] | |
| runner [Uq_gtk] | |
| S | |
| s [Netplex_cenv.FUN_TYPE] | argument type | 
| s [Netplex_cenv.LEVER] | argument type | 
| s_extended_token [Netmime_string] | An opaque type containing the information of  | 
| s_option [Netmime_string] | |
| s_param [Netmime_string] | The type of encoded parameters (RFC 2231) | 
| s_token [Netmime_string] | A token may be one of:  | 
| sarray [Netmcore_array] | Arrays where the elements have type  | 
| sarray2 [Netmcore_matrix] | Arrays where the elements have type  | 
| sarray2_descr [Netmcore_matrix] | The marshallable descriptor of a shared matrix | 
| sarray_descr [Netmcore_array] | The marshallable descriptor of a shared array | 
| sasl_mechanism [Netsys_sasl] | |
| sc [Netsys_crypto_modes.Symmetric_cipher] | |
| sc_ctx [Netsys_crypto_modes.Symmetric_cipher] | |
| scipher [Netsys_crypto_types.SYMMETRIC_CRYPTO] | Describes a cipher | 
| scipher_ctx [Netsys_crypto_types.SYMMETRIC_CRYPTO] | A cipher context stores processing data while encrypting or decrypting data | 
| scope [Netldap] | The scope of the search:  | 
| search_result [Netldap] | Search results are either entries or references:  | 
| sem_kind [Netsys_posix] | |
| sem_open_flag [Netsys_sem] | |
| sem_open_flag [Netsys_posix] | |
| sem_wait_behavior [Netsys_sem] | |
| sem_wait_behavior [Netsys_posix] | |
| semaphore [Netsys_posix] | |
| semaphore [Netmcore_sem] | |
| serial [Netlog.Debug] | A serial number for the optional tracking of ownership | 
| server_error [Rpc] | |
| server_error [Netmech_scram] | Error codes of this protocol | 
| server_name [Netsys_crypto_types.TLS_PROVIDER] | |
| server_session [Netsys_sasl_types.SASL_MECHANISM] | |
| server_session [Netmech_scram] | Session context for servers | 
| server_state [Netsys_sasl_types] | The state of the server session:  | 
| service_factory [Nethttpd_plex] | The service factory function is called when a  | 
| session [Rpc_server] | identifies a pair of a call and a reply | 
| session [Netsys_sasl.Server] | |
| session [Netsys_sasl.Client] | |
| shm_descr [Netshm] | A shared memory descriptor refers to a shared memory object. | 
| shm_name [Netshm] | A  | 
| shm_open_flag [Netsys_posix] | |
| shm_table [Netshm] | |
| shm_type [Netshm] | |
| sig_action [Netsys_posix] | |
| sign_alg [Netx509_pubkey] | |
| simplified_dtd [Nethtml] | A  | 
| size_flag [Netfs] | |
| sockaddr [Rpc_transport] | |
| socket_state [Netplex_types] | The state of a socket:  | 
| sockspec [Uq_engines_compat] | |
| sockspec [Uq_client] | Extended names for socket addresses. | 
| sockspec [Uq_engines] | Moved to  | 
| socksymbol [Netsockaddr] | Symbolic socket names: | 
| specific_keys [Netmech_scram] | The specific keys to use | 
| split_result [Netstring_str] | |
| split_result [Netstring_pcre] | |
| squeue [Netmcore_queue] | Queues where the elements have type  | 
| squeue_descr [Netmcore_queue] | The marshallble descriptor of queues | 
| sref [Netmcore_ref] | |
| sref_descr [Netmcore_ref] | The marshallable descriptor of a reference | 
| state [Rpc_proxy.ManagedClient] | The state:  | 
| state [Netsys_crypto_types.TLS_PROVIDER] | The state of a session: | 
| state [Netpop] | |
| status [Nethttp_client] | Condensed status information of a HTTP call:  | 
| status [Netcgi1_compat.Netcgi_types] | |
| status_line [Nethttpd_kernel] | = (code, phrase) | 
| status_type_t [Netgss_bindings] | |
| std_activation [Nethttpd_services] | The way the  | 
| std_activation_options [Nethttpd_services] | These are options for  | 
| store [Netmime] | Specifies where to store the body of a mail message. | 
| store [Netcgi1_compat.Netcgi_types] | Embedded in the single place of use. | 
| store [Netcgi_common] | |
| str_datum [Nettls_gnutls_bindings] | |
| str_datum_p [Nettls_gnutls_bindings] | |
| string_like [Uq_io] | The user can pass data buffers that base either on bytes or on bigarrays of char (memory). | 
| structure [Netftp_client] | The client supports two structures:  | 
| subject_access_description_flag [Netx509] | |
| suppl_status [Netsys_gssapi] | Further flags | 
| support_level [Rpc_auth_gssapi] | |
| support_level [Netsys_gssapi] | |
| support_level [Netftp_client] | |
| symlink_flag [Netfs] | |
| symmetric_crypto [Netsys_crypto_types] | |
| synchronization [Nethttp_client] | This type determines whether to keep requests and responses synchronized or not. | 
| syslog_facility [Netsys_posix] | The facilities. | 
| syslog_option [Netsys_posix] | The syslog options:  | 
| T | |
| t [Rpc_server] | represents a server for an RPC program | 
| t [Rpc_portmapper] | represents a client for the Portmapper/RPCBIND daemon | 
| t [Rpc_portmapper_clnt.Make'PMAP.V4] | |
| t [Rpc_portmapper_clnt.Make'PMAP.V3] | |
| t [Rpc_portmapper_clnt.Make'PMAP.V2] | |
| t [Rpc_simple_client] | The type of simple clients | 
| t [Rpc_client.USE_CLIENT] | The client type | 
| t [Rpc_client] | The type of RPC clients | 
| t [Rpc_program] | Type of RPC programs | 
| t [Netoid] | |
| t [Netpagebuffer] | |
| t [Nethttp.Cookie] | Functions to manipulate cookies. | 
| t [Netdate] | |
| t [Netbuffer] | |
| t [Netaddress] | The union of  | 
| t [Netshm_array] | |
| t [Netshm_hashtbl] | |
| t [Netplex_mbox.MBOX] | The type of messages | 
| t [Netplex_encap.TYPE] | |
| t [Netplex_encap.ENCAP] | |
| t [Netplex_sharedvar.VV_TYPE] | |
| t [Netplex_cenv.TYPE] | |
| t [Netplex_cenv.LEVER] | |
| t [Netplex_cenv.VAR_TYPE] | |
| t [Netmcore_hashtbl] | The type of hash tables from type  | 
| t [Netcgi.Cookie] | Mutable cookie type. | 
| t [Netcgi_common.Cookie] | |
| t [Netcgi_apache.Handler] | The type of handler functions. | 
| t [Netcgi_apache.Apache.Request] | Apache  | 
| t [Netcgi_apache.Apache.Connection] | Apache  | 
| t [Netcgi_apache.Apache.Server] | Apache  | 
| t [Netcgi_apache.Apache.Table] | Apache  | 
| t [Equeue] | This is the type of an event system with events of type 'a | 
| t_PMAP'V2'pmapproc_callit'arg [Rpc_portmapper_aux] | |
| t_PMAP'V2'pmapproc_callit'res [Rpc_portmapper_aux] | |
| t_PMAP'V2'pmapproc_dump'arg [Rpc_portmapper_aux] | |
| t_PMAP'V2'pmapproc_dump'res [Rpc_portmapper_aux] | |
| t_PMAP'V2'pmapproc_getport'arg [Rpc_portmapper_aux] | |
| t_PMAP'V2'pmapproc_getport'res [Rpc_portmapper_aux] | |
| t_PMAP'V2'pmapproc_null'arg [Rpc_portmapper_aux] | |
| t_PMAP'V2'pmapproc_null'res [Rpc_portmapper_aux] | |
| t_PMAP'V2'pmapproc_set'arg [Rpc_portmapper_aux] | |
| t_PMAP'V2'pmapproc_set'res [Rpc_portmapper_aux] | |
| t_PMAP'V2'pmapproc_unset'arg [Rpc_portmapper_aux] | |
| t_PMAP'V2'pmapproc_unset'res [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_callit'arg [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_callit'res [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_dump'arg [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_dump'res [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_getaddr'arg [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_getaddr'res [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_gettime'arg [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_gettime'res [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_null'arg [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_null'res [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_set'arg [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_set'res [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_taddr2uaddr'arg [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_taddr2uaddr'res [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_uaddr2taddr'arg [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_uaddr2taddr'res [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_unset'arg [Rpc_portmapper_aux] | |
| t_PMAP'V3'rpcbproc_unset'res [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_bcast'arg [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_bcast'res [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_dump'arg [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_dump'res [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_getaddr'arg [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_getaddr'res [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_getaddrlist'arg [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_getaddrlist'res [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_getstat'arg [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_getstat'res [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_gettime'arg [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_gettime'res [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_getversaddr'arg [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_getversaddr'res [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_indirect'arg [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_indirect'res [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_null'arg [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_null'res [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_set'arg [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_set'res [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_taddr2uaddr'arg [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_taddr2uaddr'res [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_uaddr2taddr'arg [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_uaddr2taddr'res [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_unset'arg [Rpc_portmapper_aux] | |
| t_PMAP'V4'rpcbproc_unset'res [Rpc_portmapper_aux] | |
| t_descr [Netmcore_hashtbl] | The marshallable descriptor of a shared hash table | 
| table_row [Netcgi_modtpl] | |
| tag_class [Netasn1.Value] | |
| tbuffer [Netsys_types] | A tagged buffer. | 
| telnet_command [Nettelnet_client] | A  | 
| telnet_connector [Nettelnet_client] | Connectors:  | 
| telnet_negotiated_option [Nettelnet_client] | 
 | 
| telnet_option_state [Nettelnet_client] | An option has one of three states:  | 
| telnet_options [Nettelnet_client] | 
 | 
| test_flag [Netfs] | |
| test_type [Netfs] | Tests:  | 
| text_data_repr [Netftp_data_endpoint] | Possible representation of text data:
  | 
| thread_sys_id [Netplex_types] | A system-specific identifier of the thread/process | 
| time [Netsys_gssapi] | |
| time_subtype [Netasn1.Value] | |
| time_value [Netasn1.Value] | |
| timer [Netplex_cenv] | A timer | 
| timer_expiration [Netsys_posix] | |
| timespec [Netsys_posix] | 
 | 
| tls_config [Netsys_crypto_types] | |
| tls_endpoint [Netsys_crypto_types] | |
| tls_mode [Netldap] | Options:  | 
| tls_provider [Netsys_crypto_types] | |
| token [Netsys_gssapi] | Authentication tokens. | 
| transfer_coding [Nethttpd_kernel] | |
| transmission_mode [Netftp_client] | The transmission mode selects how the data are encoded in the data connection. | 
| transmission_mode [Netftp_data_endpoint] | The transmission mode as described in RFC 959. | 
| transport_layer_id [Nethttp] | |
| transport_layer_id [Nethttp_client] | The ID identifies a requirement for the transport channel, especially whether plain HTTP is sufficient, or HTTPS needs to be used, and if so, whether there are further requirements for the TLS context. | 
| transport_layer_id [Nethttp_client_conncache] | Same as in  | 
| tstring [Netsys_types] | A tagged string which is considered as immutable. | 
| tstring_box [Netstring_tstring] | GADT for hiding the type parameter | 
| tstring_kind [Netstring_tstring] | GADT for encoding the string type (string/bytes/bigarray) | 
| tstring_ops [Netstring_tstring] | Operations to call on strings | 
| tstring_ops_box [Netstring_tstring] | GADT for hiding the type parameter | 
| tstring_polybox [Netstring_tstring] | GADT for hiding the type parameter. | 
| type_name [Netasn1.Type_name] | |
| U | |
| uaddr [Rpc_portmapper_aux] | |
| uint4 [Netnumber] | 32 bit unsigned integer | 
| uint8 [Netnumber] | 64 bit unsigned integer | 
| unicode_lexbuf [Netulex.ULB] | |
| uri_distributor [Nethttpd_services] | Describes that services are bound to URI prefixes. | 
| url [Neturl] | Values of type  | 
| url_syntax [Neturl] | Values of type  | 
| url_syntax_option [Neturl] | |
| user_name_format [Rpc_auth_gssapi] | What to return as user name:  | 
| user_name_format [Rpc_auth_sys] | How  | 
| user_name_interpretation [Rpc_auth_gssapi] | |
| V | |
| valid_glob_expr [Netglob] | A validated  | 
| value [Netasn1.Value] | |
| var [Netplex_sharedvar.VV_TYPE] | |
| var [Netcgi_modtpl] | |
| variable [Netsys_global] | |
| verbosity [Rpc_util] | How verbose the RPC ftrace is:  | 
| versioned_value [Netplex_sharedvar] | Cache for the current value | 
| W | |
| w32_console_attr [Netsys_win32] | |
| w32_console_info [Netsys_win32] | |
| w32_console_mode [Netsys_win32] | See the msdn docs for GetConsoleMode for details | 
| w32_event [Netsys_win32] | |
| w32_input_thread [Netsys_win32] | |
| w32_object [Netsys_win32] | |
| w32_output_thread [Netsys_win32] | |
| w32_pipe [Netsys_win32] | A pipe endpoint | 
| w32_pipe_server [Netsys_win32] | A pipe server. | 
| w32_process [Netsys_win32] | A handle to spawned processes | 
| wait_entry [Netmcore_condition] | Each process that wants to  | 
| wait_entry_e [Netmcore_condition] | A special kind of  | 
| wait_id [Unixqueue] | A wait identifier is used to distinguish between several
 timers, see type  | 
| wait_set [Netmcore_condition] | A set of  | 
| watched_subprocess [Netsys_posix] | |
| wd_spec [Netsys_posix] | |
| with_cursor_fun [Netconversion] | Helper type for  | 
| with_fun [Netstring_tstring] | A polymorphic function for strings | 
| workaround [Netcgi1_compat.Netcgi_env] | The  | 
| write_common [Netfs] | The intersection of  | 
| write_file_flag [Netfs] | |
| write_file_flag [Nethttp_fs] | |
| write_flag [Netfs] | |
| write_flag [Nethttp_fs] | |
| write_op [Netshm] | |
| X | |
| x509_private_key [Netsys_crypto_types.PUBKEY_CRYPTO] | 
 | 
| xdr_type [Netxdr] | This is the validated version of  | 
| xdr_type_system [Netxdr] | A validated type system. | 
| xdr_type_term [Netxdr] | |
| xdr_type_term_system [Netxdr] | Bind names to types. | 
| xdr_value [Netxdr] | |
| xdr_value_version [Netxdr] | Selects which version of  | 
| xmap_value [Nethtml] |