Index

A

addr.family (instruction) address (type)

address::Equal (operator) address::family (method) assign (instruction)

B

begin (instruction) bitset.clear (instruction) bitset.has (instruction) bitset.set (instruction) block.end (instruction) bool (type) bool.and (instruction) bool.not (instruction) bool.or (instruction) bool_::Equal (operator) bool_::LogicalAnd (operator) bool_::LogicalOr (operator) bool_::Not (operator) bytes (type) bytes.append (instruction) bytes.append_mark (instruction) bytes.append_object (instruction) bytes.at_mark (instruction) bytes.at_object (instruction) bytes.cmp (instruction) bytes.concat (instruction) bytes.contains (instruction) bytes.copy (instruction) bytes.diff (instruction) bytes.empty (instruction) bytes.find (instruction) bytes.freeze (instruction) bytes.index (instruction) bytes.is_frozen (instruction) bytes.join (instruction) bytes.length (instruction) bytes.lower (instruction)

bytes.next_mark (instruction) bytes.next_object (instruction) bytes.offset (instruction) bytes.retrieve_object (instruction) bytes.skip_object (instruction) bytes.split (instruction) bytes.split1 (instruction) bytes.startswith (instruction) bytes.strip (instruction) bytes.sub (instruction) bytes.to_int (instruction) bytes.to_uint (instruction) bytes.trim (instruction) bytes.unfreeze (instruction) bytes.upper (instruction) bytes::begin (method) bytes::decode (method) bytes::end (method) bytes::Equal (operator) bytes::join (method) bytes::lower (method) bytes::match (method) bytes::Plus (operator) bytes::PlusAssign (operator) bytes::Size (operator) bytes::split (method) bytes::split1 (method) bytes::startswith (method) bytes::strip (method) bytes::to_int (method), [1] bytes::to_time (method), [1] bytes::to_uint (method), [1] bytes::upper (method)

C

caddr.function (instruction) call (instruction) channel.read (instruction) channel.read_try (instruction) channel.size (instruction) channel.write (instruction)

channel.write_try (instruction) classifier.add (instruction) classifier.compile (instruction) classifier.get (instruction) classifier.matches (instruction) clear (instruction) clone (instruction)

D

debug.assert (instruction) debug.internal_error (instruction) debug.msg (instruction) debug.pop_indent (instruction) debug.push_indent (instruction) decr (instruction) decr_by (instruction) deref (instruction) dispatch (instruction) double (type) double.add (instruction) double.as_interval (instruction) double.as_sint (instruction) double.as_time (instruction) double.as_uint (instruction) double.div (instruction) double.eq (instruction) double.geq (instruction)

double.gt (instruction) double.leq (instruction) double.lt (instruction) double.mod (instruction) double.mul (instruction) double.pow (instruction) double.sub (instruction) double_::Cast (operator) double_::Coerce (operator) double_::Div (operator) double_::Equal (operator) double_::Greater (operator) double_::Lower (operator) double_::Minus (operator) double_::Mod (operator) double_::Mult (operator) double_::Plus (operator) double_::Power (operator)

E

end (instruction) enum (type) enum.from_int (instruction) enum.to_int (instruction) enum_::Call (operator) enum_::Cast (operator) enum_::Coerce (operator)

enum_::Equal (operator) equal (instruction) exception.__begin_handler (instruction) exception.__clear (instruction) exception.__end_handler (instruction) exception.__get_and_clear (instruction) exception.throw (instruction)

F

file.close (instruction) file.open (instruction)

file.write (instruction) function (type) function::Call (operator)

H

hash (instruction) hook.disable_group (instruction) hook.enable_group (instruction)

hook.group_enabled (instruction) hook.run (instruction) hook.stop (instruction)

I

if.else (instruction) incr (instruction) incr_by (instruction) int.add (instruction) int.and (instruction) int.as_interval (instruction) int.as_sdouble (instruction) int.as_time (instruction) int.as_udouble (instruction) int.ashr (instruction) int.div (instruction) int.eq (instruction) int.flip (instruction) int.from_host (instruction) int.mask (instruction) int.mod (instruction) int.mul (instruction) int.or (instruction) int.pow (instruction) int.sext (instruction) int.sgeq (instruction) int.sgt (instruction) int.shl (instruction) int.shr (instruction) int.sleq (instruction) int.slt (instruction) int.sub (instruction) int.to_host (instruction) int.trunc (instruction) int.ugeq (instruction) int.ugt (instruction) int.uleq (instruction) int.ult (instruction) int.xor (instruction) int.zext (instruction) integer (type) integer::BitAnd (operator) integer::BitOr (operator) integer::BitXor (operator) integer::Cast (operator), [1], [2] integer::Coerce (operator), [1], [2], [3] integer::Div (operator)

integer::Equal (operator) integer::Greater (operator) integer::Lower (operator) integer::Minus (operator) integer::MinusAssign (operator) integer::Mod (operator) integer::Mult (operator) integer::Plus (operator) integer::PlusAssign (operator) integer::Power (operator) integer::ShiftLeft (operator) integer::ShiftRight (operator) interval (type) interval.add (instruction) interval.as_double (instruction) interval.as_int (instruction) interval.eq (instruction) interval.from_double (instruction) interval.geq (instruction) interval.gt (instruction) interval.leq (instruction) interval.lt (instruction) interval.mul (instruction) interval.nsecs (instruction) interval.sub (instruction) interval::Cast (operator), [1] interval::Coerce (operator) interval::Equal (operator) interval::Greater (operator) interval::Lower (operator) interval::Minus (operator) interval::Mult (operator), [1] interval::nsecs (method) interval::Plus (operator) iosrc.close (instruction) iosrc.read (instruction) iterator (type) iterator::Deref (operator) iterator::Equal (operator) iterator::IncrPostfix (operator) iterator::IncrPrefix (operator) iterator::Plus (operator) iterator::PlusAssign (operator)

J

jump (instruction)

L

list (type) list.append (instruction) list.back (instruction) list.erase (instruction) list.front (instruction) list.insert (instruction) list.pop_back (instruction)

list.pop_front (instruction) list.push_back (instruction) list.push_front (instruction) list.size (instruction) list.timeout (instruction) list::PlusAssign (operator) list::push_back (method) list::Size (operator)

M

map (type) map.clear (instruction) map.default (instruction) map.exists (instruction) map.get (instruction) map.get_default (instruction) map.insert (instruction) map.remove (instruction)

map.size (instruction) map.timeout (instruction) map::clear (method) map::Delete (operator) map::get (method) map::In (operator) map::Index (operator) map::IndexAssign (operator) map::Size (operator)

N

net.contains (instruction) net.family (instruction)

net.length (instruction) net.prefix (instruction) new (instruction)

O

overlay.attach (instruction)

overlay.get (instruction)

P

pack (instruction)

port.protocol (instruction)

R

regexp.compile (instruction) regexp.find (instruction) regexp.groups (instruction) regexp.match_token (instruction)

regexp.match_token_advance (instruction) regexp.match_token_init (instruction) regexp.span (instruction) return.result (instruction) return.void (instruction)

S

set (type) set.clear (instruction) set.exists (instruction) set.insert (instruction) set.remove (instruction) set.size (instruction) set.timeout (instruction) set::Add (operator) set::clear (method) set::Delete (operator) set::In (operator) set::Size (operator) sink (type) sink::add_filter (method) sink::close (method) sink::connect (method) sink::connect_mime_type (method), [1] sink::gap (method) sink::New (operator) sink::sequence (method) sink::set_auto_trim (method) sink::set_initial_sequence_number (method) sink::set_policy (method) sink::Size (operator)

sink::skip (method) sink::trim (method) sink::try_connect_mime_type (method), [1] sink::write (method) spicy::AddrFamily (type) spicy::base64_decode (function) spicy::base64_encode (function) spicy::ByteOrder (type) spicy::Filter (type) string.cmp (instruction) string.concat (instruction) string.decode (instruction) string.encode (instruction) string.find (instruction) string.join (instruction) string.length (instruction) string.lt (instruction) string.substr (instruction) struct.get (instruction) struct.get_default (instruction) struct.is_set (instruction) struct.set (instruction) struct.unset (instruction) switch (instruction)

T

thread.get_context (instruction) thread.id (instruction) thread.schedule (instruction) thread.set_context (instruction) time (type) time.add (instruction) time.as_double (instruction) time.as_int (instruction) time.eq (instruction) time.from_double (instruction) time.geq (instruction) time.gt (instruction) time.leq (instruction) time.lt (instruction) time.nsecs (instruction) time.sub (instruction) time.wall (instruction) time::Cast (operator), [1] time::Coerce (operator)

time::Equal (operator) time::Greater (operator) time::Lower (operator) time::Minus (operator), [1] time::nsecs (method) time::Plus (operator), [1] timer.cancel (instruction) timer.update (instruction) timer_mgr.advance (instruction) timer_mgr.advance_global (instruction) timer_mgr.current (instruction) timer_mgr.expire (instruction) timer_mgr.schedule (instruction) tuple (type) tuple.index (instruction) tuple.length (instruction) tuple::Coerce (operator) tuple::Equal (operator) tuple::Index (operator)

U

unequal (instruction) unit (type) unit::add_filter (method) unit::Attribute (operator) unit::AttributeAssign (operator) unit::backtrack (method) unit::confirm (method) unit::disable (method)

unit::disconnect (method) unit::HasAttribute (operator) unit::input (method) unit::mime_type (method) unit::New (operator) unit::offset (method) unit::set_position (method) unit::TryAttribute (operator) unpack (instruction)

V

vector (type) vector.exists (instruction) vector.get (instruction) vector.push_back (instruction) vector.reserve (instruction) vector.set (instruction)

vector.size (instruction) vector.timeout (instruction) vector::Index (operator) vector::IndexAssign (operator) vector::push_back (method) vector::reserve (method) vector::Size (operator)

Y

yield (instruction)

yield.until (instruction)