Felix library Index
Accept
win32/faio_win32.flx:58: proc Accept(success: &bool, listener: SOCKET, accepted: SOCKET)
Addgrp
algebraic.flx:30: class Addgrp[t]
AnsiTerminal
io/ansi_terminal.flx:3: class AnsiTerminal
ArrayObject
datatype/array_class.fdoc:263: class ArrayObject[t,v]
ArrayValue
datatype/array_class.fdoc:14: class ArrayValue[t,v]
Avl
datatype/avl.flx:1: class Avl
BLUE
io/ansi_terminal.flx:17: proc BLUE(s:string)
io/ansi_terminal.flx:16: proc BLUE()
BLUE_
io/ansi_terminal.flx:15: fun BLUE_(s:string)
io/ansi_terminal.flx:14: fun BLUE_()
Base64
codec/base64.flx:4: class Base64
Bash
posix/shell.flx:64: class Bash
Bidirectional
order.flx:58: class Bidirectional[t]
Bits
algebraic.flx:95: class Bits[t]
BootFlx
felix/flx/bootflx.flx:29: class BootFlx
C89_headers
c_headers.flx:4: class C89_headers
C95_headers
c_headers.flx:24: class C95_headers
C99_headers
c_headers.flx:33: class C99_headers
CYAN
io/ansi_terminal.flx:25: proc CYAN(s:string)
io/ansi_terminal.flx:24: proc CYAN()
CYAN_
io/ansi_terminal.flx:23: fun CYAN_(s:string)
io/ansi_terminal.flx:22: fun CYAN_()
C_hack
c_hack.flx:6: class C_hack
CartComplex
scalar/float_math.flx:85: class CartComplex[r]
Check
posix/errno.flx:54: class Check[T]
CheckRewriteString
strings/re2.flx:160: fun CheckRewriteString: RE2 * StringPiece * &string -> bool
Checked_ZeroMQ
io/zmq.flx:380: class Checked_ZeroMQ[T]
Cident
felix/cident.flx:5: class Cident
CloseFile
win32/faio_win32.flx:121: proc CloseFile: WFILE
CmdExe
win32/shell.flx:36: class CmdExe
Collector
felix/flx_gc.fdoc:4: class Collector
Complex
algebraic.flx:208: class Complex[t,r]
Config
felix/config.flx:6: class Config
Connect
win32/faio_win32.flx:78: proc Connect(s: &SOCKET, addr: +char, port: int, err: &int)
win32/faio_win32.flx:70: proc Connect(s: SOCKET, addr: +char, port: int, err: &int)
Container
flx_tclass.flx:56: class Container [c,v]
ContiguousArrayObject
datatype/array_class.fdoc:324: class ContiguousArrayObject[t,v]
Copy
strings/re2.flx:65: proc Copy: RE2Options * RE2Options
CopyFiles
felix/flx_cp.flx:1: class CopyFiles
Csv
codec/csv.flx:3: class Csv
Cxx11_headers
cxx_headers.flx:59: class Cxx11_headers // http://en.cppreference.com/w/cpp/header
CxxCompiler
felix/flx_cxx.flx:1: class CxxCompiler
Cxx_headers
cxx_headers.flx:1: class Cxx_headers
Debug
debug.flx:5: class Debug
DefaultValue
datatype/option.flx:99: class DefaultValue[T]
Demux
io/demux.flx:2: class Demux
Directory
io/directory.flx:34: class Directory
Directory_class
io/directory.flx:3: class Directory_class[os,mode_t]
Dring
algebraic.flx:88: class Dring[t]
Dynlink
program/dynlink.fdoc:58: class Dynlink
Env
program/env.flx:27: class Env
Env_class
program/env.flx:2: class Env_class[os]
Eq
order.flx:3: class Eq[t]
Extract
strings/re2.flx:132: gen Extract: StringPiece * RE2 * StringPiece * &string -> bool
Faio
io/faio.flx:1: class Faio
Faio_posix
posix/faio_posix.flx:1: class Faio_posix
FileStat
io/filestat.flx:126: class FileStat
FileStat_class
io/filestat.flx:3: class FileStat_class[OS,stat_t, mode_t]
FileSystem
io/filesystem.flx:8: class FileSystem
FileSystem_class
io/filesystem.flx:3: class FileSystem_class[os]
Filename
io/filename.flx:157: class Filename
Filename_class
io/filename.flx:2: class Filename_class[os]
FloatAddgrp
algebraic.flx:4: class FloatAddgrp[t]
FloatDring
algebraic.flx:72: class FloatDring[t]
FloatMultSemi1
algebraic.flx:38: class FloatMultSemi1[t]
FloatRing
algebraic.flx:59: class FloatRing[t]
Flx
felix/flx/flx.flx:21: class Flx
FlxCache
felix/flx_cache.flx:1: class FlxCache
FlxCmdOpt
felix/flx/flx_cmdopt.flx:6: class FlxCmdOpt
FlxConfig
felix/flx/flx_config.flx:3: class FlxConfig
FlxControl
felix/flx/flx_control.flx:1: class FlxControl
FlxDepvars
felix/flx/flx_depvars.flx:3: class FlxDepvars
FlxPkg
felix/flx_pkg.flx:3: class FlxPkg
FlxPkgConfig
felix/flx_pkgconfig.flx:5: class FlxPkgConfig
FlxPkgConfigQuery_interface
felix/flx_pkgconfig_query_interface.flx:1: class FlxPkgConfigQuery_interface
FlxPkgConfig_core
felix/flx_pkgconfig_core.flx:2: class FlxPkgConfig_core
FlxPkgConfig_query
felix/flx_pkgconfig_query.flx:4: class FlxPkgConfig_query
FlxProfile
felix/flx_profile.flx:1: class FlxProfile
Flx_client
felix/flx/flx_plugin_client.flx:1: class Flx_client
Flxg
felix/flx_flxg.flx:1: class Flxg
Forward
order.flx:52: class Forward[t]
GREEN
io/ansi_terminal.flx:33: proc GREEN(s:string)
io/ansi_terminal.flx:32: proc GREEN()
GREEN_
io/ansi_terminal.flx:31: fun GREEN_(s:string)
io/ansi_terminal.flx:30: fun GREEN_()
GetLastError
win32/faio_win32.flx:29: fun GetLastError: 1 -> int
GlobalReplace
strings/re2.flx:131: gen GlobalReplace: &string * RE2 * StringPiece -> int
IBuffer
flx_tclass.flx:35: class IBuffer [f]
IByteStream
io/stream.flx:18: class IByteStream[T]
IFile
flx_tclass.flx:24: class IFile[f,t]
IOByteStream
io/stream.flx:30: class IOByteStream[T]
IOStream
flx_tclass.flx:17: class IOStream[f,t]
IStream
flx_tclass.flx:9: class IStream[f,t]
Input_text_file
io/textio.flx:7: class Input_text_file[input_text_file]
Integer
algebraic.flx:112: class Integer[t]
Judy
datatype/judy.flx:8: class Judy
Judy1ByCount
datatype/judy.flx:88: proc Judy1ByCount: J1Array * word * &word * &JError_t * &word
Judy1Count
datatype/judy.flx:85: proc Judy1Count: J1Array * word * word* &JError_t * &word
Judy1First
datatype/judy.flx:96: proc Judy1First: J1Array * &word * &JError_t * &int
Judy1FirstEmpty
datatype/judy.flx:108: proc Judy1FirstEmpty: J1Array * &word * &JError_t * &int
Judy1FreeArray
datatype/judy.flx:91: proc Judy1FreeArray: J1Array * &JError_t * &word
Judy1Last
datatype/judy.flx:102: proc Judy1Last: J1Array * &word * &JError_t * &int
Judy1LastEmpty
datatype/judy.flx:114: proc Judy1LastEmpty: J1Array * &word * &JError_t * &int
Judy1MemUsed
datatype/judy.flx:94: proc Judy1MemUsed: J1Array * &word
Judy1Next
datatype/judy.flx:99: proc Judy1Next: J1Array * &word * &JError_t * &int
Judy1NextEmpty
datatype/judy.flx:111: proc Judy1NextEmpty: J1Array * &word * &JError_t * &int
Judy1Prev
datatype/judy.flx:105: proc Judy1Prev: J1Array * &word * &JError_t * &int
Judy1PrevEmpty
datatype/judy.flx:117: proc Judy1PrevEmpty: J1Array * &word * &JError_t * &int
Judy1Set
datatype/judy.flx:68: proc Judy1Set: J1Array * word * &JError_t * &int
Judy1Test
datatype/judy.flx:74: proc Judy1Test: J1Array * word * &JError_t * &int
Judy1Unset
datatype/judy.flx:71: proc Judy1Unset: J1Array * word * &JError_t * &int
JudyHSDel
datatype/judy.flx:266: proc JudyHSDel: JHSArray * address * word * &JError_t * &int
JudyHSGet
datatype/judy.flx:269: proc JudyHSGet: JHSArray * address * word * &JError_t * &&word
JudyHSIns
datatype/judy.flx:263: proc JudyHSIns: JHSArray * address * word * &JError_t * &&word
JudyLByCount
datatype/judy.flx:160: proc JudyLByCount: JLArray * word * &word * &JError_t * &&word
JudyLCount
datatype/judy.flx:157: proc JudyLCount: JLArray * word * word * &JError_t * &word
JudyLDel
datatype/judy.flx:151: proc JudyLDel: JLArray * word * &JError_t * &int
JudyLFirst
datatype/judy.flx:169: proc JudyLFirst: JLArray * &word * &JError_t * &&word
JudyLFirstEmpty
datatype/judy.flx:181: proc JudyLFirstEmpty: JLArray * &word * &JError_t * &word
JudyLFreeArray
datatype/judy.flx:163: proc JudyLFreeArray: JLArray * &JError_t * &word
JudyLGet
datatype/judy.flx:154: proc JudyLGet: JLArray * word * &JError_t * &&word
JudyLIns
datatype/judy.flx:148: proc JudyLIns: JLArray * word * &JError_t * &&word
JudyLLast
datatype/judy.flx:175: proc JudyLLast: JLArray * &word * &JError_t * &&word
JudyLLastEmpty
datatype/judy.flx:187: proc JudyLLastEmpty: JLArray * &word * &JError_t * &word
JudyLMemUsed
datatype/judy.flx:166: proc JudyLMemUsed: JLArray * &word
JudyLNext
datatype/judy.flx:172: proc JudyLNext: JLArray * &word * &JError_t * &&word
JudyLNextEmpty
datatype/judy.flx:184: proc JudyLNextEmpty: JLArray * &word * &JError_t * &word
JudyLPrev
datatype/judy.flx:178: proc JudyLPrev: JLArray * &word * &JError_t * &&word
JudyLPrevEmpty
datatype/judy.flx:190: proc JudyLPrevEmpty: JLArray * &word * &JError_t * &word
JudySLDel
datatype/judy.flx:232: proc JudySLDel: JSLArray * +char * &JError_t * &int
JudySLFirst
datatype/judy.flx:238: proc JudySLFirst: JSLArray * +char * &JError_t * &&word
JudySLGet
datatype/judy.flx:235: proc JudySLGet: JSLArray * +char * &JError_t * &&word
JudySLIns
datatype/judy.flx:226: proc JudySLIns: JSLArray * +char * &JError_t * &&word
JudySLLast
datatype/judy.flx:244: proc JudySLLast: JSLArray * +char * &JError_t * &&word
JudySLNext
datatype/judy.flx:241: proc JudySLNext: JSLArray * +char * &JError_t * &&word
JudySLPrev
datatype/judy.flx:247: proc JudySLPrev: JSLArray * +char * &JError_t * &&word
Lexer
strings/lexer.flx:1: class Lexer
ManyMouse
io/manymouse.flx:1: class ManyMouse
ManyMouse_DeviceName
io/manymouse.flx:29: fun ManyMouse_DeviceName: uint -> string
ManyMouse_DriverName
io/manymouse.flx:25: fun ManyMouse_DriverName: 1 -> string
ManyMouse_Init
io/manymouse.flx:24: gen ManyMouse_Init: 1 -> int
ManyMouse_PollEvent
io/manymouse.flx:32: gen ManyMouse_PollEvent: &ManyMouseEvent -> int
ManyMouse_Quit
io/manymouse.flx:28: proc ManyMouse_Quit: 1
Match
strings/re2.flx:145: noinline gen Match(re:RE2, var s:string) : opt[varray[string]]
strings/re2.flx:141: gen Match: RE2 * StringPiece * int * Anchor * +StringPiece * int -> bool
Mmap
posix/mmap.flx:1: class Mmap
Monad
flx_tclass.flx:65: class Monad [M: TYPE->TYPE]
MultSemi1
algebraic.flx:52: class MultSemi1[t]
NC
io/ansi_terminal.flx:9: proc NC(s:string)
io/ansi_terminal.flx:8: proc NC()
NC_
io/ansi_terminal.flx:7: fun NC_(s:string)
io/ansi_terminal.flx:6: fun NC_ ()
NamedCapturingGroups
strings/re2.flx:138: fun NamedCapturingGroups: RE2 -> Stl_Map::stl_map[string, int]
NumberOfCapturingGroups
strings/re2.flx:137: fun NumberOfCapturingGroups: RE2 -> int
OBuffer
flx_tclass.flx:39: class OBuffer [f]
OByteStream
io/stream.flx:24: class OByteStream[T]
OFile
flx_tclass.flx:28: class OFile[f,t]
OStream
flx_tclass.flx:13: class OStream[f,t]
OpenFile
win32/faio_win32.flx:111: gen OpenFile: string -> WFILE
OpenFileDuplex
win32/faio_win32.flx:116: gen OpenFileDuplex: string -> WFILE
OsxFilename
io/filename.flx:126: class OsxFilename
Output_text_file
io/textio.flx:30: class Output_text_file[output_text_file]
ParseFlags
strings/re2.flx:100: fun ParseFlags: RE2Options -> int
PkgTool
felix/pkgtool/pkgtool_base.flx:218: class PkgTool
Pord
order.flx:16: class Pord[t]
PosixDirectory
posix/directory.flx:1: class PosixDirectory
PosixFileStat
posix/filestat.flx:1: class PosixFileStat
PosixFileSystem
posix/filesystem.flx:1: class PosixFileSystem
PosixFilename
io/filename.flx:142: class PosixFilename
PosixProcess
posix/process.flx:1: class PosixProcess
PosixSignal
posix/signal.flx:1: class PosixSignal
PosixTime
posix/time.flx:1: class PosixTime
Posix_headers
posix/posix_headers.flx:1: class Posix_headers
PossibleMatchRange
strings/re2.flx:136: fun PossibleMatchRange: RE2 * &string * &string * int -> bool
Process
program/process.flx:9: class Process
Process_class
program/process.flx:3: class Process_class[os, process_status_t]
ProgramSize
strings/re2.flx:129: fun ProgramSize: RE2 -> int
Quaternion
scalar/quaternion.flx:1: class Quaternion
QuoteMeta
strings/re2.flx:134: fun QuoteMeta: StringPiece -> string
RED
io/ansi_terminal.flx:41: proc RED(s:string)
io/ansi_terminal.flx:40: proc RED()
RED_
io/ansi_terminal.flx:39: fun RED_(s:string)
io/ansi_terminal.flx:38: fun RED_()
Ralist
datatype/ralist.flx:9: class Ralist
Raw_C
rawc.flx:17: class Raw_C
ReadFile
win32/faio_win32.flx:187: proc ReadFile(f: WFILE, len: &int, buf: address, eof: &bool)
Real
algebraic.flx:193: class Real[t]
Regdef
strings/regdef.flx:1: class Regdef
Repr
flx_tclass.flx:76: class Repr [T with Str[T]]
RespectfulParser
strings/string.fdoc:380: class RespectfulParser
ReuseSocket
win32/faio_win32.flx:145: proc ReuseSocket(s: SOCKET)
Ring
algebraic.flx:65: class Ring[t]
Rtti
felix/rtti.flx:1: class Rtti
S_expr
datatype/sexpr.fdoc:5: class S_expr
Serialise
felix/serialise.fdoc:4: class Serialise
Set
flx_tclass.flx:50: class Set[c,t]
SetupTool
felix/pkgtool/pkgtool_base.flx:1260: class SetupTool
Shell
program/shell.flx:86: class Shell
Shell_class
program/shell.flx:4: class Shell_class[OS, process_status_t]
Show
flx_tclass.flx:80: class Show [T]
Signal
program/signal.flx:15: class Signal
Signal_class
program/signal.flx:8: class Signal_class [os]
Signed_integer
algebraic.flx:124: class Signed_integer[t]
Smaps
linux/smaps.flx:17: class Smaps
Socket
io/socket.flx:1: class Socket
Sort
datatype/sort.flx:2: class Sort
Special
algebraic.flx:187: class Special[t]
Sqlite3
db/sqlite3/sqlite3.flx:39: class Sqlite3
Sqlite3Pool
db/sqlite3/sqlite3_pool.flx:3: class Sqlite3Pool
Str
flx_tclass.flx:72: class Str [T]
StrDict
datatype/strdict.flx:14: class StrDict[T]
Stream
io/stream.flx:1: class Stream
StringPiece
strings/re2.flx:38: ctor StringPiece: unit
strings/re2.flx:37: ctor StringPiece: string
SyncControl
felix/sync.flx:1: class SyncControl
System
program/system.flx:1: class System
TerminalIByteStream
io/stream.flx:36: class TerminalIByteStream[T]
TerminalIOByteStream
io/stream.flx:52: class TerminalIOByteStream[T]
TerminalOByteStream
io/stream.flx:44: class TerminalOByteStream[T]
Time_class
time.flx:1: class Time_class [os]
Tord
order.flx:28: class Tord[t]
TransmitFile
win32/faio_win32.flx:131: proc TransmitFile(s: SOCKET, f: WFILE)
Tre
strings/tre.flx:1: class Tre
Trig
algebraic.flx:137: class Trig[t]
TrueArrayObject
datatype/array_class.fdoc:303: class TrueArrayObject[t,x, v]
TrueArrayValue
datatype/array_class.fdoc:249: class TrueArrayValue [t,x,v]
TrueContiguousArrayObject
datatype/array_class.fdoc:371: class TrueContiguousArrayObject[t,x, v]
Tuple
datatype/tuple.flx:5: class Tuple[U]
URICodec
codec/uri_codec.flx:15: class URICodec
Unsigned_integer
algebraic.flx:131: class Unsigned_integer[t]
WCOREDUMP
win32/process.flx:28: fun WCOREDUMP: process_status_t -> int
posix/process.flx:26: fun WCOREDUMP: process_status_t -> int
WEXITSTATUS
win32/process.flx:23: fun WEXITSTATUS: process_status_t -> int
posix/process.flx:21: fun WEXITSTATUS: process_status_t -> int
felix/pkgtool/pkgtool_base.flx:388: fun WEXITSTATUS(x:process_status_t)
WIFCONTINUED
win32/process.flx:18: fun WIFCONTINUED: process_status_t -> bool
posix/process.flx:16: fun WIFCONTINUED: process_status_t -> bool
WIFEXITED
win32/process.flx:19: fun WIFEXITED: process_status_t -> bool
posix/process.flx:17: fun WIFEXITED: process_status_t -> bool
felix/pkgtool/pkgtool_base.flx:387: fun WIFEXITED(x:process_status_t)
WIFSIGNALED
win32/process.flx:20: fun WIFSIGNALED: process_status_t -> bool
posix/process.flx:18: fun WIFSIGNALED: process_status_t -> bool
WIFSTOPPED
win32/process.flx:21: fun WIFSTOPPED: process_status_t -> bool
posix/process.flx:19: fun WIFSTOPPED: process_status_t -> bool
WSARecv
win32/faio_win32.flx:157: proc WSARecv(s: SOCKET, len: &int, buf: address, eof: &bool)
WSASend
win32/faio_win32.flx:169: proc WSASend(s: SOCKET, len: &int, buf: address, eof: &bool)
WSTOPSIG
win32/process.flx:25: fun WSTOPSIG: process_status_t -> signal_t
posix/process.flx:23: fun WSTOPSIG: process_status_t -> signal_t
WTERMSIG
win32/process.flx:24: fun WTERMSIG: process_status_t -> signal_t
posix/process.flx:22: fun WTERMSIG: process_status_t -> signal_t
Win32Directory
win32/directory.flx:1: class Win32Directory
Win32FileStat
win32/filestat.flx:1: class Win32FileStat
Win32FileSystem
win32/filesystem.flx:1: class Win32FileSystem
Win32Filename
io/filename.flx:107: class Win32Filename
Win32Process
win32/process.flx:1: class Win32Process
Win32Signal
win32/signal.flx:1: class Win32Signal
Win32Time
win32/time.flx:1: class Win32Time
Win32_headers
win32/win32_headers.flx:1: class Win32_headers
WriteFile
win32/faio_win32.flx:195: proc WriteFile(f: WFILE, len: &int, buf: address, eof: &bool)
YELLOW
io/ansi_terminal.flx:49: proc YELLOW(s:string)
io/ansi_terminal.flx:48: proc YELLOW()
YELLOW_
io/ansi_terminal.flx:47: fun YELLOW_(s:string)
io/ansi_terminal.flx:46: fun YELLOW_()
ZMQ
io/zmq.flx:489: class ZMQ
ZeroMQ
io/zmq.flx:6: class ZeroMQ
abort
program/system.flx:21: gen abort: 1 -> any
abs
scalar/int.flx:249: fun abs: t -> t
scalar/float_math.flx:76: fun abs: t -> t
scalar/float_math.flx:36: fun abs: complex[t] -> t
algebraic.flx:214: virtual fun abs: t -> r
algebraic.flx:200: virtual fun abs: t -> t
algebraic.flx:127: virtual fun abs: t -> t
accept
posix/faio_posix.flx:249: proc accept(s: &socket_t, listener: socket_t)
io/socket.flx:19: proc accept(l: socket_t, s: &socket_t)
acos
scalar/float_math.flx:61: fun acos: t -> t
algebraic.flx:155: virtual fun acos: t -> t
acosh
scalar/float_math.flx:67: fun acosh: t -> t
algebraic.flx:173: virtual fun acosh: t -> t
acot
algebraic.flx:160: virtual fun acot (x:t)
acoth
algebraic.flx:178: virtual fun acoth (x:t)
acsc
algebraic.flx:159: virtual fun acsc (x:t)
acsch
algebraic.flx:177: virtual fun acsch (x:t)
add
strings/tre.flx:29: fun add: +char * regoff_t -> +char
datatype/strdict.flx:23: proc add (x:strdict) (key:string) (value: T)
codec/csv.flx:10: proc add(j:int)
algebraic.flx:20: fun add(x:t,y:t)
add_pointer
felix/serialise.fdoc:94: proc add_pointer (self: &pclosure) (p:address)
add_root
gc.flx:32: proc add_root: address
add_symbol
program/dynlink.fdoc:186: noinline proc add_symbol (modulename:string, symbolname:string, adr:address)
add_val
felix/flx_pkgconfig_core.flx:253: proc add_val(v:string)
add_worker_task
control/pthread.flx:20: proc add_worker_task : job_queue * worker_task
addfile
felix/flx_cp.flx:13: proc addfile(f:string)
address
datatype/judy.flx:21: ctor address: word
adjust_all_pointers
felix/serialise.fdoc:256: proc adjust_all_pointers (newhead:address)
adjust_pointer
felix/serialise.fdoc:237: proc adjust_pointer (pptr:&address)
aio_creat
posix/faio_posix.flx:185: gen aio_creat: string * posix_permissions-> FileSystem::posix_file
aio_ropen
posix/faio_posix.flx:179: gen aio_ropen: string -> FileSystem::posix_file
aio_rwopen
posix/faio_posix.flx:183: gen aio_rwopen: string -> FileSystem::posix_file
aio_wopen
posix/faio_posix.flx:181: gen aio_wopen: string -> FileSystem::posix_file
all_but_first
datatype/avl.flx:132: fun all_but_first[T] : avl[T]->avl[T]
all_but_last
datatype/avl.flx:120: fun all_but_last[T] : avl[T]->avl[T]
allocated_bytes
felix/flx_gc.fdoc:26: fun allocated_bytes (pd: pointer_data_t)
append_unique
datatype/list.fdoc:523: noinline fun append_unique[T] (eq: T * T -> bool) (x:list[T]) (e:T) : list[T]
apply
strings/string.fdoc:74: fun apply (x:string, y:int):string
strings/string.fdoc:73: fun apply (x:string, y:string):string
strings/re2.flx:158: gen apply (re:RE2, s:string)
datatype/array_class.fdoc:57: fun apply [I in ints] (i:I, x:t)
control/future.fdoc:141: fun apply[T] (x:future[T], a:unit)
carray.flx:51: fun apply [T,I in ints] (i:I, x:carray[T])
arg
scalar/float_math.flx:37: fun arg : complex[t] -> t
algebraic.flx:215: virtual fun arg: t -> r
args
program/system.flx:9: fun args ()
argv
program/system.flx:6: fun argv:int -> string
argv_dflt
program/system.flx:7: fun argv_dflt (x:int) (y:string)
array_alloc
carray.flx:30: fun array_alloc[T]: !ints -> carray[T]
array_calloc
carray.flx:34: fun array_calloc[T]: !ints -> carray[T]
array_of
carray.flx:102: fun array_of[T,N]: carray[T] -> &array[T,N]
asec
algebraic.flx:158: virtual fun asec (x:t)
asech
algebraic.flx:176: virtual fun asech (x:t)
asin
scalar/float_math.flx:60: fun asin: t -> t
algebraic.flx:154: virtual fun asin: t -> t
asinh
scalar/float_math.flx:66: fun asinh: t -> t
algebraic.flx:172: virtual fun asinh: t -> t
assert_true
felix/pkgtool/pkgtool_base.flx:307: proc assert_true(result:bool)
felix/pkgtool/pkgtool_base.flx:304: proc assert_true(result:bool,name:string)
felix/pkgtool/pkgtool_base.flx:299: noinline proc assert_true(result:bool,name:string,fail_message:string)
associate_with_iocp
win32/faio_win32.flx:211: proc associate_with_iocp(s: SOCKET)
async_read
posix/faio_posix.flx:209: proc async_read(fd: socket_t, len: &int, buf: address,
async_rw
posix/faio_posix.flx:198: proc async_rw(fd: socket_t, len: &int, buf: address, eof: &bool, read_flag: bool)
async_write
posix/faio_posix.flx:215: proc async_write(fd: socket_t, len: &int, buf: address, eof: &bool)
atan
scalar/float_math.flx:62: fun atan: t -> t
algebraic.flx:156: virtual fun atan: t -> t
atanh
scalar/float_math.flx:68: fun atanh: t -> t
algebraic.flx:174: virtual fun atanh: t -> t
atof
strings/string.fdoc:679: fun atof: string -> double
atoi
strings/string.fdoc:676: fun atoi: string -> int
atol
strings/string.fdoc:677: fun atol: string -> long
atoll
strings/string.fdoc:678: fun atoll: string -> long
aux
strings/string.fdoc:359: fun aux (x:string,y:List::list[string])
strings/string.fdoc:347: fun aux (x:string,y:List::list[string])
strings/string.fdoc:335: fun aux (x:string,y:List::list[string])
io/filesystem.flx:17: proc aux (d:string) (b:string)
felix/flx_pkgconfig_query.flx:13: fun aux (lst:list[string]) (out:list[string])
datatype/list.fdoc:524: fun aux (inp:list[T], out: list[T])
datatype/list.fdoc:492: fun aux (inp:list[T], out: list[T])
datatype/list.fdoc:318: fun aux (l1: list[T1]) (l2: list[T2]) (acc: list[T1 * T2])
datatype/list.fdoc:299: fun aux (x:list[T]) (y:list[T]) : list[T]
datatype/list.fdoc:272: fun aux (inp:list[T]) (out:list[U]) : list[U]
datatype/list.fdoc:230: fun aux (x:list[T]) (init:U):U
datatype/list.fdoc:216: fun aux (init:U) (x:list[T]):U
datatype/list.fdoc:184: fun aux (acc:size) (x:list[T])
datatype/list.fdoc:156: fun aux (l:list[T])
datatype/avl.flx:194: proc aux (depth:int, f:int*T->void, tree:avl[T])
bad_socket
posix/faio_posix.flx:175: fun bad_socket : socket_t -> bool
band
algebraic.flx:106: fun band(x:t,y:t)
basename
io/filename.flx:57: fun basename(s:string)
felix/cident.flx:10: fun basename : string -> string
basic_get_stdout
program/shell.flx:36: gen basic_get_stdout (cmd: string) : int * string
basic_system
program/shell.flx:33: gen basic_system (cmd: string) :int
bind
io/zmq.flx:445: proc bind(x:zmq_socket) (a:string)
flx_tclass.flx:66: virtual fun bind[a,b]: M a * (a -> M b) -> M b
bind_proc
program/dynlink.fdoc:614: fun bind_proc: flx_instance * address * address -> cont
blit
felix/serialise.fdoc:11: fun blit[T] (p: &T)
blue
io/ansi_terminal.flx:13: proc blue(s:string)
io/ansi_terminal.flx:12: proc blue()
blue_
io/ansi_terminal.flx:11: fun blue_(s:string)
io/ansi_terminal.flx:10: fun blue_()
bnot
algebraic.flx:107: fun bnot(x:t)
bor
algebraic.flx:105: fun bor(x:t,y:t)
bounds
strings/lexer.flx:6: fun bounds (x:string): lex_iterator * lex_iterator
broadcast
control/schannels.flx:89: proc broadcast[T] (chan:oschannel[T], v:T)
control/schannels.flx:80: proc broadcast[T] (chan:schannel[T], v:T)
control/condition_variable.flx:26: proc broadcast: condition_variable
build
felix/pkgtool/pkgtool_base.flx:794: virtual proc build()
bxor
algebraic.flx:104: fun bxor(x:t,y:t)
bytes_per_element
felix/rtti.flx:31: fun bytes_per_element: gc_shape_t -> size
c_depcheck
felix/flx/flx_depchk.flx:47: gen c_depcheck (tc: toolchain_t, src:string, dst:string) : bool
cache_join
felix/flx_cache.flx:199: fun cache_join (c:string, var f:string)
cal_cxx_uptodate
felix/flx/flx_run.flx:164: fun cal_cxx_uptodate(debugln:string -> 0, OUTPUT_DIR:string, f:string)
cal_depvars
felix/flx/flx_depvars.flx:21: gen cal_depvars(
cal_files_time
felix/flx/flx_run.flx:151: fun cal_files_time (fs: list[string])
cal_slice
datatype/slice.flx:30: fun cal_slice (n:int, var b:int, var e:int)
cal_time_from_flxdepfile
felix/flx/flx_run.flx:137: fun cal_time_from_flxdepfile (debugln: string->0, df: string):double
calc_eof
io/faio.flx:23: proc calc_eof(pb: sel_param_ptr, len: &int, eof: &bool)
calloc
rawc.flx:26: proc calloc:size
calpackages
felix/flx/flx_run.flx:106: proc calpackages
cascade_FLX_HOME_DIR
felix/config.flx:61: proc cascade_FLX_HOME_DIR (x: &config_type) (y: string)
cascade_FLX_INSTALL_DIR
felix/config.flx:47: proc cascade_FLX_INSTALL_DIR (x: &config_type) (y: string)
cascade_FLX_SHARE_DIR
felix/config.flx:57: proc cascade_FLX_SHARE_DIR (x: &config_type) (y: string)
cascade_FLX_TARGET_DIR
felix/config.flx:52: proc cascade_FLX_TARGET_DIR (x: &config_type) (y: string)
case_sensitive
strings/re2.flx:88: fun case_sensitive: RE2Options -> bool
cast
c_hack.flx:24: fun cast[dst,src]: src->dst
cat
io/stream.flx:181: proc cat[istr,ostr with IByteStream[istr], OByteStream[ostr]] (
io/stream.flx:167: proc cat[istr,ostr with IByteStream[istr], OByteStream[ostr]] (
io/stream.flx:148: proc cat[istr,ostr with IByteStream[istr], OByteStream[ostr]] (
datatype/list.fdoc:408: noinline fun cat[T] (x:list[list[T]]):list[T]
catmap
datatype/list.fdoc:434: fun catmap[T] (sep:string) (f:T -> string) (ls: list[T])
ceil
scalar/float_math.flx:79: fun ceil: t -> t
algebraic.flx:202: virtual fun ceil: t -> t
chain
control/fibres.flx:34: proc chain : cont
char
strings/string.fdoc:79: ctor char (x:string)
charp_first
datatype/strdict.flx:209: gen charp_first (x:strdict) (buffer:+char)
charp_get_ge
datatype/strdict.flx:77: gen charp_get_ge (x:strdict) (var key: +char) : opt[T]
charp_get_gt
datatype/strdict.flx:110: gen charp_get_gt (x:strdict) (var key: +char)
charp_get_le
datatype/strdict.flx:143: gen charp_get_le (x:strdict) (var key: +char)
charp_get_lt
datatype/strdict.flx:176: gen charp_get_lt (x:strdict) (var key: +char)
check_binary_uptodate
felix/flx/flx_run.flx:562: gen check_binary_uptodate () : bool
check_cache
felix/flx/flx_run.flx:32: proc check_cache(
check_cxx_uptodate
felix/flx/flx_run.flx:182: gen check_cxx_uptodate () : bool
check_dependencies
felix/pkgtool/pkgtool_base.flx:714: noinline proc check_dependencies()
check_id
felix/flx_pkgconfig_core.flx:227: fun check_id (s:string)
check_output_if_required
felix/flx/flx_run.flx:713: gen check_output_if_required () : int
check_pkgconfig_path
felix/pkgtool/pkgtool_base.flx:371: noinline proc check_pkgconfig_path (unit)
check_run_if_required_and_uptodate
felix/flx/flx_run.flx:398: gen check_run_if_required_and_uptodate() : bool
check_socket
io/zmq.flx:440: fun check_socket(var x:zmq_socket)
checkpid
win32/process.flx:129: gen checkpid(pid:pid_t)
posix/process.flx:159: gen checkpid(pid:pid_t)
chmod
win32/filestat.flx:57: gen chmod: string * mode_t -> int
posix/filestat.flx:71: gen chmod: string * mode_t -> int
io/filestat.flx:18: virtual gen chmod: string * mode_t -> int
chop_extension
felix/cident.flx:15: fun chop_extension : string -> string
clean
felix/pkgtool/pkgtool_base.flx:1079: virtual proc clean()
clean_flx
felix/pkgtool/pkgtool_base.flx:1017: proc clean_flx(file:string)
close
win32/filesystem.flx:41: gen close: posix_file -> int
posix/filesystem.flx:41: gen close: posix_file -> int
posix/faio_posix.flx:173: proc close: socket_t
io/zmq.flx:447: proc close (s:zmq_socket)
io/zmq.flx:386: proc close (x:zmq_msg_t)
flx_tclass.flx:30: virtual proc close: f
closedir
posix/directory.flx:10: proc closedir: DIR_t
closesocket
win32/faio_win32.flx:95: proc closesocket: SOCKET
cmdopt-parse-result_t
program/cmdopt.flx:144: ctor cmdopt-parse-result_t ()
cmk_listener
win32/faio_win32.flx:85: proc cmk_listener: &SOCKET*&int*int
cmk_socket
win32/faio_win32.flx:34: fun cmk_socket : unit -> SOCKET
cmp
io/stream.flx:240: proc cmp[istr1, istr2 with IByteStream[istr1], IByteStream[istr2]] (
cname
felix/rtti.flx:24: fun cname: gc_shape_t -> +char
collect
gc.flx:10: proc collect()
complex
scalar/float_math.flx:103: ctor complex[ldouble] (x:ldouble)
scalar/float_math.flx:102: ctor complex[double] (x:double)
scalar/float_math.flx:101: ctor complex[float] (x:float)
scalar/float_math.flx:99: ctor complex[ldouble] (x:ldouble, y:ldouble)
scalar/float_math.flx:98: ctor complex[double] (x:double, y:double)
scalar/float_math.flx:97: ctor complex[float] (x:float, y:float)
compose
categ.flx:41: fun compose[u,v,w] (f:v->w, g:u->v) : u -> w
concurrently
control/forkjoin.flx:28: proc concurrently[T with Streamable[T,1->0]] (d:T)
concurrently_by_iterator
control/forkjoin.flx:6: proc concurrently_by_iterator (var it:1 -> opt[1->0])
condition_variable
control/condition_variable.flx:10: ctor condition_variable: 1
config
felix/config.flx:110: fun config () : config_type
conj
scalar/quaternion.flx:26: fun conj (a:q):q
connect
posix/faio_posix.flx:232: proc connect(s: &socket_t, addr: +char, port: int, err: &int)
io/zmq.flx:446: proc connect(x:zmq_socket) (a:string)
io/socket.flx:42: proc connect(s: &socket_t, addr: +char, port: int, err: &int)
const_cast
c_hack.flx:33: fun const_cast[dst,src]: src->dst
cont
felix/sync.flx:38: ctor cont: (1->0)
copy
datatype/list.fdoc:104: fun copy[T] (x:list[T]):list[T]
datatype/array.flx:9: fun copy[T,N] (var x:array[T,N])
control/mux.flx:6: noinline proc copy[T] (i:ischannel[T],o:oschannel[T]) ()
copy_last
datatype/list.fdoc:115: proc copy_last[T] (inp:list[T], out:&list[T], last:&list[T])
copyfiles
felix/flx_cp.flx:107: proc copyfiles(basedir:string, re:string, tpat:string, live:bool, verbose:bool)
felix/flx_cp.flx:103: proc copyfiles(basedir:string, re:RE2, tpat:string, live:bool, verbose:bool)
copyfrom
strings/string.fdoc:91: fun copyfrom: string * !ints -> string
copyto
strings/string.fdoc:93: fun copyto: string * !ints -> string
cos
scalar/float_math.flx:58: fun cos: t -> t
algebraic.flx:147: virtual fun cos: t -> t
cosh
scalar/float_math.flx:64: fun cosh: t -> t
algebraic.flx:165: virtual fun cosh: t -> t
cot
algebraic.flx:152: virtual fun cot (x:t)
coth
algebraic.flx:170: virtual fun coth (x:t)
cp_root
felix/pkgtool/pkgtool_base.flx:357: noinline proc cp_root(s:string,p:string,dest:string)
felix/pkgtool/pkgtool_base.flx:352: noinline proc cp_root(s:string,p:string)
creat
win32/filesystem.flx:39: gen creat: string * Win32FileStat::mode_t-> posix_file
posix/filesystem.flx:39: gen creat: string * PosixFileStat::mode_t-> posix_file
create
program/dynlink.fdoc:300: proc create: flx_library * flx_instance
create_config
felix/pkgtool/pkgtool_base.flx:558: noinline proc create_config(name:string,includes:list[string],libs:list[string],
felix/pkgtool/pkgtool_base.flx:550: noinline proc create_config(name:string,includes:list[string],libs:list[string],
create_empty_varray
felix/serialise.fdoc:163: gen create_empty_varray : gc_shape_t * size -> address
create_fpc
felix/pkgtool/pkgtool_base.flx:519: noinline proc create_fpc(name:string,description:string,ccflags:list[string],includes:list[string],
create_instance_handle
program/dynlink.fdoc:287: fun create_instance_handle: bool->flx_instance
create_library_handle
program/dynlink.fdoc:102: fun create_library_handle: bool ->flx_library
create_objects
felix/serialise.fdoc:206: gen create_objects () : address
create_popen_command
program/shell.flx:28: fun create_popen_command (s:list[string]) : string
create_system_command
program/shell.flx:25: fun create_system_command (s:list[string]) : string
create_with_args
program/dynlink.fdoc:310: proc create_with_args (lib:flx_library, inst:flx_instance, args:list[string])
program/dynlink.fdoc:305: proc create_with_args: flx_library * flx_instance * int * + +char
csc
algebraic.flx:151: virtual fun csc (x:t)
csch
algebraic.flx:169: virtual fun csch (x:t)
cstr
strings/string.fdoc:696: fun cstr (x:string) : +char
ctime
io/filestat.flx:56: fun ctime: &stat_t -> double
ction
datatype/array_class.fdoc:40: virtual function so that the default definitions
cube
algebraic.flx:43: fun cube(x:t)
current_continuation
control/control.flx:58: fun current_continuation: unit -> cont
curry
categ.flx:16: fun curry[u,v,w,r] (f:u*v*w->r) : u -> v -> w -> r
categ.flx:13: fun curry[u,v,r] (f:u*v->r) : u -> v -> r
cvt-key-arg
program/cmdopt.flx:5: noinline fun cvt-key-arg (keys: list[string * string]) (x:list[string])
cxx_compile_dynamic
felix/flx/flx_run.flx:288: gen cxx_compile_dynamic () : int
cxx_compile_dynamic1
felix/flx/flx_run.flx:264: gen cxx_compile_dynamic1(src:string, dst:string) : int
cxx_compile_static
felix/flx/flx_run.flx:311: gen cxx_compile_static () : int
cxx_compile_static1
felix/flx/flx_run.flx:356: gen cxx_compile_static1 (src: string, dst: string) : int
cxx_depcheck
felix/flx/flx_depchk.flx:3: gen cxx_depcheck (tc: toolchain_t, src:string, dst:string) : bool
cxx_link_dynamic
felix/flx/flx_run.flx:436: gen cxx_link_dynamic () : int
cxx_link_dynamic_with_calpackages
felix/flx/flx_run.flx:472: gen cxx_link_dynamic_with_calpackages () : int
cxx_link_static
felix/flx/flx_run.flx:478: gen cxx_link_static () : int
cxx_link_static_with_calpackages
felix/flx/flx_run.flx:518: gen cxx_link_static_with_calpackages() : int
cxx_static_library
felix/flx/flx_run.flx:524: gen cxx_static_library () : int
cyan
io/ansi_terminal.flx:21: proc cyan(s:string)
io/ansi_terminal.flx:20: proc cyan()
cyan_
io/ansi_terminal.flx:19: fun cyan_(s:string)
io/ansi_terminal.flx:18: fun cyan_()
data
strings/re2.flx:41: fun data: StringPiece -> +char
debugln
felix/flx/flx_run.flx:58: proc debugln[T with Str[T]] (x:T)
felix/flx/flx_depvars.flx:29: proc debugln[T with Str[T]] (x:T)
felix/flx/flx_cmdopt.flx:636: proc debugln[T with Str[T]] (x:T)
felix/flx/flx_cmdopt.flx:544: proc debugln[T with Str[T]] (x:T)
felix/flx/flx_cmdopt.flx:185: proc debugln[T with Str[T]] (x:T)
decode
codec/base64.flx:83: fun decode(enc_str:string)
decode_pointer_closure
felix/serialise.fdoc:197: gen decode_pointer_closure (ss:string) : address
decode_varray
felix/serialise.fdoc:173: gen decode_varray (ss:string) : address
decoder
felix/rtti.flx:40: fun decoder: gc_shape_t -> gc_decoder_t
decr_pos
control/ts_counter.flx:10: gen decr_pos: ts_counter -> long
default
datatype/option.flx:100: virtual fun default[T]: 1->T
default_build
felix/pkgtool/pkgtool_base.flx:730: noinline proc default_build()
default_clean
felix/pkgtool/pkgtool_base.flx:1014: noinline proc default_clean()
default_install
felix/pkgtool/pkgtool_base.flx:841: noinline proc default_install()
default_run_flx
felix/pkgtool/pkgtool_base.flx:430: fun default_run_flx(file:string,on_error:string)
default_test
felix/pkgtool/pkgtool_base.flx:804: noinline proc default_test()
degitify
felix/pkgtool/pkgtool_base.flx:1214: noinline proc degitify(dir:string)
felix/pkgtool/pkgtool_base.flx:1209: noinline proc degitify()
del
datatype/strdict.flx:68: gen del (x:strdict) (key: string) : bool
datatype/sarray.flx:48: proc del[T] (a:sarray[T], i:size)
delete
program/dynlink.fdoc:83: proc delete : cptr[flx_link_failure_t]
felix/sync.flx:50: proc delete: scheduler
felix/sync.flx:32: proc delete : fthread_list
delete_fibre_scheduler
control/fibres.flx:44: proc delete_fibre_scheduler : fibre_scheduler
dequeue
control/ts_bound_queue.flx:16: gen dequeue[T] (Q:ts_bound_queue_t[T]): T
deref
strings/lexer.flx:18: fun deref: lex_iterator -> char
cptr.flx:30: fun deref[T] (px:cptr[T])
destroy
semaphore.flx:7: proc destroy : semaphore
control/ts_counter.flx:5: proc destroy : ts_counter
control/mutex.flx:10: proc destroy: mutex
control/condition_variable.flx:13: proc destroy: condition_variable
c_hack.flx:97: proc destroy[T] : &T
destroy_member
db/sqlite3/sqlite3_pool.flx:24: proc destroy_member (m:sqlite3_db_t)
dfiletime
io/filestat.flx:114: fun dfiletime(var f:string, dflt:double)
dflt
c_hack.flx:74: fun dflt[t]:1->t
dflt_control
felix/flx/flx_control.flx:50: fun dflt_control (config:Config::config_type)
dflt_profile
felix/flx_profile.flx:3: fun dflt_profile ()
directories
io/filename.flx:64: fun directories (s:string) : list[string]
dirname
io/filename.flx:60: fun dirname(s:string)
display
felix/pkgtool/pkgtool_base.flx:481: proc display(message:string)
felix/pkgtool/pkgtool_base.flx:477: proc display(message:string,log_file:string)
div
algebraic.flx:79: fun div(x:t, y:t)
diveq
algebraic.flx:83: proc diveq(px:&t, y:t)
dlclose
program/dynlink.fdoc:229: proc dlclose:flx_library
dlib_of
program/dynlink.fdoc:619: fun dlib_of : flx_library -> address
dlopen
program/dynlink.fdoc:111: proc dlopen:flx_library * string
dlsym_err
program/dynlink.fdoc:623: proc dlsym_err:flx_library*string
do_resize
datatype/darray.fdoc:81: proc do_resize[T] (pd: darray[T], new_size: size)
drop
datatype/list.fdoc:549: fun drop[T] (k:int) (lst:list[T]) : list[T]
dump_litterbox
felix/pkgtool/pkgtool_base.flx:935: noinline fun dump_litterbox()
dup
win32/filesystem.flx:45: gen dup: posix_file -> posix_file
posix/filesystem.flx:45: gen dup: posix_file -> posix_file
dup2
win32/filesystem.flx:46: gen dup2: posix_file * posix_file -> posix_file
posix/filesystem.flx:46: gen dup2: posix_file * posix_file -> posix_file
dxqt
felix/flx/flx_run.flx:5: gen dxqt(DBG:bool) (cmd:string)
dynamic_cast
c_hack.flx:30: fun dynamic_cast[dst,src]: src->dst
dynamic_library_extension
io/filename.flx:151: fun dynamic_library_extension()
io/filename.flx:135: fun dynamic_library_extension()
io/filename.flx:116: fun dynamic_library_extension()
io/filename.flx:12: virtual fun dynamic_library_extension: 1 -> string
dynamic_object_extension
io/filename.flx:149: fun dynamic_object_extension()
io/filename.flx:133: fun dynamic_object_extension()
io/filename.flx:114: fun dynamic_object_extension()
io/filename.flx:10: virtual fun dynamic_object_extension: 1 -> string
echo
io/stream.flx:254: proc echo[iostr with IOByteStream[iostr]] (
echoln
felix/flx/flx_run.flx:62: proc echoln[T with Str[T]] (x:T)
edure
program/dynlink.fdoc:340: procedure.
eendl
io/textio.flx:225: proc eendl()
ehandler
posix/errno.flx:70: fun ehandler ():any
posix/errno.flx:65: fun ehandler ():any
posix/errno.flx:59: virtual fun ehandler: unit -> any
io/zmq.flx:482: fun ehandler():any
embed
scalar/float_math.flx:82: fun embed: int -> t
algebraic.flx:197: virtual fun embed: int -> t
empty
flx_tclass.flx:60: virtual fun empty(x: c): bool
empty_config
felix/config.flx:33: fun empty_config() :config_type
encode
codec/base64.flx:31: fun encode (inp:string, iOff:int, iLen:int) : string
codec/base64.flx:29: fun encode (inp:string)
encode_closure
felix/serialise.fdoc:152: fun encode_closure (alst:list[address]) : string
encode_pointer_closure
felix/serialise.fdoc:159: fun encode_pointer_closure (p:address)
encode_varray
felix/serialise.fdoc:23: fun encode_varray (p:address) : string
encoder
felix/rtti.flx:37: fun encoder : gc_shape_t -> gc_encoder_t
encoding
strings/re2.flx:67: fun encoding: RE2Options -> Encoding
end_iterator
strings/lexer.flx:5: fun end_iterator: string -> lex_iterator
endcol
debug.flx:16: fun endcol: flx_location_t -> int
endl
io/textio.flx:210: proc endl()
io/textio.flx:77: proc endl (s:output_text_file)
endline
debug.flx:15: fun endline: flx_location_t -> int
endswith
strings/string.fdoc:246: fun endswith (x:string) (e:char) : bool
strings/string.fdoc:243: fun endswith (x:string) (e:string) : bool
enqueue
control/ts_bound_queue.flx:13: proc enqueue[T] (Q:ts_bound_queue_t[T]) (elt:T)
eprint
io/textio.flx:219: proc eprint [T with Str[T]] (x:T)
eprintln
io/textio.flx:222: proc eprintln[T with Str[T]] (x:T)
eq
win32/faio_win32.flx:55: fun eq : SOCKET*SOCKET -> bool
order.flx:11: fun eq(x:t, y:t)
codec/csv.flx:13: fun eq(a:state_t, b:state_t)
c_hack.flx:47: fun eq[T]: gcptr[T] * gcptr[T] -> bool
eral_fail
felix/pkgtool/pkgtool_base.flx:989: general_fail(msg)
felix/pkgtool/pkgtool_base.flx:662: general_fail(msg)
felix/pkgtool/pkgtool_base.flx:572: general_fail("Unable to find " + inc +
felix/pkgtool/pkgtool_base.flx:543: general_fail("Failed creating "+fpc_name)
felix/pkgtool/pkgtool_base.flx:162: general_fail$ "HOME environment variable is not set. Please set HOME before building."
erase
strings/string.fdoc:574: fun erase: string * int * int -> string
strings/string.fdoc:569: proc erase: &string * int * int
datatype/varray.flx:168: proc erase[v] (a:varray[v], i:int)
datatype/varray.flx:148: proc erase[v] (a:varray[v], first:int, last:int)
datatype/darray.fdoc:174: proc erase[t] (a:darray[t], first:int, last:int)
datatype/darray.fdoc:170: proc erase[t] (a:darray[t], i:int)
eration
program/dynlink.fdoc:221: generation, it is very hard to ensure there are no references
erf
algebraic.flx:188: virtual fun erf: t -> t
erfc
algebraic.flx:189: virtual fun erfc: t -> t
errno_t
posix/errno.flx:5: ctor errno_t : int
error
strings/re2.flx:125: fun error: RE2 -> string
error_arg
strings/re2.flx:127: fun error_arg: RE2 -> string
error_code
strings/re2.flx:126: fun error_code: RE2 -> ErrorCode
espace
io/textio.flx:228: proc espace()
ess_config_text
felix/config.flx:148: process_config_text &cfg text
essed
felix/serialise.fdoc:85: processed: J1Array
essfiles
felix/flx_cp.flx:104: processfiles (FileSystem::filecopy) (basedir, re, tpat, live, verbose)
ewrap
io/zmq.flx:37: gen ewrap(var x:int)
exec
control/spipe.flx:81: noinline proc exec (var k:size, chi:ischannel[T]) ()
executable_extension
io/filename.flx:147: fun executable_extension ()
io/filename.flx:131: fun executable_extension ()
io/filename.flx:112: fun executable_extension ()
io/filename.flx:8: virtual fun executable_extension : 1 -> string
execv
win32/process.flx:49: gen execv:+char * + +char -> exec_result_t
posix/process.flx:47: gen execv:+char * + +char -> exec_result_t
execve
win32/process.flx:51: gen execve:+char * + +char * + +char -> exec_result_t
posix/process.flx:49: gen execve:+char * + +char * + +char -> exec_result_t
execvp
win32/process.flx:50: gen execvp:+char * + +char -> exec_result_t
posix/process.flx:48: gen execvp:+char * + +char -> exec_result_t
exit
program/system.flx:20: gen exit: int -> any
exp
scalar/float_math.flx:69: fun exp: t -> t
algebraic.flx:181: virtual fun exp: t -> t
extract
strings/re2.flx:197: fun extract (re2:RE2, target:string) : opt[varray[string]]
strings/re2.flx:196: fun extract (re2:string, target:string) : opt[varray[string]]
fail
control/control.flx:48: proc fail:string
faio_read
posix/faio_posix.flx:271: proc faio_read(fd: FileSystem::posix_file, len: &int, buf: address,
faio_req
io/faio.flx:7: proc faio_req[t](x:&t)
faio_rw
posix/faio_posix.flx:263: proc faio_rw(q:job_queue, fd: FileSystem::posix_file, len: &int, buf: address, eof: &bool, read_flag: bool)
faio_write
posix/faio_posix.flx:279: proc faio_write(fd: FileSystem::posix_file, len: &int, buf: address, eof: &bool)
fclose
io/textio.flx:184: proc fclose: ostream
io/textio.flx:173: proc fclose: istream
io/textio.flx:135: proc fclose: ofile
io/textio.flx:124: proc fclose: ifile
io/textio.flx:39: virtual proc fclose: output_text_file
io/textio.flx:16: virtual proc fclose: input_text_file
fdopen_input
win32/filesystem.flx:62: gen fdopen_input: posix_file -> ifile
posix/filesystem.flx:62: gen fdopen_input: posix_file -> ifile
fdopen_output
win32/filesystem.flx:63: gen fdopen_output: posix_file -> ofile
posix/filesystem.flx:63: gen fdopen_output: posix_file -> ofile
feof
io/textio.flx:176: gen feof : istream -> bool
io/textio.flx:127: gen feof : ifile -> bool
io/textio.flx:26: virtual gen feof : input_text_file -> bool
fflush
io/textio.flx:216: proc fflush()
io/textio.flx:189: proc fflush: ostream
io/textio.flx:140: proc fflush: ofile
io/textio.flx:54: virtual proc fflush: output_text_file
fibre_scheduler
control/fibres.flx:41: ctor fibre_scheduler: 1
field
datatype/tuple.flx:103: fun field[n,t,u,v,w,x where n
datatype/tuple.flx:102: fun field[n,t,u,v,w,x where n
datatype/tuple.flx:101: fun field[n,t,u,v,w,x where n
datatype/tuple.flx:100: fun field[n,t,u,v,w,x where n
datatype/tuple.flx:99: fun field[n,t,u,v,w,x where n
datatype/tuple.flx:97: fun field[n,t,u,v,w where n
datatype/tuple.flx:96: fun field[n,t,u,v,w where n
datatype/tuple.flx:95: fun field[n,t,u,v,w where n
datatype/tuple.flx:94: fun field[n,t,u,v,w where n
datatype/tuple.flx:92: fun field[n,t,u,v where n
datatype/tuple.flx:91: fun field[n,t,u,v where n
datatype/tuple.flx:90: fun field[n,t,u,v where n
datatype/tuple.flx:88: fun field[n,t,u where n
datatype/tuple.flx:87: fun field[n,t,u where n
file_perm
win32/filestat.flx:34: fun file_perm(m:mode_t)
posix/filestat.flx:48: fun file_perm(m:mode_t)
file_type
win32/filestat.flx:60: fun file_type (s:&stat_t): file_type_t
win32/filestat.flx:33: fun file_type(m:mode_t)
posix/filestat.flx:74: fun file_type (s:&stat_t): file_type_t
posix/filestat.flx:47: fun file_type(m:mode_t)
io/filestat.flx:40: virtual fun file_type: &stat_t -> file_type_t
filecopy
win32/filesystem.flx:79: gen filecopy(src: string, dst: string) : bool
posix/filesystem.flx:81: gen filecopy(src: string, dst: string) : bool
fileexists
io/filestat.flx:80: fun fileexists(f:string):bool
filename
win32/directory.flx:13: fun filename : FINDDATA_t -> string
program/dynlink.fdoc:325: fun filename : flx_instance -> string
program/dynlink.fdoc:175: fun filename : flx_library -> string
program/dynlink.fdoc:78: fun filename : flx_link_failure_t -> string
posix/directory.flx:11: fun filename: dirent_t -> string
debug.flx:12: fun filename: flx_location_t -> +char
filename_to_modulename
felix/cident.flx:25: fun filename_to_modulename : string -> string
filesin
win32/directory.flx:62: fun filesin(dname:string): opt[list[string]]
posix/directory.flx:43: fun filesin(dname:string): opt[List::list[string]]
io/directory.flx:23: virtual fun filesin:string -> opt[List::list[string]]
filetime
io/filestat.flx:60: fun filetime(f:string):double
filetype
io/filestat.flx:83: fun filetype(f:string):file_type_t
filter
datatype/option.flx:83: fun filter[T] (P:T -> bool) (x:opt[T]) : opt[T]
datatype/list.fdoc:490: noinline fun filter[T] (P:T -> bool) (x:list[T]) : list[T]
finaliser
felix/rtti.flx:34: fun finaliser: gc_shape_t -> gc_finaliser_t
find
strings/string.fdoc:140: fun find (s:string, e:char, i:int) : opt[int]
strings/string.fdoc:139: fun find (s:string, e:char) : opt[int]
strings/string.fdoc:138: fun find (s:string, e:+char, i:int) : opt[int]
strings/string.fdoc:137: fun find (s:string, e:+char) : opt[int]
strings/string.fdoc:136: fun find (s:string, e:string, i:int) : opt[int]
strings/string.fdoc:135: fun find (s:string, e:string) : opt[int]
datatype/list.fdoc:485: fun find[T, U] (eq:T * U -> bool) (xs:list[T]) (e:U) : opt[T]
datatype/list.fdoc:474: fun find[T] (eq:T -> bool) (xs:list[T]) : opt[T]
datatype/avl.flx:99: fun find[T] (tree : avl[T], y : T, cmp : T*T->int) : opt[T]
datatype/assoc_list.fdoc:42: fun find[A,B with Eq[A]] (xs:assoc_list[A,B]) (e:A) : opt[B]
datatype/assoc_list.fdoc:38: fun find[A,B,T] (eq:A * T -> bool) (xs:assoc_list[A,B]) (e:T) : opt[B]
datatype/assoc_list.fdoc:29: fun find[A,B] (eq:A -> bool) (xs:assoc_list[A,B]) : opt[B]
datatype/array_class.fdoc:218: virtual fun find (rel:v*v->bool) (x:t) (e:v): opt[v]
datatype/array_class.fdoc:201: virtual fun find(pred:v->bool) (x:t): opt[v]
find_closure
felix/serialise.fdoc:125: fun find_closure (p:address) : list[address]
find_first_not_of
strings/string.fdoc:182: fun find_first_not_of (s:string, e:char, i:int) : opt[int]
strings/string.fdoc:181: fun find_first_not_of (s:string, e:char) : opt[int]
strings/string.fdoc:180: fun find_first_not_of (s:string, e:+char, i:int) : opt[int]
strings/string.fdoc:179: fun find_first_not_of (s:string, e:+char) : opt[int]
strings/string.fdoc:178: fun find_first_not_of (s:string, e:string, i:int) : opt[int]
strings/string.fdoc:177: fun find_first_not_of (s:string, e:string) : opt[int]
find_first_of
strings/string.fdoc:168: fun find_first_of (s:string, e:char, i:int) : opt[int]
strings/string.fdoc:167: fun find_first_of (s:string, e:char) : opt[int]
strings/string.fdoc:166: fun find_first_of (s:string, e:+char, i:int) : opt[int]
strings/string.fdoc:165: fun find_first_of (s:string, e:+char) : opt[int]
strings/string.fdoc:164: fun find_first_of (s:string, e:string, i:int) : opt[int]
strings/string.fdoc:163: fun find_first_of (s:string, e:string) : opt[int]
find_in_path
io/filesystem.flx:48: fun find_in_path(x:string, path:list[string]):opt[string]
find_last_not_of
strings/string.fdoc:210: fun find_last_not_of (s:string, e:char, i:int) : opt[int]
strings/string.fdoc:209: fun find_last_not_of (s:string, e:char) : opt[int]
strings/string.fdoc:208: fun find_last_not_of (s:string, e:+char, i:int) : opt[int]
strings/string.fdoc:207: fun find_last_not_of (s:string, e:+char) : opt[int]
strings/string.fdoc:206: fun find_last_not_of (s:string, e:string, i:int) : opt[int]
strings/string.fdoc:205: fun find_last_not_of (s:string, e:string) : opt[int]
find_last_of
strings/string.fdoc:196: fun find_last_of (s:string, e:char, i:int) : opt[int]
strings/string.fdoc:195: fun find_last_of (s:string, e:char) : opt[int]
strings/string.fdoc:194: fun find_last_of (s:string, e:+char, i:int) : opt[int]
strings/string.fdoc:193: fun find_last_of (s:string, e:+char) : opt[int]
strings/string.fdoc:192: fun find_last_of (s:string, e:string, i:int) : opt[int]
strings/string.fdoc:191: fun find_last_of (s:string, e:string) : opt[int]
find_path_to
felix/pkgtool/pkgtool_base.flx:506: noinline fun find_path_to(name:string,paths:list[string])
find_pointers
felix/serialise.fdoc:53: fun find_pointers (p:address) : list[address]
find_sym
program/dynlink.fdoc:253: noinline fun find_sym(lib:flx_library, sym:string) : address
findclose
win32/directory.flx:10: proc findclose : DIR_t
findfailed
win32/directory.flx:12: fun findfailed : DIR_t -> bool
findfirst
win32/directory.flx:8: proc findfirst: string * &FINDDATA_t * &DIR_t
findnext
win32/directory.flx:9: proc findnext: DIR_t * &FINDDATA_t * &int
first
datatype/strdict.flx:215: fun first (x:strdict) : opt[string * T]
datatype/avl.flx:127: fun first[T] : avl[T]->T
fix2word_flags
felix/flx_pkg.flx:25: fun fix2word_flags (fs: list[string])
flags
felix/rtti.flx:61: fun flags: gc_shape_t -> gc_shape_flags_t
floor
scalar/float_math.flx:80: fun floor: t -> t
algebraic.flx:203: virtual fun floor: t -> t
flx_dlsym
program/dynlink.fdoc:444: noinline fun flx_dlsym[T] (linst: flx_instance, sym:string)
flx_link_failure_t
program/dynlink.fdoc:75: ctor flx_link_failure_t : string * string * string
flx_pkgconfig
felix/flx_pkgconfig_core.flx:6: gen flx_pkgconfig (args:list[string]) : int * list[string]
flx_processing
felix/flx/flx.flx:23: gen flx_processing
felix/flx/bootflx.flx:31: gen flx_processing
flxid_to_cid
felix/cident.flx:20: fun flxid_to_cid : string -> string
fmt
scalar/float_format.flx:25: fun fmt[t,r with Complex[t,r]] (v:t, m: mode)
scalar/float_format.flx:15: fun fmt[t in reals] (v:t, m: mode)
fmt_default
scalar/float_format.flx:34: fun fmt_default[t] : t * int * int -> string
fmt_fixed
scalar/float_format.flx:37: fun fmt_fixed[t] : t * int * int -> string
fmt_scientific
scalar/float_format.flx:40: fun fmt_scientific[t] : t * int * int -> string
fold
datatype/array_class.fdoc:152: virtual fun fold[u] (_f:u->v->u) (init:u) (x:t): u
fold_left
datatype/sexpr.fdoc:9: fun fold_left[T,U] (_f:U->T->U) (init:U) (x:sexpr[T]):U
datatype/list.fdoc:214: fun fold_left[U] (_f:U->T->U) (init:U) (x:list[T]):U
datatype/avl.flx:162: fun fold_left[T, U] (f:U->T->U) (accumulated:U) (tree:avl[T]):U
datatype/array_class.fdoc:116: virtual fun fold_left[u] (_f:u->v->u) (init:u) (x:t): u
fold_right
datatype/list.fdoc:228: fun fold_right[U] (_f:T->U->U) (x:list[T]) (init:U):U
datatype/avl.flx:170: fun fold_right[T, U] (f:T->U->U) (tree:avl[T]) (accumulated:U)
datatype/array_class.fdoc:132: virtual fun fold_right[u] (_f:v->u->u) (x:t) (init:u): u
fopen_append
felix/pkgtool/pkgtool_base.flx:227: gen fopen_append: string -> ofile
fopen_input
io/textio.flx:171: gen fopen_input: string -> istream
io/textio.flx:122: gen fopen_input: string -> ifile
io/textio.flx:10: virtual gen fopen_input: string -> input_text_file
fopen_output
io/textio.flx:182: gen fopen_output: string -> ostream
io/textio.flx:133: gen fopen_output: string -> ofile
io/textio.flx:33: virtual gen fopen_output: string -> output_text_file
for_each
control/control.flx:17: proc for_each
forever
control/control.flx:5: proc forever (bdy:unit->void)
fork
posix/process.flx:65: gen fork: unit -> pid_t
fprint
io/textio.flx:80: proc fprint[T with Str[T]] (s:output_text_file, x:T)
fprintln
io/textio.flx:83: proc fprintln[T with Str[T]] (s:output_text_file, x:T)
free
rawc.flx:24: proc free:address
datatype/judy.flx:258: proc free: JHSArray
datatype/judy.flx:222: proc free: JSLArray
datatype/judy.flx:145: proc free: JLArray
datatype/judy.flx:66: proc free: J1Array
carray.flx:38: proc free[T]: carray[T]
c_hack.flx:94: proc free: address
fthread
felix/sync.flx:41: ctor fthread: cont
fthread_list
felix/sync.flx:29: ctor fthread_list: 1
func0
program/dynlink.fdoc:480: noinline fun func0[R] (linst: flx_instance, sym:string)
func1
program/dynlink.fdoc:487: noinline fun func1[R,A0] (linst: flx_instance, sym:string)
func2
program/dynlink.fdoc:494: noinline fun func2[R,A0,A1] (linst: flx_instance, sym:string)
future_time
io/filestat.flx:98: fun future_time ()
gc_get_allocation_amt
gc.flx:21: fun gc_get_allocation_amt : unit -> ulong
gc_get_allocation_count
gc.flx:25: fun gc_get_allocation_count : unit -> ulong
gc_get_root_count
gc.flx:29: fun gc_get_root_count : unit -> ulong
ge
order.flx:46: fun ge (x:t,y:t):bool
general_fail
felix/pkgtool/pkgtool_base.flx:278: proc general_fail(s:string)
generic_cxx_compile_for_dynamic
felix/flx_cxx.flx:52: gen generic_cxx_compile_for_dynamic (spec: cxx_dynamic_spec_t) (src:string, dst:string) : int
generic_cxx_compile_for_static
felix/flx_cxx.flx:120: gen generic_cxx_compile_for_static
generic_cxx_gen_deps
felix/flx_cxx.flx:12: gen generic_cxx_gen_deps (spec: cxx_dep_spec_t) (src:string) : int * string
generic_dependency_parser
felix/flx_cxx.flx:32: gen generic_dependency_parser (data:string) : list[string]
generic_link_dynamic
felix/flx_cxx.flx:83: gen generic_link_dynamic
generic_link_static
felix/flx_cxx.flx:155: gen generic_link_static
generic_static_library
felix/flx_cxx.flx:183: gen generic_static_library
get
datatype/strdict.flx:39: fun get (x:strdict) (key: string) : opt[T]
datatype/sarray.flx:16: fun get[T] (a:sarray[T], i:size) : T
datatype/option.flx:67: fun get[T] : opt[T] -> T
datatype/array_class.fdoc:32: fun get[I in ints] (x:t, i:I)
control/ts_counter.flx:11: gen get: ts_counter -> long
carray.flx:47: fun get[T]: carray[T] * !ints -> T
get_bytes_done
io/faio.flx:19: fun get_bytes_done : sel_param_ptr -> int
get_cpu_nr
linux/linux.flx:4: fun get_cpu_nr: 1 -> int
get_csv_value
codec/csv.flx:8: proc get_csv_value(s:string, i:&int,res:&string)
get_csv_values
codec/csv.flx:44: fun get_csv_values(s:string): list[string]
get_ctrl_c_flag
program/signal.flx:9: gen get_ctrl_c_flag: 1 -> bool requires ctrl_c_flag
get_debug_driver_flag
program/dynlink.fdoc:86: fun get_debug_driver_flag : 1 -> bool
get_dflt
datatype/strdict.flx:59: fun get_dflt (x:strdict) (key:string, dflt:T)
get_double_val
db/sqlite3/sqlite3.flx:289: fun get_double_val: column_value->double
get_err
posix/faio_posix.flx:229: fun get_err: async_connect -> int
get_extension
io/filename.flx:102: fun get_extension (s:string)
get_field
felix/flx_pkgconfig_core.flx:233: fun get_field(line:string):string * string
get_ge
datatype/strdict.flx:91: fun get_ge (x:strdict) (var key: string)
get_gt
datatype/strdict.flx:124: fun get_gt (x:strdict) (var key: string)
get_init
program/dynlink.fdoc:351: fun get_init: flx_instance -> cont
get_int_val
db/sqlite3/sqlite3.flx:285: fun get_int_val: column_value->int
get_le
datatype/strdict.flx:157: fun get_le (x:strdict) (var key: string)
get_library
program/dynlink.fdoc:356: fun get_library: flx_instance -> flx_library
get_line
io/stream.flx:289: noinline proc get_line[istr with IByteStream[istr]] (
get_lt
datatype/strdict.flx:190: fun get_lt (x:strdict) (var key: string)
get_module_registry
program/dynlink.fdoc:137: gen get_module_registry () :registry_t
get_module_registry_address_address
program/dynlink.fdoc:129: fun get_module_registry_address_address: 1 -> &®istry_t
get_next
db/sqlite3/sqlite3.flx:299: gen get_next ( iter:()->ret_val[darray[column_value]],row:&ret_val[darray[column_value]]):bool
get_opt
io/zmq.flx:443: fun get_opt(s: zmq_socket) (o: zmq_sockopts_tag) : zmq_socket_options
get_pb
win32/faio_win32.flx:185: fun get_pb: winfile_io -> sel_param_ptr
posix/faio_posix.flx:261: fun get_pb: flxfileio_request -> sel_param_ptr
posix/faio_posix.flx:195: fun get_pb: socketio_request -> sel_param_ptr
get_pointer_data
felix/flx_gc.fdoc:21: fun get_pointer_data (p:address)
get_scheduler_state
felix/sync.flx:58: fun get_scheduler_state : scheduler -> fstate_t
get_socket
posix/faio_posix.flx:243: fun get_socket: accept_request -> socket_t
posix/faio_posix.flx:228: fun get_socket: async_connect -> socket_t
get_sockopt
io/zmq.flx:275: proc get_sockopt[T:blobkind](s:zmq_socket, o:zmq_sockopts_tag, pd:&T, ps: &size)
get_start_as_address
program/dynlink.fdoc:184: fun get_start_as_address: flx_library -> address
get_state
control/fibres.flx:79: fun get_state : fibre_scheduler -> fibre_scheduler_state
get_stdout
win32/shell.flx:44: gen get_stdout(x:string)
program/system.flx:74: gen get_stdout(x:string) : int * string
program/shell.flx:75: gen get_stdout[T with Streamable[T,string]] (args:T) : int * string
program/shell.flx:71: gen get_stdout (args:list[string]) : int * string
program/shell.flx:48: gen get_stdout (cmd:string) : int * string
get_stmt
db/sqlite3/sqlite3.flx:296: fun get_stmt: result_code[sqlite3_stmt_t]-> sqlite3_stmt_t
get_success
win32/faio_win32.flx:50: fun get_success[t]: t -> bool
get_text_val
db/sqlite3/sqlite3.flx:293: fun get_text_val: column_value->string
get_thread
io/faio.flx:12: proc get_thread(thread: &fthread)
get_thread_frame
program/dynlink.fdoc:363: fun get_thread_frame: flx_instance -> address
get_thread_frame_creator_as_address
program/dynlink.fdoc:181: fun get_thread_frame_creator_as_address: flx_library -> address
get_variable
felix/flx_pkgconfig_core.flx:243: fun get_variable(line:string):string * string
getcwd
win32/directory.flx:41: fun getcwd():string
posix/directory.flx:34: fun getcwd():string
io/directory.flx:26: virtual fun getcwd: 1 -> string
getenv
program/env.flx:15: fun getenv(name:string,dflt:string):string
program/env.flx:9: fun getenv:string -> string
getenvlist
program/env.flx:19: fun getenvlist (name:string) : list[string]
getpeername
posix/faio_posix.flx:111: fun getpeername (s: socket_t) : string
posix/faio_posix.flx:109: fun getpeername: socket_t * &sockaddr_t * &socklen_t -> int
getpid
linux/smaps.flx:36: fun getpid: ()->Process::pid_t
getsockopt
io/zmq.flx:301: gen getsockopt(s: zmq_socket, o: zmq_sockopts_tag) : zmq_socket_options
git_get
felix/pkgtool/pkgtool_base.flx:682: noinline proc git_get(url:string,dest:string)
felix/pkgtool/pkgtool_base.flx:674: noinline proc git_get(dest:string)
glob
glob.flx:21: gen glob (pat:string): stl_vector[string]
glob.flx:18: gen glob: string * &glob_t -> bool
glob.flx:7: class glob
globfree
glob.flx:19: proc globfree: &glob_t
gramtime
felix/flx_cache.flx:3: fun gramtime(debugln: string -> 0) (path:string, s:string) : double
green
io/ansi_terminal.flx:29: proc green(s:string)
io/ansi_terminal.flx:28: proc green()
green_
io/ansi_terminal.flx:27: fun green_(s:string)
io/ansi_terminal.flx:26: fun green_()
gt
order.flx:44: fun gt(x:t,y:t):bool
gxx_demangle
felix/rtti.flx:88: fun gxx_demangle(s:string) :string
handle_dependency
felix/pkgtool/pkgtool_base.flx:650: noinline proc handle_dependency(dependency:string)
handle_global_options
felix/pkgtool/pkgtool_base.flx:1225: gen handle_global_options(options:list[string])
handle_pkg
felix/flx_pkgconfig_core.flx:267: proc handle_pkg (pkg:string, trace:list[string])
handlecopying
strings/string.fdoc:407: noinline proc handlecopying(ch:char)
haskey
datatype/strdict.flx:47: fun haskey (x:strdict) (key: string) : bool
help
felix/pkgtool/pkgtool_base.flx:1085: proc help()
help_command
felix/pkgtool/pkgtool_base.flx:1133: proc help_command (command:list[string])
i
scalar/quaternion.flx:7: fun i(x:q)
iclose
io/stream.flx:114: proc iclose (fd: fd_t)
io/stream.flx:40: virtual proc iclose: T
io/socket.flx:89: proc iclose (s:socket_t)
io/socket.flx:86: proc iclose (s:socket_t)
ignore
c_hack.flx:21: proc ignore[t]:t
ignore_signal
win32/signal.flx:36: proc ignore_signal(s:signal_t)
posix/signal.flx:58: proc ignore_signal(s:signal_t)
iiter
datatype/array_class.fdoc:75: virtual proc iiter (_f:size -> v->void) (x:t)
imag
scalar/float_math.flx:35: fun imag : complex[t] -> t
algebraic.flx:213: virtual fun imag: t -> r
implies
scalar/bool.flx:25: fun implies: bool * bool -> bool
imply
felix/pkgtool/pkgtool_base.flx:293: noinline proc imply(name:string)
inet_ntop
posix/faio_posix.flx:95: fun inet_ntop: sa_family_t * address * +char * socklen_t -> +char requires arpa_inet_h;
init
io/zmq.flx:385: proc init (x:zmq_msg_t)
init_lib
program/dynlink.fdoc:398: noinline gen init_lib(modulename:string):flx_instance
init_lib_with_args
program/dynlink.fdoc:406: noinline gen init_lib_with_args(modulename:string, args:list[string]):flx_instance
init_loopctl
felix/flx/flx_control.flx:38: fun init_loopctl ()
init_pb
io/faio.flx:20: proc init_pb : sel_param*address*int
init_size
io/zmq.flx:384: proc init_size (x:zmq_msg_t) (n:size)
init_string
io/zmq.flx:390: proc init_string (x:zmq_msg_t) (s:string)
inner
datatype/list.fdoc:334: fun inner(low:int, high:int, step:int, values:list[int])
insert
strings/string.fdoc:575: fun insert: string * int * string -> string
strings/string.fdoc:570: proc insert: &string * int * string
datatype/varray.flx:177: proc insert[t] (a:varray[t], i:int, v:t)
datatype/darray.fdoc:159: proc insert[t] (a:darray[t], i:int, v:t)
datatype/avl.flx:93: fun insert[T] (y : T, cmp : T*T->int)
datatype/avl.flx:78: fun insert[T] (tree : avl[T], y : T, cmp : T*T->int)
insert_unique
datatype/list.fdoc:512: fun insert_unique[T] (eq: T * T -> bool) (x:list[T]) (e:T) : list[T]
install
felix/pkgtool/pkgtool_base.flx:879: virtual proc install()
installed
felix/pkgtool/pkgtool_base.flx:1187: noinline fun installed()
int
win32/signal.flx:5: ctor int: signal_t
win32/process.flx:12: ctor int:process_status_t
win32/filesystem.flx:28: ctor int : posix_file
strings/tre.flx:31: ctor int : regoff_t
scalar/int.flx:32: ctor int(x:bool)
scalar/int.flx:30: ctor int : int
scalar/int.flx:28: ctor int: string
posix/signal.flx:5: ctor int: signal_t
posix/process.flx:60: ctor int: pid_t
posix/process.flx:12: ctor int:process_status_t
posix/filesystem.flx:28: ctor int : posix_file
posix/faio_posix.flx:28: ctor int : socklen_t
posix/errno.flx:4: ctor int : errno_t
datatype/judy.flx:17: ctor int: word
int16
scalar/int.flx:85: ctor int16: string
int32
scalar/int.flx:91: ctor int32: string
int64
scalar/int.flx:97: ctor int64: string
int8
scalar/int.flx:79: ctor int8: string
int_of_process_status_t
win32/process.flx:14: fun int_of_process_status_t: process_status_t -> int
posix/process.flx:14: fun int_of_process_status_t: process_status_t -> int
int_to_int
posix/errno.flx:57: fun int_to_int (var x:int)
int_to_proc
posix/errno.flx:56: proc int_to_proc (var x:int)
intmax
scalar/int.flx:156: ctor intmax: string
intptr
win32/process.flx:57: ctor intptr: pid_t
win32/process.flx:11: ctor intptr:process_status_t
scalar/int.flx:144: ctor intptr: string
ioclose
io/stream.flx:136: proc ioclose (fd: fd_t)
io/stream.flx:57: virtual proc ioclose: T
io/socket.flx:124: proc ioclose (s:socket_t)
io/socket.flx:108: proc ioclose (s:socket_t)
isNULL
scalar/address.flx:17: fun isNULL: address -> bool
posix/directory.flx:8: fun isNULL: dirent_t -> bool
posix/directory.flx:7: fun isNULL: DIR_t -> bool
felix/rtti.flx:8: fun isNULL: gc_shape_t -> bool
datatype/judy.flx:23: fun isNULL: &word -> bool
datatype/judy.flx:22: fun isNULL: word -> bool
control/schannels.flx:45: fun isNULL[T] :oschannel[T] -> bool
control/schannels.flx:42: fun isNULL[T] :ischannel[T] -> bool
control/schannels.flx:39: fun isNULL[T] :schannel[T] -> bool
c_hack.flx:63: fun isNULL[t]: gcptr[t] -> bool
c_hack.flx:59: fun isNULL[t]: +t -> bool
c_hack.flx:55: fun isNULL[t]: &t -> bool
is_absolute_filename
io/filename.flx:152: fun is_absolute_filename (f:string)
io/filename.flx:136: fun is_absolute_filename (f:string)
io/filename.flx:117: fun is_absolute_filename (f:string)
io/filename.flx:6: virtual fun is_absolute_filename : string -> bool
is_felix_pointer
felix/flx_gc.fdoc:23: fun is_felix_pointer (pd: pointer_data_t)
is_head_pointer
felix/flx_gc.fdoc:24: fun is_head_pointer (pd: pointer_data_t)
is_installed
felix/pkgtool/pkgtool_base.flx:636: noinline fun is_installed(name:string)
is_nullptr
cptr.flx:33: fun is_nullptr[T] (px:cptr[T])
is_prefix_of
felix/flx_pkgconfig_core.flx:123: fun is_prefix_of(p:string,w:string)
isalnum
scalar/char.flx:23: fun isalnum : char -> bool requires C89_headers::ctype_h
isalpha
scalar/char.flx:26: fun isalpha : char -> bool requires C89_headers::ctype_h
isalphanum
scalar/char.flx:62: fun isalphanum(x:char)
isblank
scalar/char.flx:41: fun isblank : char -> bool requires C89_headers::ctype_h
iscamlidcont
scalar/char.flx:59: fun iscamlidcont(x:char)
iscntrl
scalar/char.flx:35: fun iscntrl : char -> bool requires C89_headers::ctype_h
isdigit
scalar/char.flx:29: fun isdigit : char -> bool requires C89_headers::ctype_h
isdq
scalar/char.flx:66: fun isdq(x:char)
iseol
scalar/char.flx:69: fun iseol(x:char)
isidcont
scalar/char.flx:60: fun isidcont(x:char)
isidstart
scalar/char.flx:58: fun isidstart(x:char)
isletter
scalar/char.flx:63: fun isletter (x:char)
islower
scalar/char.flx:20: fun islower : char -> bool requires C89_headers::ctype_h
isnull
scalar/char.flx:68: fun isnull(x:char)
isnumeric
scalar/char.flx:61: fun isnumeric(x:char)
isprint
scalar/char.flx:44: fun isprint : char -> bool requires C89_headers::ctype_h
ispunct
scalar/char.flx:47: fun ispunct : char -> bool requires C89_headers::ctype_h
isrc
control/spipe.flx:12: proc isrc[V,T with Streamable[T,V]] (var dat:T) (out:oschannel[opt[V]])
isslosh
scalar/char.flx:67: fun isslosh(x:char)
isspace
scalar/char.flx:38: fun isspace : char -> bool requires C89_headers::ctype_h
issq
scalar/char.flx:65: fun issq(x:char)
isupper
scalar/char.flx:17: fun isupper : char -> bool requires C89_headers::ctype_h
isxdigit
scalar/char.flx:32: fun isxdigit : char -> bool requires C89_headers::ctype_h
iter
datatype/sexpr.fdoc:15: proc iter[T] (_f:T->void) (x:sexpr[T])
datatype/option.flx:39: proc iter[T] (_f:T->void) (x:opt[T])
datatype/list.fdoc:203: proc iter (_f:T->void) (x:list[T])
datatype/avl.flx:192: proc iter[T] (f:int*T->void, tree:avl[T])
datatype/avl.flx:180: proc iter[T] (f:T->void, tree:avl[T])
datatype/array_class.fdoc:62: virtual proc iter (_f:v->void) (x:t)
iterator
strings/string.fdoc:222: gen iterator(var x:string) ()
strings/re2.flx:171: gen iterator (r:RE2, var target:string) () : opt[varray[string]]
strings/re2.flx:168: gen iterator (re2:string, var target:string)
felix/serialise.fdoc:110: gen iterator (self: &pclosure) () : opt[address]
datatype/strdict.flx:220: gen iterator (x:strdict) () : opt[string * T]
datatype/slice.flx:15: gen iterator[t] (f:1->opt[t])
datatype/option.flx:93: gen iterator[T] (var x:opt[T]) ()
datatype/list.fdoc:581: gen iterator (var xs:list[T]) ()
datatype/array_class.fdoc:99: gen iterator(xs:t) () : opt[v]
control/stream.flx:6: virtual fun iterator : ContainerType -> 1 -> opt[ValueType]
j
scalar/quaternion.flx:8: fun j(x:q)
join
io/filename.flx:79: fun join(ps: List::list[string])
io/filename.flx:76: fun join(x:string) (y:string)
io/filename.flx:73: fun join(a:string, b:string, c:string,d:string)
io/filename.flx:72: fun join(a:string, b:string, c:string)
io/filename.flx:48: fun join(p:string, b:string)
datatype/list.fdoc:375: fun join[T] (x:list[T]) (y:list[T]):list[T]
datatype/avl.flx:139: fun join[T] (A : avl[T], B : avl[T])
datatype/array.flx:90: fun join[T, M] (x:T) (y:array[T, M]):array[T, 1 + M]
datatype/array.flx:77: fun join[T, N] (x:array[T, N]) (y:T):array[T, N + 1]
datatype/array.flx:58: fun join[T, N, M] (x:array[T, N]) (y:array[T, M]):array[T, N + M]
join_list
felix/pkgtool/pkgtool_base.flx:224: fun join_list (strings:list[string])
felix/pkgtool/pkgtool_base.flx:221: fun join_list (strings:list[string],s:string)
k
scalar/quaternion.flx:9: fun k(x:q)
keep_val
felix/flx_pkgconfig_core.flx:263: proc keep_val (v:string)
kill
win32/process.flx:142: gen kill: pid_t * signal_t -> int
posix/process.flx:172: gen kill: pid_t * signal_t -> int
control/fibres.flx:89: proc kill: fthread
land
scalar/bool.flx:7: fun land: bool * bool -> bool
last
datatype/avl.flx:115: fun last[T] : avl[T]->T
le
order.flx:45: fun le (x:t,y:t):bool
len
strings/string.fdoc:50: fun len: string -> size
strings/re2.flx:45: fun len: StringPiece -> size
strings/re2.flx:40: fun len: StringPiece -> size
flx_tclass.flx:59: virtual fun len: c -> size
datatype/varray.flx:84: fun len: varray[v] -> size
datatype/darray.fdoc:109: fun len (a:darray[v])
datatype/bsarray.flx:17: fun len(b:bsarray[T])
datatype/array_class.fdoc:21: virtual fun len: t -> size
datatype/array.flx:23: fun len (x:&array[t, n]): size
datatype/array.flx:16: fun len (x:array[t, n]): size
lexit
felix/flx_pkgconfig_core.flx:37: fun lexit(ini:lex_iterator, finish:lex_iterator): lex_iterator * string
lexstr
felix/flx_pkgconfig_core.flx:82: fun lexstr(s':string): list[string]
link_shape
felix/rtti.flx:120: gen link_shape[T]()
link_strings
felix/flx/flx_cmdopt.flx:728: fun link_strings ()
list_comprehension
datatype/list.fdoc:154: fun list_comprehension[T] (f: (1->opt[T]))
literal
strings/re2.flx:82: fun literal: RE2Options -> bool
ljust
strings/string.fdoc:316: fun ljust(x:string, width:int) : string
lnot
scalar/bool.flx:22: fun lnot: bool -> bool
load
io/textio.flx:174: gen load: istream -> string
io/textio.flx:125: gen load: ifile -> string
io/textio.flx:97: fun load: string -> string
io/textio.flx:19: virtual gen load: input_text_file -> string
load-plugin-func0
program/dynlink.fdoc:562: noinline gen load-plugin-func0[iftype] (
load-plugin-func1
program/dynlink.fdoc:576: noinline gen load-plugin-func1[iftype, arg_t] (
load-plugin-func2
program/dynlink.fdoc:590: noinline gen load-plugin-func2[iftype, arg1_t, arg2_t] (
lock
control/mutex.flx:8: proc lock: mutex
log
scalar/float_math.flx:70: fun log: t -> t
felix/pkgtool/pkgtool_base.flx:466: noinline proc log(message:string,log_file:string)
felix/pkgtool/pkgtool_base.flx:461: proc log(message:string)
algebraic.flx:182: virtual fun log: t -> t
log10
scalar/float_math.flx:77: fun log10: t -> t
algebraic.flx:199: virtual fun log10: t -> t
log_errors
strings/re2.flx:76: fun log_errors: RE2Options -> bool
long
scalar/int.flx:37: ctor long: string
longest_match
strings/re2.flx:73: fun longest_match: RE2Options -> bool
lor
scalar/bool.flx:13: fun lor: bool * bool -> bool
lstrip
strings/string.fdoc:310: fun lstrip (x:string) : string
strings/string.fdoc:270: fun lstrip (x:string, e:string) : string
lt
order.flx:43: fun lt (x:t,y:t): bool
ltrim
strings/string.fdoc:250: fun ltrim (x:string) (e:string) : string
make_history
felix/pkgtool/pkgtool_base.flx:911: noinline proc make_history (name:string)
make_string
codec/base64.flx:13: gen make_string: size*char->string
make_zmq_msg_t
io/zmq.flx:66: gen make_zmq_msg_t : 1 -> zmq_msg_t
malloc
rawc.flx:23: gen malloc:size -> address
c_hack.flx:91: gen malloc: !ints -> address
manager
control/forkjoin.flx:10: noinline proc manager (var p: 1->0) ()
map
strings/string.fdoc:112: fun map (f:char->char) (var x:string): string
datatype/varray.flx:200: fun map[T, U] (_f:T->U) (x:varray[T]): varray[U]
datatype/sexpr.fdoc:22: fun map[T,U] (_f:T->U) (x:sexpr[T]):sexpr[U]
datatype/option.flx:73: fun map[T,U] (_f:T->U) (x:opt[T]): opt[U]
datatype/list.fdoc:287: fun map[T,U] (_f:T->U) (x:list[T]): list[U]
datatype/array.flx:40: fun map[V,N,U] (_f:V->U) (x:array[V,N]):array[U,N]
map_package_requirements
felix/flx_pkg.flx:41: gen map_package_requirements(spec:pkgconfig_inspec_t) : pkgconfig_outspec_t
max
order.flx:47: fun max(x:t,y:t):t
max_mem
strings/re2.flx:79: fun max_mem: RE2Options -> int
maxf
felix/flx/flx_run.flx:564: fun maxf (t:double) (f:string)
felix/flx/flx_run.flx:139: fun maxf (x: double) (f:string)
felix/flx/flx_depchk.flx:62: fun maxf (t:double) (f:string)
felix/flx/flx_depchk.flx:18: fun maxf (t:double) (f:string)
maxlen
datatype/varray.flx:110: fun maxlen[t]: varray[t] -> size
maxtime
felix/flx_cache.flx:5: fun maxtime (x:double) (s:string)
maybe_exit
posix/errno.flx:23: proc maybe_exit()
posix/errno.flx:22: proc maybe_exit(var n:errno_t)
posix/errno.flx:21: proc maybe_exit(var n:int)
mem
flx_tclass.flx:51: fun mem (elt:t, container:c):bool
datatype/list.fdoc:460: fun mem[T, U] (eq:T * U -> bool) (xs:list[T]) (e:U) : bool
datatype/list.fdoc:450: fun mem[T] (eq:T -> bool) (xs:list[T]) : bool
datatype/assoc_list.fdoc:22: fun mem[A,B with Eq[A]] (xs:assoc_list[A,B]) (e:A) : bool
datatype/assoc_list.fdoc:17: fun mem[A,B,T] (eq:A * T -> bool) (xs:assoc_list[A,B]) (e:T) : bool
datatype/assoc_list.fdoc:11: fun mem[A,B] (eq:A -> bool) (xs:assoc_list[A,B]) : bool
datatype/array_class.fdoc:180: virtual fun mem[u] (rel:v*u->bool) (x:t) (e:u): bool
datatype/array_class.fdoc:161: virtual fun mem(pred:v->bool) (x:t): bool
memcmp
carray.flx:112: fun memcmp: address * address * size -> int
memcpy
rawc.flx:30: gen memcpy:address * address * size -> address
carray.flx:106: proc memcpy: address * address * size
memmove
rawc.flx:31: gen memmove:address * address * size -> address
memset
rawc.flx:29: gen memset:address * int * size -> address
min
order.flx:48: fun min(x:t,y:t):t
min_whitespace
linux/smaps.flx:42: fun min_whitespace(s:string)
minuseq
algebraic.flx:25: proc minuseq(px:&t, y:t)
mk_absolute_filename
win32/directory.flx:55: fun mk_absolute_filename(s:string)
posix/directory.flx:39: fun mk_absolute_filename(s:string)
io/directory.flx:29: virtual fun mk_absolute_filename: string -> string
mk_accept
win32/faio_win32.flx:48: fun mk_accept: demuxer * SOCKET*SOCKET -> wasync_accept
posix/faio_posix.flx:242: fun mk_accept: demuxer * socket_t -> accept_request
mk_alarm_clock
io/faio.flx:38: fun mk_alarm_clock: 1 -> alarm_clock
mk_async_connect
posix/faio_posix.flx:227: fun mk_async_connect: demuxer * +char *int-> async_connect
mk_connect_ex
win32/faio_win32.flx:66: fun mk_connect_ex: demuxer * SOCKET*+char*int -> connect_ex
mk_faio
posix/faio_posix.flx:259: fun mk_faio: job_queue * FileSystem::posix_file *address*int*int*bool -> flxfileio_request
mk_iocp_associator
win32/faio_win32.flx:206: fun mk_iocp_associator: demuxer * SOCKET -> iocp_associator
mk_iopchannel_pair
control/pchannels.flx:34: fun mk_iopchannel_pair[t]()
control/pchannels.flx:29: fun mk_iopchannel_pair[t](var ch:pchannel[t])
mk_ioschannel_pair
control/schannels.flx:59: gen mk_ioschannel_pair[t]()
control/schannels.flx:54: gen mk_ioschannel_pair[t](var ch:schannel[t])
mk_job_queue
control/pthread.flx:19: gen mk_job_queue: int * int -> job_queue
mk_listener
win32/faio_win32.flx:88: proc mk_listener(listener: &SOCKET, port: &int, backlog: int)
posix/faio_posix.flx:246: proc mk_listener: &socket_t* &int *int
io/socket.flx:10: proc mk_listener(l: &socket_t, port: &int, qlen: int)
mk_null_ischannel
control/schannels.flx:31: gen mk_null_ischannel[t]: 1->ischannel[t]
mk_null_oschannel
control/schannels.flx:36: gen mk_null_oschannel[t]: 1->oschannel[t]
mk_null_schannel
control/schannels.flx:26: gen mk_null_schannel[t]: 1->schannel[t]
mk_pchannel
control/pchannels.flx:21: fun mk_pchannel[t]: 1->pchannel[t]
mk_pkgconfig_query
felix/flx_pkgconfig_export.flx:15: gen mk_pkgconfig_query (a:FlxPkgConfigQuery_struct)
mk_reuse_socket
win32/faio_win32.flx:142: fun mk_reuse_socket : demuxer * SOCKET -> wasync_transmit_file
mk_schannel
control/schannels.flx:17: gen mk_schannel[t]: 1->schannel[t]
mk_sleep_request
io/faio.flx:39: fun mk_sleep_request: alarm_clock * double -> sleep_request
mk_socket
win32/faio_win32.flx:39: proc mk_socket(s: &SOCKET)
io/zmq.flx:441: gen mk_socket (c: zmq_context) (t:zmq_socket_type_t)
mk_socketio_request
posix/faio_posix.flx:192: gen mk_socketio_request: demuxer * socket_t*address*int*bool -> socketio_request
mk_sys_demux
io/demux.flx:7: gen mk_sys_demux: 1->demuxer
mk_thread
control/fibres.flx:15: gen mk_thread: cont->fthread
mk_transmit_file
win32/faio_win32.flx:127: fun mk_transmit_file : demuxer * SOCKET*WFILE -> wasync_transmit_file
mk_winfile_io
win32/faio_win32.flx:182: fun mk_winfile_io: demuxer * WFILE*address*int*bool->winfile_io
mk_wsa_socketio
win32/faio_win32.flx:152: gen mk_wsa_socketio: demuxer * SOCKET*sel_param_ptr*bool->wsa_socketio
mkdir
win32/directory.flx:29: gen mkdir: string -> int
win32/directory.flx:28: gen mkdir: string * Win32FileStat::mode_t -> int
posix/directory.flx:20: gen mkdir: string -> int
posix/directory.flx:19: gen mkdir: string * PosixFileStat::mode_t -> int
io/directory.flx:11: virtual gen mkdir: string -> int
io/directory.flx:7: virtual gen mkdir: string * mode_t -> int
mkdirs
win32/directory.flx:30: proc mkdirs (s:string)
posix/directory.flx:21: proc mkdirs (s:string)
io/directory.flx:15: virtual proc mkdirs: string
mkrel
felix/flx/flx_cmdopt.flx:750: fun mkrel (d:string, f:string)
mmap
posix/mmap.flx:73: fun mmap:
mod
algebraic.flx:80: fun mod(x:t, y:t)
modeq
algebraic.flx:84: proc modeq(px:&t, y:t)
modopen
program/dynlink.fdoc:115: proc modopen:flx_library * string * string
modulename
program/dynlink.fdoc:178: fun modulename : flx_library -> string
msync
posix/mmap.flx:86: fun msync: address * size * int -> int
mtime
io/filestat.flx:51: fun mtime: &stat_t -> double
mul
algebraic.flx:41: fun mul(x:t, y:t)
muleq
algebraic.flx:40: proc muleq(px:&t, y:t)
munmap
posix/mmap.flx:83: fun munmap: address * size -> int
mutex
control/mutex.flx:7: ctor mutex: unit
mux
control/mux.flx:28: fun mux[C,T with Streamable[C,ischannel[T]]] (a:C, out:oschannel[T])
control/mux.flx:17: proc mux[T] (inp:1->opt[ischannel[T]], out:oschannel[T]) ()
myget
program/system.flx:14: gen myget(i:size)
program/dynlink.fdoc:316: gen myget(i:size)
n
datatype/array_class.fdoc:293: fun n"&." [I in ints] (x:t, i:I) : &v
carray.flx:20: fun n"&." [T]: carray[T] * !ints -> &T
n_offsets
felix/rtti.flx:49: fun n_offsets (shape: gc_shape_t) : size
name
felix/rtti.flx:71: fun name : type_info -> string
nand
scalar/bool.flx:10: fun nand: bool * bool -> bool
ncode
felix/serialise.fdoc:12: fun ncode [T] (var v: T)
ne
order.flx:12: fun ne(x:t, y:t)
neg
algebraic.flx:23: fun neg(x:t)
never_nl
strings/re2.flx:85: fun never_nl: RE2Options -> bool
next_shape
felix/rtti.flx:21: fun next_shape: gc_shape_t -> gc_shape_t
ngrp
strings/regdef.flx:45: fun ngrp (s:string)
nor
scalar/bool.flx:16: fun nor: bool * bool -> bool
norm
scalar/quaternion.flx:27: fun norm (a:q):double
nsub
strings/tre.flx:21: fun nsub: &tre_regex_t -> int
number_of_elements
felix/rtti.flx:28: fun number_of_elements: gc_shape_t -> size
oclose
io/stream.flx:125: proc oclose (fd: fd_t)
io/stream.flx:48: virtual proc oclose: T
io/socket.flx:100: proc oclose (s:socket_t)
io/socket.flx:97: proc oclose (s:socket_t)
offsets
felix/rtti.flx:56: fun offsets (shape: gc_shape_t) : +size
ok
strings/re2.flx:128: fun ok: RE2 -> bool
one
scalar/number.flx:12: fun one: unit -> t
scalar/float_math.flx:52: fun one: 1 -> complex[t]
algebraic.flx:44: virtual fun one: unit -> t
one_line
strings/re2.flx:97: fun one_line: RE2Options -> bool
open
win32/filesystem.flx:34: gen open: string * file_perm_t -> posix_file
win32/filesystem.flx:33: gen open: string * file_perm_t * Win32FileStat::mode_t -> posix_file
posix/filesystem.flx:34: gen open: string * file_perm_t -> posix_file
posix/filesystem.flx:33: gen open: string * file_perm_t * PosixFileStat::mode_t -> posix_file
opendir
posix/directory.flx:6: proc opendir: string * &DIR_t
operation
program/dynlink.fdoc:79: fun operation : flx_link_failure_t -> string
or_default
datatype/option.flx:102: fun or_default[T] (x:opt[T]) ()
or_else
datatype/option.flx:31: fun or_else[T] (x:opt[T]) (alt:opt[T]) : opt[T]
datatype/option.flx:22: fun or_else[T] (x:opt[T]) (d:T) : T
ord
scalar/char.flx:5: fun ord: char -> int
pack
datatype/sarray.flx:68: proc pack[T] (a:sarray[T])
parse
win32/shell.flx:57: fun parse (s:string) : list[string]
program/shell.flx:14: virtual fun parse: string -> list[string]
posix/shell.flx:99: fun parse (s:string) : list[string]
parse-cmdline
program/cmdopt.flx:152: noinline gen parse-cmdline (spec:cmdspec_t) (x:list[string]) : cmdopt-parse-result_t
parse-key
program/cmdopt.flx:80: noinline gen parse-key (keys:list[string]) (d:strdict[int]) (x:list[string])
parse-key-multi-value
program/cmdopt.flx:27: noinline gen parse-key-multi-value (keys:list[string]) (d:strdict[list[string]]) (x:list[string])
parse-key-single-value
program/cmdopt.flx:52: noinline gen parse-key-single-value (keys:list[string]) (d:strdict[string]) (x:list[string])
parse-switches
program/cmdopt.flx:106: noinline gen parse-switches (switchmap: list[char * string] ) (d:strdict[int]) (x:list[string])
parse_args
felix/flx_pkgconfig_core.flx:132: proc parse_args(args:list[string])
pass
control/control.flx:14: proc pass()
past_time
io/filestat.flx:97: fun past_time ()
pathsep
program/env.flx:5: virtual fun pathsep: 1 -> string
pattern
strings/re2.flx:124: fun pattern: RE2 -> string
pclose
win32/process.flx:7: gen pclose: Cstdio::ifile -> process_status_t
program/process.flx:6: virtual gen pclose: Cstdio::ifile -> process_status_t
posix/process.flx:7: gen pclose: Cstdio::ifile -> process_status_t
pclosure
felix/serialise.fdoc:90: ctor pclosure ()
perl_classes
strings/re2.flx:91: fun perl_classes: RE2Options -> bool
pexit
program/system.flx:54: proc pexit(e:int)
program/system.flx:39: proc pexit(e:int)
phase
felix/pkgtool/pkgtool_base.flx:261: proc phase(label:string,step_p:unit->void)
pid_touint
linux/smaps.flx:38: fun pid_touint: Process::pid_t->uint
pipe
win32/filesystem.flx:60: gen pipe ()
posix/filesystem.flx:60: gen pipe ()
control/spipe.flx:223: fun pipe[T0,T1,U0,U1]
control/spipe.flx:207: fun pipe[T,U]
control/spipe.flx:187: fun pipe[T0,T1,U0,U1,V0,V1]
control/spipe.flx:171: fun pipe[T,U,V]
control/spipe.flx:135: fun pipe[T,U0,U1]
control/spipe.flx:107: fun pipe[T0,T1,U0,U1]
control/spipe.flx:91: fun pipe[T,U]
control/spipe.flx:67: fun pipe[T,N]
control/spipe.flx:35: fun pipe[T0,T1]
control/spipe.flx:20: fun pipe[T]
control/ppipe.flx:80: fun pipe[T,U]
control/ppipe.flx:64: fun pipe[T,U,V]
control/ppipe.flx:36: fun pipe[T,U]
control/ppipe.flx:21: fun pipe[T]
pisrc
control/ppipe.flx:13: proc pisrc[V,T with Streamable[T,V]] (dat:T) (out:opchannel[opt[V]])
pkgconfl
felix/flx_pkg.flx:50: gen pkgconfl(args:list[string]) : list[string]
pkgconfs
felix/flx_pkg.flx:60: gen pkgconfs(args:list[string]) : string
plus
algebraic.flx:21: fun plus(x:t)
pluseq
algebraic.flx:24: proc pluseq(px:&t, y:t)
pointer_to_pointer
posix/errno.flx:58: fun pointer_to_pointer[U] (var p:&U)
poll
io/zmq.flx:449: gen poll(pits:varray[zmq_poll_item], timeout:double)
pop
datatype/varray.flx:134: proc pop[t] : varray[t]
datatype/darray.fdoc:137: proc pop[t](a:darray[t])
popen_in
win32/process.flx:6: gen popen_in: string -> Cstdio::ifile
program/process.flx:5: virtual gen popen_in : string -> Cstdio::ifile
posix/process.flx:6: gen popen_in: string -> Cstdio::ifile
posix_syntax
strings/re2.flx:70: fun posix_syntax: RE2Options -> bool
post
semaphore.flx:8: proc post: semaphore
post_decr
scalar/int.flx:239: proc post_decr: &t
order.flx:62: virtual proc post_decr: &t
control/ts_counter.flx:9: gen post_decr: ts_counter -> long
carray.flx:79: proc post_decr[T]: &carray[T]
post_incr
scalar/int.flx:233: proc post_incr: &t
order.flx:55: virtual proc post_incr: &t
control/ts_counter.flx:7: gen post_incr: ts_counter-> long
carray.flx:73: proc post_incr[T]: &carray[T]
pow
scalar/float_math.flx:71: fun pow: t * t -> t
algebraic.flx:183: virtual fun pow: t * t -> t
pre_decr
scalar/int.flx:238: proc pre_decr: &t
order.flx:61: virtual proc pre_decr: &t
control/ts_counter.flx:8: gen pre_decr: ts_counter -> long
carray.flx:76: proc pre_decr[T]: &carray[T]
pre_incr
scalar/int.flx:232: proc pre_incr: &t
order.flx:54: virtual proc pre_incr: &t
felix/flx_pkgconfig_core.flx:35: proc pre_incr:&lex_iterator
control/ts_counter.flx:6: gen pre_incr: ts_counter -> long
carray.flx:70: proc pre_incr[T]: &carray[T]
pred
scalar/int.flx:237: fun pred: t -> t
order.flx:60: virtual fun pred: t -> t
prefix
strings/string.fdoc:231: fun prefix(arg:string,key:string)
felix/flx_pkgconfig_core.flx:138: fun prefix(x:string)
prepare_lib
program/dynlink.fdoc:377: noinline gen prepare_lib(modulename:string):flx_instance
prepare_lib_with_args
program/dynlink.fdoc:387: noinline gen prepare_lib_with_args(modulename:string, args:list[string]):flx_instance
prepend_unique
datatype/list.fdoc:506: fun prepend_unique[T] (eq: T * T -> bool) (x:list[T]) (e:T) : list[T]
print
io/textio.flx:204: proc print [T with Str[T]] (x:T)
print_config
felix/flx/flx_config.flx:5: proc print_config(config:Config::config_type)
print_help
felix/flx_pkgconfig_core.flx:8: proc print_help
print_options
felix/flx/flx_control.flx:3: proc print_options(control:control_type)
print_pointer_data
felix/flx_gc.fdoc:60: proc print_pointer_data[T] (p:+T)
felix/flx_gc.fdoc:59: proc print_pointer_data[T] (p:cptr[T])
felix/flx_gc.fdoc:58: proc print_pointer_data[T] (p:&T)
felix/flx_gc.fdoc:53: proc print_pointer_data (p:address)
felix/flx_gc.fdoc:32: proc print_pointer_data (pd: pointer_data_t)
println
io/textio.flx:207: proc println[T with Str[T]] (x:T)
proc0
program/dynlink.fdoc:501: noinline fun proc0 (linst: flx_instance, sym:string)
proc1
program/dynlink.fdoc:508: noinline fun proc1[A0] (linst: flx_instance, sym:string)
proc2
program/dynlink.fdoc:515: noinline fun proc2[A0,A1] (linst: flx_instance, sym:string)
process_config_text
felix/config.flx:68: proc process_config_text (cfg:&config_type) (text:string)
process_status_t
win32/process.flx:13: ctor process_status_t : intptr
posix/process.flx:13: ctor process_status_t : int
processfiles
felix/flx_cp.flx:2: proc processfiles
processing_stage1
felix/flx/flx_cmdopt.flx:626: noinline proc processing_stage1
proj1
categ.flx:28: fun proj1[u1,u2,r1,r2] (f:u1*u2->r1*r2) : u1 * u2 -> r1
proj2
categ.flx:32: fun proj2[u1,u2,r1,r2] (f:u1*u2->r1*r2) : u1 * u2 -> r2
prompt
felix/pkgtool/pkgtool_base.flx:444: noinline fun prompt(q:string,a:string)
psource
control/ppipe.flx:6: proc psource[T] (var it:1 -> T) (out:opchannel[T])
ptrdiff
scalar/int.flx:138: ctor ptrdiff: string
push_back
felix/sync.flx:35: proc push_back: fthread_list * fthread
datatype/varray.flx:121: proc push_back[t] : varray[t] * t
datatype/darray.fdoc:151: proc push_back[t] (a:darray[t], v:t)
q
scalar/quaternion.flx:11: ctor q (x:double)
quaternion
scalar/quaternion.flx:4: ctor quaternion (x:double^4)
quote_arg
win32/shell.flx:40: fun quote_arg(s:string):string
program/shell.flx:8: virtual fun quote_arg:string->string
posix/shell.flx:71: fun quote_arg(s:string):string
quote_line_for_popen
win32/shell.flx:42: fun quote_line_for_popen(s:string)
program/shell.flx:12: virtual fun quote_line_for_popen: string -> string
posix/shell.flx:83: fun quote_line_for_popen (s:string)
quote_line_for_system
win32/shell.flx:41: fun quote_line_for_system(s:string)
program/shell.flx:11: virtual fun quote_line_for_system: string->string
posix/shell.flx:82: fun quote_line_for_system (s:string)
r
scalar/quaternion.flx:6: fun r(x:q)
raise
control/control.flx:43: gen raise[exn] : exn -> any
ralist_cons
datatype/ralist.flx:40: fun ralist_cons[a] (x:a, xs: ralist[a])
ralist_empty
datatype/ralist.flx:45: fun ralist_empty[a]: ralist[a] -> bool
ralist_foreach
datatype/ralist.flx:210: proc ralist_foreach[a]
ralist_head
datatype/ralist.flx:84: fun ralist_head[a] (xs: ralist[a]) : a
ralist_length
datatype/ralist.flx:23: fun ralist_length[a] : ralist[a] -> int
ralist_lookup
datatype/ralist.flx:128: fun ralist_lookup[a] (xs:ralist[a],i:int)
ralist_tail
datatype/ralist.flx:93: fun ralist_tail[a] (xs: ralist[a]) : ralist[a]
ralist_uncons
datatype/ralist.flx:74: proc ralist_uncons[a] (xs: ralist[a], phd: &a, ptl: &ralist[a])
ralist_update
datatype/ralist.flx:169: fun ralist_update[a] (xs:ralist[a], i:int, x0:a)
rand
cstdlib.flx:11: fun rand: unit -> int
range
datatype/list.fdoc:370: fun range (num:int)
datatype/list.fdoc:364: fun range (low:int, high:int)
datatype/list.fdoc:332: fun range (low:int, high:int, step:int)
ravel
categ.flx:37: fun ravel[u1,u2,r1,r2] (f1:u1->r1,f2:u2->r2) : u1 * u2 -> r1 * r2
raw_dlsym
program/dynlink.fdoc:250: fun raw_dlsym:flx_library * string->address
raw_get_stdout
program/shell.flx:22: virtual gen raw_get_stdout : string -> int * string
posix/shell.flx:85: gen raw_get_stdout(x:string)
raw_malloc
c_hack.flx:87: gen raw_malloc: !ints -> address
raw_mode
win32/filestat.flx:32: fun raw_mode: &stat_t -> mode_t
posix/filestat.flx:46: fun raw_mode: &stat_t -> mode_t
raw_system
program/shell.flx:17: gen raw_system: string -> int
read
win32/filesystem.flx:42: gen read: posix_file * &char * size -> size
posix/filesystem.flx:42: gen read: posix_file * &char * size -> size
io/stream.flx:90: proc read(fd: fd_t, len: &int, buf: address, eof: &bool)
io/stream.flx:67: proc read(strm: devnull_t, len: &int, buf: address, eof: &bool)
io/stream.flx:20: virtual proc read: T * &int * address * &bool
io/socket.flx:61: proc read(s: socket_t, len: &int, buf: address, eof: &bool)
io/socket.flx:58: proc read(s: socket_t, len: &int, buf: address, eof: &bool)
flx_tclass.flx:36: virtual gen read: f -> address * int -> int * bool
flx_tclass.flx:10: virtual gen read: f -> t
control/pchannels.flx:64: gen read[t] (chan:ipchannel[t])
control/pchannels.flx:59: noinline gen read[t] (chan:pchannel[t])
read_cfg
felix/pkgtool/pkgtool_base.flx:237: noinline fun read_cfg(fn:string)
readdir
posix/directory.flx:9: proc readdir: DIR_t * dirent_t * &dirent_t * &int
readln
io/textio.flx:175: gen readln: istream -> string
io/textio.flx:126: gen readln: ifile -> string
io/textio.flx:23: virtual gen readln: input_text_file -> string
real
scalar/float_math.flx:34: fun real : complex[t] -> t
algebraic.flx:212: virtual fun real: t -> r
realloc
rawc.flx:25: gen realloc:address * size -> address
realpath
felix/pkgtool/pkgtool_base.flx:349: gen realpath: string->string
reattach_drive_letters
felix/flx_pkgconfig_core.flx:211: fun reattach_drive_letters : list[string] -> list[string]
recip
algebraic.flx:81: fun recip (x:t)
reciprocal
scalar/quaternion.flx:32: fun reciprocal (a:q):q
recv_msg
io/zmq.flx:417: proc recv_msg (s:zmq_socket) (m:zmq_msg_t)
recv_msg_dontwait
io/zmq.flx:418: proc recv_msg_dontwait (s:zmq_socket) (m:zmq_msg_t)
recv_string
io/zmq.flx:419: gen recv_string (s:zmq_socket)
recv_string_dontwait
io/zmq.flx:428: gen recv_string_dontwait (s:zmq_socket)
recv_strings
io/zmq.flx:466: gen recv_strings (s:zmq_socket) : varray[string]
red
io/ansi_terminal.flx:37: proc red(s:string)
io/ansi_terminal.flx:36: proc red()
red_
io/ansi_terminal.flx:35: fun red_(s:string)
io/ansi_terminal.flx:34: fun red_()
redir_err
felix/pkgtool/pkgtool_base.flx:492: noinline fun redir_err (cmd:string,to_file:string):string
regfilesin
io/filesystem.flx:73: fun regfilesin(dname:string, re:RE2): list[string]
io/filesystem.flx:70: fun regfilesin(dname:string, re:string): list[string]
regopen
program/dynlink.fdoc:148: noinline proc regopen (registry:registry_t) (lib:flx_library, modulename:string)
reinterpret
c_hack.flx:41: fun reinterpret[dst,src]: src->dst
reinterpret_cast
c_hack.flx:36: fun reinterpret_cast[dst,src]: src->dst
remove
datatype/list.fdoc:517: fun remove[T] (eq: T * T -> bool) (x:list[T]) (e:T) : list[T]
datatype/avl.flx:146: fun remove[T] (tree : avl[T], y : T, cmp : T*T->int)
remove_root
gc.flx:35: proc remove_root: address
rename_file
win32/filesystem.flx:73: gen rename_file: string * string -> int
posix/filesystem.flx:74: gen rename_file: string * string -> int
render
strings/regdef.flx:48: fun render: regex -> string
datatype/array_class.fdoc:252: virtual fun render : x -> size
repeat_count
felix/flx_gc.fdoc:25: fun repeat_count (pd: pointer_data_t)
repeat_history
felix/pkgtool/pkgtool_base.flx:968: noinline proc repeat_history()
replace
strings/string.fdoc:576: fun replace: string * int * int * string -> string
strings/string.fdoc:571: proc replace: &string * int * int * string
repr
strings/string.fdoc:729: fun repr (x:string) : string
scalar/char.flx:78: fun repr[with Str[T]] (c:T) : string
flx_tclass.flx:77: virtual fun repr (t:T) : string
repr_expr
debug.flx:30: fun repr_expr[t]: t -> string
reserve
strings/string.fdoc:683: proc reserve: &string * !ints
resize
control/ts_bound_queue.flx:18: proc resize[T]: ts_bound_queue_t[T] * !ints
respectful_parse
strings/string.fdoc:401: noinline fun respectful_parse (action:action_t) (var state:state_t) (var s:string) : state_t
respectful_split
strings/string.fdoc:547: fun respectful_split (s:string) : list[string]
strings/string.fdoc:527: fun respectful_split (action:RespectfulParser::action_t) (s:string) : list[string]
ret
flx_tclass.flx:67: virtual fun ret[a]: a -> M a
rev
datatype/list.fdoc:49: proc rev[T,PLT
datatype/array.flx:127: fun rev[T, N] (x:array[T, N]): array[T, N]
rev_compose
categ.flx:51: fun rev_compose[u,v,w] (f:u->v, g:v->w) : u -> w
rev_last
datatype/list.fdoc:76: proc rev_last[T,PLT
rev_map
datatype/list.fdoc:271: fun rev_map[T,U] (_f:T->U) (x:list[T]): list[U]
rev_split
strings/string.fdoc:358: fun rev_split (x:string, d:+char): List::list[string]
strings/string.fdoc:346: fun rev_split (x:string, d:string): List::list[string]
strings/string.fdoc:334: fun rev_split (x:string, d:char): List::list[string]
revents
io/zmq.flx:365: fun revents: zmq_poll_item -> zmq_pollitem_flag_t
rewrite_history
felix/pkgtool/pkgtool_base.flx:919: noinline proc rewrite_history (prior_knowledge:strdict[string])
rfi
io/filesystem.flx:77: proc rfi(dname2: string)
felix/flx_cp.flx:40: proc rfi(dir: string)
rfind
strings/string.fdoc:154: fun rfind (s:string, e:char, i:int) : opt[int]
strings/string.fdoc:153: fun rfind (s:string, e:char) : opt[int]
strings/string.fdoc:152: fun rfind (s:string, e:+char, i:int) : opt[int]
strings/string.fdoc:151: fun rfind (s:string, e:+char) : opt[int]
strings/string.fdoc:150: fun rfind (s:string, e:string, i:int) : opt[int]
strings/string.fdoc:149: fun rfind (s:string, e:string) : opt[int]
rjust
strings/string.fdoc:323: fun rjust(x:string, width:int) : string
rm
io/filesystem.flx:45: proc rm (f:string)
ropen
win32/filesystem.flx:36: gen ropen: string -> posix_file
posix/filesystem.flx:36: gen ropen: string -> posix_file
rstrip
strings/string.fdoc:311: fun rstrip (x:string) : string
strings/string.fdoc:289: fun rstrip (x:string, e:string) : string
rtrim
strings/string.fdoc:258: fun rtrim (x:string) (e:string) : string
run
felix/sync.flx:55: proc run : scheduler
felix/pkgtool/pkgtool_base.flx:1264: noinline proc run()
felix/pkgtool/pkgtool_base.flx:1253: virtual proc run()
control/fibres.flx:95: proc run: cont
run_cmd
felix/pkgtool/pkgtool_base.flx:406: noinline fun run_cmd (cmd:string,on_error:string,echo:bool,fail_not_fatal:bool)
felix/pkgtool/pkgtool_base.flx:400: noinline fun run_cmd (cmd:string,on_error:string,echo:bool)
felix/pkgtool/pkgtool_base.flx:397: fun run_cmd (cmd:string,on_error:string)
felix/pkgtool/pkgtool_base.flx:392: fun run_cmd(cmd:string)
run_cxx_compiler_if_required
felix/flx/flx_run.flx:384: gen run_cxx_compiler_if_required () : int
run_dynamic_with_calpackages
felix/flx/flx_run.flx:689: gen run_dynamic_with_calpackages () : int
run_felix_compiler
felix/flx_flxg.flx:27: gen run_felix_compiler (spec:flxg_spec_t) : int
run_felix_compiler_if_required
felix/flx/flx_run.flx:197: gen run_felix_compiler_if_required () : int
run_flx
felix/pkgtool/pkgtool_base.flx:434: virtual fun run_flx(file:string,on_error:string)
run_lib
program/dynlink.fdoc:418: proc run_lib(modulename:string)
run_linker_if_required
felix/flx/flx_run.flx:603: gen run_linker_if_required() : int
run_proc
program/dynlink.fdoc:629: noinline proc run_proc (linstance:flx_instance, p: string, data: address)
felix/sync.flx:65: proc run_proc (p: 1->0)
run_program
program/dynlink.fdoc:425: proc run_program(args:list[string])
run_program_dynamic
felix/flx/flx_run.flx:648: gen run_program_dynamic () : int
run_program_if_required
felix/flx/flx_run.flx:695: gen run_program_if_required () : int
run_program_static
felix/flx/flx_run.flx:672: gen run_program_static () : int
run_tee
control/spipe.flx:54: proc run_tee[T,N] (i:ischannel[T], oa:oschannel[T]^N)
run_test
felix/pkgtool/pkgtool_base.flx:339: proc run_test(name:string)
felix/pkgtool/pkgtool_base.flx:316: noinline proc run_test(name:string,noheader:bool,fail_not_fatal:bool)
felix/pkgtool/pkgtool_base.flx:312: noinline proc run_test(name:string,noheader:bool)
run_with_calpackages
felix/flx/flx_run.flx:422: gen run_with_calpackages () : int
runflx
felix/flx/flx.flx:120: gen runflx(args:list[string]) : int
felix/flx/bootflx.flx:124: gen runflx(args:list[string]) : int
rwopen
win32/filesystem.flx:38: gen rwopen: string -> posix_file
posix/filesystem.flx:38: gen rwopen: string -> posix_file
s6_addr
posix/faio_posix.flx:80: fun s6_addr: struct_in6_addr -> &ipv6_addr
s_addr
posix/faio_posix.flx:65: fun s_addr: struct_in_addr -> in_addr_t
sa_family
posix/faio_posix.flx:54: fun sa_family : &sockaddr_t -> sa_family_t
save
io/textio.flx:66: proc save (fn:string, lines:list[string])
io/textio.flx:57: proc save (fn:string, d:string)
schedule_fthread
control/fibres.flx:26: proc schedule_fthread(p:1->0)
scheduler
felix/sync.flx:49: ctor scheduler : fthread_list
search_and_replace
strings/string.fdoc:658: fun search_and_replace (x:string, var spos: size, re:Re2::RE2, r:string) : string
strings/string.fdoc:597: fun search_and_replace (vs:list[string * string]) (var v:string)
strings/string.fdoc:595: fun search_and_replace (x:string, s:string, r:string) : string
strings/string.fdoc:582: fun search_and_replace (x:string, var spos:size, s:string, r:string) : string
sec
algebraic.flx:150: virtual fun sec (x:t)
sech
algebraic.flx:168: virtual fun sech (x:t)
semaphore
semaphore.flx:6: ctor semaphore * int
semaphore.flx:5: ctor semaphore
send
control/fibres.flx:134: proc send[t] (p:&cont) (x:t)
send_msg
io/zmq.flx:414: proc send_msg (s:zmq_socket) (m:zmq_msg_t)
send_string
io/zmq.flx:415: proc send_string (s:zmq_socket) (m:string)
send_string_part
io/zmq.flx:416: proc send_string_part (s:zmq_socket) (m:string)
send_strings
io/zmq.flx:462: proc send_strings (s:zmq_socket) (ss:list[string])
io/zmq.flx:452: proc send_strings (s:zmq_socket) (ss:varray[string])
sep
io/filename.flx:146: fun sep()
io/filename.flx:130: fun sep()
io/filename.flx:111: fun sep()
io/filename.flx:5: virtual fun sep: 1 -> string
set
datatype/sarray.flx:25: proc set[T] (a:sarray[T], i:size, v:T)
datatype/array_class.fdoc:287: proc set[I in ints] (x:t, i:I, a:v)
datatype/array.flx:30: proc set[t,n, I in ints] (a: &array[t,n], i:I,v:t)
control/ts_counter.flx:12: proc set: ts_counter * long
carray.flx:54: proc set[T] : carray[T] * !ints * T
set_case_sensitive
strings/re2.flx:89: proc set_case_sensitive: RE2Options * bool
set_ctrl_c_flag
program/signal.flx:10: proc set_ctrl_c_flag: int requires ctrl_c_flag
set_encoding
strings/re2.flx:68: proc set_encoding: RE2Options * Encoding
set_entry_points
program/dynlink.fdoc:120: proc set_entry_points : flx_library * string * address * address
set_literal
strings/re2.flx:83: proc set_literal: RE2Options * bool
set_log_errors
strings/re2.flx:77: proc set_log_errors: RE2Options * bool
set_longest_match
strings/re2.flx:74: proc set_longest_match: RE2Options * bool
set_max_mem
strings/re2.flx:80: proc set_max_mem: RE2Options * int
set_never_nl
strings/re2.flx:86: proc set_never_nl: RE2Options * bool
set_one_line
strings/re2.flx:98: proc set_one_line: RE2Options * bool
set_opt
io/zmq.flx:442: proc set_opt(s: zmq_socket) (o: zmq_socket_options)
set_perl_classes
strings/re2.flx:92: proc set_perl_classes: RE2Options * bool
set_posix_syntax
strings/re2.flx:71: proc set_posix_syntax: RE2Options * bool
set_sockopt
io/zmq.flx:249: gen set_sockopt(s: zmq_socket) (o: zmq_socket_options)
set_used
felix/serialise.fdoc:168: proc set_used: address * size
set_word_boundary
strings/re2.flx:95: proc set_word_boundary: RE2Options * bool
setargs
program/system.flx:12: proc setargs[N] (a:string^N)
program/system.flx:11: proc setargs : + +char * size
setup
felix/flx/flx_plugin_client.flx:3: proc setup ()
setup-from-file
felix/flx/flx_cmdopt.flx:117: proc setup-from-file (debugln: string -> 0)
setup_fail
felix/pkgtool/pkgtool_base.flx:273: proc setup_fail(s:string)
sgn
scalar/int.flx:248: fun sgn: t -> int
algebraic.flx:126: virtual fun sgn: t -> int
shape_list_head
felix/rtti.flx:65: fun shape_list_head : unit -> gc_shape_t
shl
algebraic.flx:119: fun shl(x:t,y:t)
short
scalar/int.flx:22: ctor short: string
io/zmq.flx:350: ctor short: zmq_pollitem_flag_t
showtime
felix/flx/flx_run.flx:76: proc showtime(msg:string, t0:double)
shr
algebraic.flx:120: fun shr(x:t,y:t)
shutdown
win32/faio_win32.flx:101: proc shutdown: SOCKET*int
posix/faio_posix.flx:174: proc shutdown: socket_t*int
io/socket.flx:33: proc shutdown(s: socket_t, how: int)
signal
win32/signal.flx:9: gen signal: signal_t * sig_t -> sig_t
posix/signal.flx:8: gen signal: signal_t * sig_t -> sig_t
control/condition_variable.flx:22: proc signal: condition_variable
signal_t
win32/signal.flx:4: ctor signal_t: int
posix/signal.flx:4: ctor signal_t: int
sin
scalar/float_math.flx:57: fun sin: t -> t
algebraic.flx:146: virtual fun sin: t -> t
sin6_addr
posix/faio_posix.flx:87: fun sin6_addr : &sockaddr_in6_t -> &struct_in6_addr
posix/faio_posix.flx:86: fun sin6_addr : sockaddr_in6_t -> struct_in6_addr
sin6_family
posix/faio_posix.flx:84: fun sin6_family: sockaddr_in6_t -> sa_family_t
sin6_port
posix/faio_posix.flx:85: fun sin6_port : sockaddr_in6_t -> in_port_t
sin_addr
posix/faio_posix.flx:72: fun sin_addr : &sockaddr_in_t -> &struct_in_addr
posix/faio_posix.flx:71: fun sin_addr : sockaddr_in_t -> struct_in_addr
sin_family
posix/faio_posix.flx:69: fun sin_family: sockaddr_in_t -> sa_family_t
sin_port
posix/faio_posix.flx:70: fun sin_port : sockaddr_in_t -> in_port_t
sinh
scalar/float_math.flx:63: fun sinh: t -> t
algebraic.flx:164: virtual fun sinh: t -> t
size
scalar/int.flx:129: ctor size: size
scalar/int.flx:127: ctor size: string
datatype/judy.flx:20: ctor size: word
sleep
io/faio.flx:41: proc sleep(clock: alarm_clock, delta: double)
slice_range
datatype/slice.flx:10: gen slice_range[T with Integer[T]] (first:T) (last:T) ()
smaps_total
linux/smaps.flx:60: fun smaps_total(p:Process::pid_t,path:string):smaps_metric
sockaddr_p
posix/faio_posix.flx:57: fun sockaddr_p : &sockaddr_storage_t -> &sockaddr_t
socklen_t
posix/faio_posix.flx:27: ctor socklen_t : int
sort
datatype/list.fdoc:577: fun sort[T with Tord[T]](x:list[T])
datatype/list.fdoc:562: fun sort[T] (lt:T*T->bool) (x:list[T])
datatype/array_class.fdoc:363: proc sort[with Tord[v]] (a:t)
datatype/array_class.fdoc:352: proc sort (cmp: v * v -> bool) (a:t)
datatype/array.flx:143: fun sort[T,N] (var x:array[T,N]) : array[T,N]
datatype/array.flx:138: fun sort[T,N] (cmp: T * T -> bool) (var x:array[T,N]) : array[T,N]
control/spipe.flx:244: proc sort[T with Tord[T]] (r: ischannel[opt[T]], w: oschannel[opt[T]])
control/ppipe.flx:97: proc sort[T with Tord[T]] (r: ipchannel[opt[T]], w: opchannel[opt[T]])
source
control/spipe.flx:5: proc source[T] (var it:1 -> T) (out:oschannel[T])
space
io/textio.flx:213: proc space()
io/textio.flx:74: proc space (s:output_text_file)
spawn_fibre
control/fibres.flx:56: proc spawn_fibre: fibre_scheduler * fthread
spawn_fthread
control/fibres.flx:83: proc spawn_fthread (fs:fibre_scheduler) (p:1->0)
control/fibres.flx:19: proc spawn_fthread(p:1->0)
spawn_pthread
control/pthread.flx:23: proc spawn_pthread(p:1->0)
spawnv
win32/process.flx:79: gen spawnv(file: string, argv:+ +char, setup:1->int) : spawn_result_t
win32/process.flx:75: gen spawnv:+char * + +char -> pid_t
posix/process.flx:77: gen spawnv(file: string, argv:+ +char, setup:1->int) : spawn_result_t
spawnve
win32/process.flx:97: gen spawnve(file: string, argv:+ +char, env: + +char, setup:1->int) : spawn_result_t
win32/process.flx:77: gen spawnve:+char * + +char * + +char -> pid_t
posix/process.flx:117: gen spawnve(file: string, argv:+ +char, env: + +char, setup:1->int) : spawn_result_t
spawnvp
win32/process.flx:88: gen spawnvp(file: string, argv:+ +char, setup:1->int) : spawn_result_t
win32/process.flx:76: gen spawnvp:+char * + +char -> pid_t
posix/process.flx:97: gen spawnvp(file: string, argv:+ +char, setup:1->int) : spawn_result_t
splice
datatype/list.fdoc:33: proc splice[T] : &list[T] * list[T]
split
strings/string.fdoc:356: fun split (x:string, d:+char): List::list[string]
strings/string.fdoc:344: fun split (x:string, d:string): List::list[string]
strings/string.fdoc:332: fun split (x:string, d:char): List::list[string]
io/filename.flx:39: fun split(s:string)
split1
io/filename.flx:22: fun split1(s:string)
split_extension
io/filename.flx:86: fun split_extension (s:string): string * string
split_first
strings/string.fdoc:368: fun split_first (x:string, d:string): opt[string*string]
sqlite3_close
db/sqlite3/sqlite3.flx:51: proc sqlite3_close : sqlite3_db_t
sqlite3_column_blob
db/sqlite3/sqlite3.flx:209: gen sqlite3_column_blob: sqlite3_stmt_t*int->&byte
sqlite3_column_bytes
db/sqlite3/sqlite3.flx:212: gen sqlite3_column_bytes: sqlite3_stmt_t*int -> int
sqlite3_column_count
db/sqlite3/sqlite3.flx:191: gen sqlite3_column_count: sqlite3_stmt_t -> int
sqlite3_column_double
db/sqlite3/sqlite3.flx:203: gen sqlite3_column_double: sqlite3_stmt_t*int->double
sqlite3_column_int
db/sqlite3/sqlite3.flx:206: gen sqlite3_column_int: sqlite3_stmt_t*int->int
sqlite3_column_name
db/sqlite3/sqlite3.flx:194: gen sqlite3_column_name: sqlite3_stmt_t*int -> string
sqlite3_column_text
db/sqlite3/sqlite3.flx:200: gen sqlite3_column_text: sqlite3_stmt_t*int->string
sqlite3_column_type
db/sqlite3/sqlite3.flx:197: gen sqlite3_column_type: sqlite3_stmt_t*int->int
sqlite3_errmsg
db/sqlite3/sqlite3.flx:83: gen sqlite3_errmsg : sqlite3_db_t -> +char
sqlite3_exec
db/sqlite3/sqlite3.flx:77: gen sqlite3_exec : sqlite3_db_t * string * &(+char) -> int
db/sqlite3/sqlite3.flx:69: gen sqlite3_exec : sqlite3_db_t * string * sqlite3_exec_callback_t * address * &(+char) -> int
sqlite3_execute
db/sqlite3/sqlite3.flx:309: gen sqlite3_execute (stmt:sqlite3_stmt_t) :bool
sqlite3_finalize
db/sqlite3/sqlite3.flx:217: gen sqlite3_finalize: sqlite3_stmt_t -> int
sqlite3_get_columns
db/sqlite3/sqlite3.flx:249: fun sqlite3_get_columns (stmt:sqlite3_stmt_t):darray[column_value]
sqlite3_open
db/sqlite3/sqlite3.flx:46: gen sqlite3_open : string * &sqlite3_db_t -> int
sqlite3_pool
db/sqlite3/sqlite3_pool.flx:10: fun sqlite3_pool(db_file:string):pool
sqlite3_prepare_stmt
db/sqlite3/sqlite3.flx:239: fun sqlite3_prepare_stmt (db:sqlite3_db_t,query:string):result_code[sqlite3_stmt_t]
sqlite3_prepare_v2
db/sqlite3/sqlite3.flx:184: gen sqlite3_prepare_v2: sqlite3_db_t * string * int * sqlite3_stmt_t *string -> int
sqlite3_quote
db/sqlite3/sqlite3.flx:329: gen sqlite3_quote: string->string
sqlite3_row_iterator
db/sqlite3/sqlite3.flx:268: gen sqlite3_row_iterator (stmt:sqlite3_stmt_t) () :ret_val[darray[column_value]]
sqlite3_step
db/sqlite3/sqlite3.flx:188: noinline gen sqlite3_step: sqlite3_stmt_t -> int
sqr
algebraic.flx:42: fun sqr(x:t)
sqrt
scalar/float_math.flx:78: fun sqrt: t -> t
algebraic.flx:201: virtual fun sqrt: t -> t
srand
cstdlib.flx:7: proc srand: uint
ss_family
posix/faio_posix.flx:50: fun ss_family : &sockaddr_storage_t -> sa_family_t
start
control/fibres.flx:12: gen start (p:1->0)
control/fibres.flx:7: gen start[t] (p:t->0) (x:t)
start_iterator
strings/lexer.flx:4: fun start_iterator : string -> lex_iterator
startcol
debug.flx:14: fun startcol: flx_location_t -> int
startline
debug.flx:13: fun startline: flx_location_t -> int
startswith
strings/string.fdoc:245: fun startswith (x:string) (e:char) : bool
strings/string.fdoc:240: fun startswith (x:string) (e:string) : bool
stat
win32/filestat.flx:43: proc stat: string * &stat_t * &int
posix/filestat.flx:57: proc stat: string * &stat_t * &int
io/filestat.flx:43: gen stat(file: string, statbuf:&stat_t)
io/filestat.flx:7: virtual proc stat: string * &stat_t * &int
static_cast
c_hack.flx:27: fun static_cast[dst,src]: src->dst
static_library_extension
io/filename.flx:150: fun static_library_extension()
io/filename.flx:134: fun static_library_extension()
io/filename.flx:115: fun static_library_extension()
io/filename.flx:11: virtual fun static_library_extension: 1 -> string
static_object_extension
io/filename.flx:148: fun static_object_extension()
io/filename.flx:132: fun static_object_extension()
io/filename.flx:113: fun static_object_extension()
io/filename.flx:9: virtual fun static_object_extension: 1 -> string
step
control/fibres.flx:86: gen step: cont -> cont
stl_begin
strings/string.fdoc:691: fun stl_begin: &string -> +char
datatype/varray.flx:103: fun stl_begin: varray[v] -> +v
datatype/darray.fdoc:125: fun stl_begin(b:darray[v])
datatype/array_class.fdoc:331: virtual fun stl_begin: t -> +v
datatype/array.flx:36: fun stl_begin[t,n]: &array[t,n] -> +t
carray.flx:57: fun stl_begin[T,N]: carray[array[T,N]] -> carray[T]
stl_end
strings/string.fdoc:692: fun stl_end: &string -> +char
datatype/varray.flx:106: fun stl_end: varray[v] -> +v
datatype/darray.fdoc:126: fun stl_end(b:darray[v])
datatype/array_class.fdoc:334: virtual fun stl_end: t -> +v
datatype/array.flx:37: fun stl_end[t,n] ( x:&array[t,n] ) : +t
stl_find
strings/string.fdoc:133: fun stl_find: string * char * int -> int
strings/string.fdoc:132: fun stl_find: string * char -> int
strings/string.fdoc:131: fun stl_find: string * +char * int -> int
strings/string.fdoc:130: fun stl_find: string * +char -> int
strings/string.fdoc:129: fun stl_find: string * string * int -> int
strings/string.fdoc:128: fun stl_find: string * string -> int
stl_find_first_not_of
strings/string.fdoc:175: fun stl_find_first_not_of: string * char * int -> int
strings/string.fdoc:174: fun stl_find_first_not_of: string * char -> int
strings/string.fdoc:173: fun stl_find_first_not_of: string * +char * int -> int
strings/string.fdoc:172: fun stl_find_first_not_of: string * +char -> int
strings/string.fdoc:171: fun stl_find_first_not_of: string * string * int -> int
strings/string.fdoc:170: fun stl_find_first_not_of: string * string -> int
stl_find_first_of
strings/string.fdoc:161: fun stl_find_first_of: string * char * int -> int
strings/string.fdoc:160: fun stl_find_first_of: string * char -> int
strings/string.fdoc:159: fun stl_find_first_of: string * +char * int -> int
strings/string.fdoc:158: fun stl_find_first_of: string * +char -> int
strings/string.fdoc:157: fun stl_find_first_of: string * string * int -> int
strings/string.fdoc:156: fun stl_find_first_of: string * string -> int
stl_find_last_not_of
strings/string.fdoc:203: fun stl_find_last_not_of: string * char * int -> int
strings/string.fdoc:202: fun stl_find_last_not_of: string * char -> int
strings/string.fdoc:201: fun stl_find_last_not_of: string * +char * int -> int
strings/string.fdoc:200: fun stl_find_last_not_of: string * +char -> int
strings/string.fdoc:199: fun stl_find_last_not_of: string * string * int -> int
strings/string.fdoc:198: fun stl_find_last_not_of: string * string -> int
stl_find_last_of
strings/string.fdoc:189: fun stl_find_last_of: string * char * int -> int
strings/string.fdoc:188: fun stl_find_last_of: string * char -> int
strings/string.fdoc:187: fun stl_find_last_of: string * +char * int -> int
strings/string.fdoc:186: fun stl_find_last_of: string * +char -> int
strings/string.fdoc:185: fun stl_find_last_of: string * string * int -> int
strings/string.fdoc:184: fun stl_find_last_of: string * string -> int
stl_rfind
strings/string.fdoc:147: fun stl_rfind: string * char * int -> int
strings/string.fdoc:146: fun stl_rfind: string * char -> int
strings/string.fdoc:145: fun stl_rfind: string * +char * int -> int
strings/string.fdoc:144: fun stl_rfind: string * +char-> int
strings/string.fdoc:143: fun stl_rfind: string * string * int -> int
strings/string.fdoc:142: fun stl_rfind: string * string -> int
stl_sort
datatype/sort.flx:33: proc stl_sort[T]: stl_comparator[T] * +T * +T
store
strings/string.fdoc:108: proc store: &string * !ints * char
str
win32/signal.flx:22: fun str: signal_t -> string
win32/process.flx:62: fun str: pid_t -> string
win32/process.flx:31: fun str(x:process_status_t)
win32/faio_win32.flx:23: fun str: socket_t -> string
strings/string.fdoc:725: fun str: +char -> string
strings/string.fdoc:721: fun str (s:string) : string
strings/re2.flx:54: fun str: StringPiece -> string
scalar/int.flx:183: fun str: T -> string
scalar/int.flx:172: fun str: utiny -> string
scalar/int.flx:168: fun str: tiny -> string
scalar/float_math.flx:29: fun str (z:lcomplex)
scalar/float_math.flx:20: fun str (z:dcomplex)
scalar/float_math.flx:11: fun str (z:fcomplex)
scalar/float_format.flx:73: fun str(x:ldouble):string
scalar/float_format.flx:60: fun str(x:double):string
scalar/float_format.flx:47: fun str(x:float):string
scalar/char.flx:74: fun str: T -> string
scalar/bool.flx:52: fun str (b:bool) : string
scalar/address.flx:29: fun str (t:T) : string
posix/signal.flx:22: fun str: signal_t -> string
posix/process.flx:57: fun str: pid_t -> string
posix/process.flx:29: fun str(x:process_status_t)
posix/faio_posix.flx:106: fun str: socket_t -> string
posix/faio_posix.flx:102: fun str: FileSystem::posix_file -> string
io/zmq.flx:353: fun str(x:zmq_pollitem_flag_t)
io/zmq.flx:203: fun str: zmq_socket_options -> string
io/zmq.flx:148: fun str:zmq_sockopts_tag-> string
io/zmq.flx:118: fun str: zmq_socket_type_t -> string
flx_tclass.flx:95: fun str (x:unit)
flx_tclass.flx:88: fun str (x:void)
flx_tclass.flx:73: virtual fun str: T -> string
felix/sync.flx:10: fun str: fstate_t -> string
felix/config.flx:20: fun str (x:config_type) : string
debug.flx:19: fun str(var x:flx_location_t)
datatype/varray.flx:214: fun str (xs:varray[T])
datatype/unitsum.fdoc:19: fun str(x:T)
datatype/tuple.flx:34: fun str (t1:T, t2:T)
datatype/tuple.flx:31: fun str (t:T, u:U)
datatype/tuple.flx:27: fun str (x: U ** V)
datatype/strdict.flx:236: fun str(var x:strdict) : string
datatype/sexpr.fdoc:33: noinline fun str(x:sexpr[T])
datatype/ralist.flx:229: fun str (xx: ralist[a]):string
datatype/option.flx:12: fun str (x:opt[T])
datatype/list.fdoc:603: noinline fun str (xs:List::list[T])
datatype/darray.fdoc:182: fun str (x:darray[T])
datatype/bsarray.flx:41: fun str (xs:bsarray[T])
datatype/array.flx:151: fun str (xs:array[T,N])
strcat
rawc.flx:38: gen strcat:ntbs * ntbs -> ntbs
datatype/list.fdoc:442: fun strcat[T with Str[T]] (ls: list[T])
datatype/list.fdoc:438: fun strcat[T with Str[T]] (sep: string) (ls: list[T])
strchr
rawc.flx:39: gen strchr:ntbs * int -> ntbs
strcmp
rawc.flx:40: gen strcmp:ntbs * ntbs-> int
strcpy
rawc.flx:35: gen strcpy:ntbs * ntbs -> ntbs
carray.flx:120: proc strcpy: carray[char] * carray[char]
strdict
datatype/strdict.flx:31: ctor strdict ( kv: list[string * T] )
datatype/strdict.flx:21: ctor strdict()
strdup
rawc.flx:37: gen strdup:ntbs -> ntbs
carray.flx:129: gen strdup(s:carray[char])
stream_cmp
io/stream.flx:193: proc stream_cmp[istr1,istr2 with IByteStream[istr1], IByteStream[istr2]] (
strerror
posix/errno.flx:48: gen strerror()
posix/errno.flx:36: fun strerror(e:errno_t) : string
strerror_r
posix/errno.flx:32: proc strerror_r: errno_t * carray[char] * size
posix/errno.flx:28: proc strerror_r: errno_t * carray[char] * size
strfiletime
io/filestat.flx:109: fun strfiletime (x:double)
strfiletime0
io/filestat.flx:100: fun strfiletime0 (x:double)
string
strings/string.fdoc:84: ctor string: +char * !ints
strings/string.fdoc:83: ctor string: +char
strings/string.fdoc:82: ctor string (c:char)
strings/re2.flx:39: ctor string: StringPiece
io/zmq.flx:397: ctor string: zmq_msg_t
string_between
strings/lexer.flx:12: fun string_between: lex_iterator * lex_iterator -> string
strip
strings/string.fdoc:312: fun strip (x:string) : string
strings/string.fdoc:308: fun strip (x:string, e:string) : string
strip_extension
io/filename.flx:99: fun strip_extension (s:string)
strlen
rawc.flx:34: gen strlen: ntbs -> size
carray.flx:126: fun strlen: carray[char] ->size
strncpy
rawc.flx:36: gen strncpy:ntbs * ntbs * size -> ntbs
carray.flx:123: proc strncpy: carray[char] * carray[char] * !ints
study_history
felix/pkgtool/pkgtool_base.flx:888: noinline fun study_history()
sub
strings/tre.flx:30: fun sub: regoff_t * regoff_t -> int
algebraic.flx:22: fun sub(x:t,y:t)
subscript
strings/string.fdoc:98: fun subscript (x:string, s:slice[int]):string
strings/string.fdoc:89: fun subscript: string * !ints -> char
carray.flx:41: fun subscript[T]: carray[T] * !ints -> T
subst
strings/string.fdoc:608: fun subst(s:string, v:varray[StringPiece]): string
substring
strings/string.fdoc:95: fun substring: string * !ints * !ints -> string
succ
scalar/int.flx:231: fun succ: t -> t
order.flx:53: virtual fun succ: t -> t
suffix
strings/string.fdoc:235: fun suffix (arg:string,key:string)
svc
control/control.flx:118: noinline proc svc(x:svc_req_t)
swap
control/ts_counter.flx:13: gen swap: ts_counter * long -> long
sys_job_queue_nthreads
posix/faio_posix.flx:15: fun sys_job_queue_nthreads()
sys_job_queue_qbound
posix/faio_posix.flx:14: fun sys_job_queue_qbound()
system
program/system.flx:19: gen system (cmd:string) : int
program/shell.flx:60: gen system[T with Streamable[T,string]] (args:T) : int
program/shell.flx:56: gen system (args:list[string]) : int
program/shell.flx:41: gen system (cmd:string)
tail_val
felix/flx_pkgconfig_core.flx:258: proc tail_val(v:string)
take
datatype/list.fdoc:537: fun take[T] (k:int) (lst:list[T]) : list[T]
tan
scalar/float_math.flx:59: fun tan: t -> t
algebraic.flx:148: virtual fun tan (x:t)
tanh
scalar/float_math.flx:65: fun tanh: t -> t
algebraic.flx:166: virtual fun tanh (x:t)
task
felix/pkgtool/pkgtool_base.flx:269: proc task (s:string)
felix/pkgtool/pkgtool_base.flx:265: proc task(task_s:string,task_p:unit->void)
tee
io/stream.flx:264: proc tee[istr,ostr with IByteStream[istr], OByteStream[ostr]] (
term
io/zmq.flx:438: proc term (x:zmq_context)
test
felix/pkgtool/pkgtool_base.flx:834: virtual proc test()
test_config
felix/pkgtool/pkgtool_base.flx:605: noinline proc test_config(name:string,reqs:list[string])
test_fail
felix/pkgtool/pkgtool_base.flx:344: proc test_fail(s:string)
test_result
felix/pkgtool/pkgtool_base.flx:285: proc test_result (status:bool)
throw
control/control.flx:39: gen throw[ret,exn] : exn -> any
throw_continuation
control/control.flx:84: proc throw_continuation(x: unit->void)
time
win32/time.flx:19: gen time () : double
time.flx:2: virtual gen time: 1 -> double
posix/time.flx:21: gen time () : double
timedwait
control/condition_variable.flx:30: gen timedwait: condition_variable * mutex * double -> int
tiny
scalar/int.flx:16: ctor tiny: string
tmp_filename
win32/filesystem.flx:147: gen tmp_filename: 1 -> string
posix/filesystem.flx:149: gen tmp_filename: 1 -> string
to_sqlite3_result_code
db/sqlite3/sqlite3.flx:125: fun to_sqlite3_result_code: int -> sqlite3_result_codes
to_sqlite3_type
db/sqlite3/sqlite3.flx:174: fun to_sqlite3_type: int -> sqlite3_types
tolower
strings/string.fdoc:713: fun tolower(s:string):string
scalar/char.flx:14: fun tolower : char -> char requires C89_headers::ctype_h
toupper
strings/string.fdoc:711: fun toupper(s:string):string
scalar/char.flx:11: fun toupper : char -> char requires C89_headers::ctype_h
transpose
datatype/array.flx:111: fun transpose[T,N,M] (y:array[array[T,M],N]) : array[array[T,N],M]
trap_ctrl_c
win32/signal.flx:49: proc trap_ctrl_c: unit requires ctrl_c_handling
program/signal.flx:11: virtual proc trap_ctrl_c: 1
posix/signal.flx:75: proc trap_ctrl_c: unit requires ctrl_c_handling
tre_regcomp
strings/tre.flx:13: fun tre_regcomp (x:string): opt[tre_regex_t]
tre_regexec
strings/tre.flx:43: fun tre_regexec (re_in: tre_regex_t) (x:string): int * int * +regmatch_t
trim
strings/string.fdoc:266: fun trim (x:string) (e:string) : string
true_unsafe_get
datatype/array_class.fdoc:253: fun true_unsafe_get (a:t, i:x)
true_unsafe_set
datatype/array_class.fdoc:307: proc true_unsafe_set(a:t, i:x, e:v)
trunc
scalar/float_math.flx:81: fun trunc: t -> t
algebraic.flx:204: virtual fun trunc: t -> t
trywait
semaphore.flx:10: gen trywait: semaphore -> int
ts_counter
control/ts_counter.flx:4: ctor ts_counter : 1
tuple_str
datatype/tuple.flx:18: fun tuple_str (x: U * V)
datatype/tuple.flx:10: fun tuple_str (x: U ** V)
datatype/tuple.flx:6: virtual fun tuple_str (x:U)
twist
categ.flx:25: fun twist[u,v,r] (f:u*v->r) : v * u -> r
uint
win32/filestat.flx:36: ctor uint: mode_t
scalar/int.flx:61: ctor uint: string
posix/filestat.flx:50: ctor uint: mode_t
datatype/judy.flx:18: ctor uint: word
uint16
scalar/int.flx:109: ctor uint16: string
uint32
scalar/int.flx:115: ctor uint32: string
uint64
scalar/int.flx:121: ctor uint64: string
uint8
scalar/int.flx:103: ctor uint8: string
uint_topid
linux/smaps.flx:40: fun uint_topid: uint->Process::pid_t
uintmax
scalar/int.flx:162: ctor uintmax: string
uintptr
scalar/int.flx:150: ctor uintptr: string
ulong
scalar/int.flx:67: ctor ulong: string
datatype/judy.flx:19: ctor ulong: word
umask
win32/filestat.flx:58: gen umask: mode_t -> mode_t
posix/filestat.flx:72: gen umask: mode_t -> mode_t
io/filestat.flx:23: virtual gen umask: mode_t -> mode_t
unblit
felix/serialise.fdoc:15: gen unblit[T] (p: &T, s: +char, i:size) : size
uncurry2
categ.flx:19: fun uncurry2[u,v,r] (f:u->v->r) : u * v -> r
uncurry3
categ.flx:22: fun uncurry3[u,v,w,r] (f:u->v->w->r) : u * v * w -> r
unlink
io/filesystem.flx:15: proc unlink(f:string)
unlink_empty_dir
posix/directory.flx:31: gen unlink_empty_dir : string -> int
io/directory.flx:17: virtual gen unlink_empty_dir: string -> int
unlink_file
win32/filesystem.flx:68: gen unlink_file: string -> int
posix/filesystem.flx:68: gen unlink_file: string -> int
unlock
control/mutex.flx:9: proc unlock: mutex
unsafe_get
datatype/varray.flx:89: fun unsafe_get: varray[v] * size -> v
datatype/darray.fdoc:110: fun unsafe_get (a:darray[v], i:size)
datatype/bsarray.flx:18: fun unsafe_get(b:bsarray[T], i:size)
datatype/array_class.fdoc:28: virtual fun unsafe_get: t * size -> v
datatype/array.flx:25: fun unsafe_get: &array[t, n] * size -> &t
datatype/array.flx:18: fun unsafe_get (var a: array[t, n], j: size): t
unsafe_get_ref
datatype/varray.flx:97: fun unsafe_get_ref: varray[v] * size -> &v
datatype/darray.fdoc:118: fun unsafe_get_ref (b:darray[v], n:size) : &v
datatype/array_class.fdoc:280: virtual fun unsafe_get_ref : t * size -> &v
unsafe_set
datatype/varray.flx:96: proc unsafe_set: varray[v] * size * v
datatype/darray.fdoc:117: proc unsafe_set (b:darray[v], n:size, x:v)
datatype/bsarray.flx:23: proc unsafe_set(b:bsarray[T], i:size, v:T)
datatype/array_class.fdoc:272: virtual proc unsafe_set: t * size * v
datatype/array.flx:29: proc unsafe_set[t,n] (a: &(t^n), i:size, v:t)
uri_decode
codec/uri_codec.flx:66: fun uri_decode(encoded:string):string
uri_encode
codec/uri_codec.flx:58: gen uri_encode: string -> string
uses_offset_table
felix/rtti.flx:43: fun uses_offset_table : gc_shape_t -> bool
ushort
scalar/int.flx:55: ctor ushort: string
utf8
strings/string.fdoc:85: fun utf8: int -> string
utime
win32/filestat.flx:45: proc utime: string * double * double * &int
posix/filestat.flx:59: proc utime: string * double * double * &int
io/filestat.flx:77: gen utime(f:string, t:double)
io/filestat.flx:69: gen utime(f:string, a:double, m:double): bool
io/filestat.flx:12: virtual proc utime: string * double * double * &int
utiny
scalar/int.flx:49: ctor utiny: string
uvlong
scalar/int.flx:73: ctor uvlong: string
valid
win32/filesystem.flx:27: fun valid: posix_file -> bool
posix/filesystem.flx:27: fun valid: posix_file -> bool
io/zmq.flx:105: fun valid: zmq_socket->bool
io/textio.flx:183: gen valid : ostream -> bool
io/textio.flx:172: gen valid : istream -> bool
io/textio.flx:134: gen valid : ofile -> bool
io/textio.flx:123: gen valid : ifile -> bool
io/textio.flx:36: virtual gen valid : output_text_file -> bool
io/textio.flx:13: virtual gen valid : input_text_file -> bool
validate_cache
felix/flx_cache.flx:95: gen validate_cache (spec: cache_validation_spec_t) : int * double
varray
datatype/varray.flx:66: ctor varray[char] (var x:string)
vlong
scalar/int.flx:43: ctor vlong: string
vsprintf
strings/string.fdoc:704: fun vsprintf[t]: string * t -> string
strings/string.fdoc:700: fun vsprintf[t]: +char * t -> string
wait
semaphore.flx:9: proc wait: semaphore
control/ts_bound_queue.flx:17: proc wait[T]: ts_bound_queue_t[T]
control/condition_variable.flx:17: proc wait: condition_variable * mutex
wait_zero
control/ts_counter.flx:14: proc wait_zero: ts_counter
waitpid
win32/process.flx:116: gen waitpid(pid:pid_t)
win32/process.flx:114: gen waitpid: pid_t * &process_status_t * process_status_options_t -> pid_t requires Posix_headers::sys_wait_h
posix/process.flx:146: gen waitpid(pid:pid_t)
posix/process.flx:144: gen waitpid: pid_t * &process_status_t * process_status_options_t -> pid_t requires Posix_headers::sys_wait_h
warning
felix/pkgtool/pkgtool_base.flx:271: proc warning (s:string)
what
program/dynlink.fdoc:80: fun what : flx_link_failure_t -> string
wopen
win32/filesystem.flx:37: gen wopen: string -> posix_file
posix/filesystem.flx:37: gen wopen: string -> posix_file
word
datatype/judy.flx:16: ctor word: address
datatype/judy.flx:15: ctor word: !ints
word_boundary
strings/re2.flx:94: fun word_boundary: RE2Options -> bool
wrap
codec/base64.flx:66: fun wrap (b64_str:string,ll:uint) : string
write
win32/filesystem.flx:43: gen write: posix_file * &char * size -> size
posix/filesystem.flx:43: gen write: posix_file * &char * size -> size
io/textio.flx:188: proc write : ostream * char
io/textio.flx:187: proc write : ostream * utiny
io/textio.flx:186: proc write : ostream * string
io/textio.flx:139: proc write : ofile * char
io/textio.flx:138: proc write : ofile * utiny
io/textio.flx:137: proc write : ofile * string
io/textio.flx:51: virtual proc write : output_text_file * char
io/textio.flx:48: virtual proc write : output_text_file * utiny
io/textio.flx:45: virtual proc write : output_text_file * string
io/stream.flx:101: proc write(fd: fd_t, len: &int, buf: address, eof: &bool)
io/stream.flx:75: proc write(strm: devnull_t, len: &int, buf: address, eof: &bool)
io/stream.flx:26: virtual proc write: T * &int * address * &bool
io/socket.flx:76: proc write(s: socket_t, len: &int, buf: address, eof: &bool)
io/socket.flx:69: proc write(s: socket_t, len: &int, buf: address, eof: &bool)
flx_tclass.flx:40: virtual gen write : f -> address * int -> int * bool
flx_tclass.flx:14: virtual proc write: f * t
control/schannels.flx:86: proc write[T] (chan:oschannel[T], v:T)
control/schannels.flx:74: proc write[T] (chan:schannel[T], v:T)
control/pchannels.flx:81: proc write[t] (chan:opchannel[t], v:t)
control/pchannels.flx:77: noinline proc write[t](chan:pchannel[t], v:t)
write_include_file
felix/flx_pkg.flx:138: proc write_include_file(path:string, INCLUDE_FILES:list[string])
write_string
io/stream.flx:316: proc write_string[ostr with OByteStream[ostr]] (
writeln
io/textio.flx:185: proc writeln : ostream * string
io/textio.flx:136: proc writeln : ofile * string
io/textio.flx:42: virtual proc writeln : output_text_file * string
xdebugln
felix/flx/flx_run.flx:27: proc xdebugln[T with Str[T]] (d:bool) (x:T)
xfind
felix/flx_pkgconfig_core.flx:125: fun xfind(flags: string, c: string)
xor
scalar/bool.flx:19: fun xor: bool * bool -> bool
xpipe
control/spipe.flx:159: fun xpipe[V,T,U with Streamable[T,V]]
control/ppipe.flx:52: fun xpipe[V,T,U with Streamable[T,V]]
xstr
scalar/float_format.flx:70: fun xstr: ldouble -> string
scalar/float_format.flx:57: fun xstr: double -> string
scalar/float_format.flx:44: fun xstr: float -> string
yellow
io/ansi_terminal.flx:45: proc yellow(s:string)
io/ansi_terminal.flx:44: proc yellow()
yellow_
io/ansi_terminal.flx:43: fun yellow_(s:string)
io/ansi_terminal.flx:42: fun yellow_()
zero
scalar/number.flx:3: fun zero: unit -> t
scalar/float_math.flx:51: fun zero: 1 -> complex[t]
scalar/bool.flx:44: fun zero ()
datatype/unitsum.fdoc:12: fun zero ()
algebraic.flx:6: virtual fun zero: unit -> t
zip2
datatype/list.fdoc:316: fun zip2[T1,T2] (l1: list[T1]) (l2: list[T2]) : list[T1 * T2]
zmq_bind
io/zmq.flx:103: gen zmq_bind : zmq_socket * string -> int
zmq_check
io/zmq.flx:54: fun zmq_check(var retcode: int)
io/zmq.flx:47: fun zmq_check (msg:string) (var retcode:int)
zmq_close
io/zmq.flx:102: gen zmq_close: zmq_socket -> int
zmq_connect
io/zmq.flx:104: gen zmq_connect : zmq_socket * string -> int
zmq_context
io/zmq.flx:437: ctor zmq_context : int
zmq_errno
io/zmq.flx:34: fun zmq_errno : 1-> errno_t
zmq_getmsgopt
io/zmq.flx:83: fun zmq_getmsgopt: zmq_msg_t * zmq_message_option_code_t * address * &size -> int
zmq_init
io/zmq.flx:92: gen zmq_init : int -> zmq_context
zmq_more
io/zmq.flx:408: fun zmq_more (s:zmq_socket)
io/zmq.flx:399: fun zmq_more(m:zmq_msg_t):bool
zmq_msg_close
io/zmq.flx:72: gen zmq_msg_close: zmq_msg_t -> int
zmq_msg_copy
io/zmq.flx:75: gen zmq_msg_copy: zmq_msg_t * zmq_msg_t -> int
zmq_msg_data
io/zmq.flx:76: fun zmq_msg_data: zmq_msg_t -> address
zmq_msg_init
io/zmq.flx:69: gen zmq_msg_init: zmq_msg_t->int
zmq_msg_init_data
io/zmq.flx:71: gen zmq_msg_init_data: zmq_msg_t * address * size * zmq_free_fn * address -> int
zmq_msg_init_size
io/zmq.flx:70: gen zmq_msg_init_size: zmq_msg_t * size -> int
zmq_msg_move
io/zmq.flx:74: gen zmq_msg_move: zmq_msg_t * zmq_msg_t -> int
zmq_msg_size
io/zmq.flx:77: fun zmq_msg_size : zmq_msg_t -> size
zmq_poll
io/zmq.flx:369: gen zmq_poll(pits : varray[zmq_poll_item], t:double)
io/zmq.flx:367: gen zmq_poll: carray[zmq_poll_item] * int * long -> int
zmq_poll_item
io/zmq.flx:364: ctor zmq_poll_item: zmq_socket * zmq_pollitem_flag_t
zmq_recv
io/zmq.flx:339: gen zmq_recv : zmq_socket * address * size * zmq_xmit_options_t -> int
zmq_recvmsg
io/zmq.flx:341: gen zmq_recvmsg : zmq_socket * zmq_msg_t * zmq_xmit_options_t -> int
zmq_send
io/zmq.flx:338: gen zmq_send : zmq_socket * address * size * zmq_xmit_options_t -> int
zmq_sendmsg
io/zmq.flx:340: gen zmq_sendmsg : zmq_socket * zmq_msg_t * zmq_xmit_options_t -> int
zmq_socket
io/zmq.flx:101: ctor zmq_socket : zmq_context * zmq_socket_type_t
zmq_strerror
io/zmq.flx:35: fun zmq_strerror : errno_t -> string
zmq_term
io/zmq.flx:93: gen zmq_term : zmq_context -> int
zmq_validate
io/zmq.flx:45: proc zmq_validate (var retcode: int)
io/zmq.flx:39: proc zmq_validate (msg:string) (var retcode: int)
zmq_version
io/zmq.flx:17: fun zmq_version()
io/zmq.flx:16: proc zmq_version: &int * &int * &int