Namespaces
	assoc

	net

	pattr

	storage

	str

	stream

Classes
struct	accumRecTy

struct	accumRecTy< const char *, MonoTypePtr, Xs... >

class	aconcatexp

class	action

struct	ADBFSigUnqualify

class	AddDBFieldSignal

struct	addFileSignalF

class	adjptr

class	adjvtblptr

class	AIndex

class	alenexp

class	ambiguity_conflict

class	annotated_error

class	App

struct	AppendsTo

class	AppendsToUnqualifier

class	applyCFn

struct	applySubstitutionF

struct	array

class	Array

class	asetlen

class	Assign

class	Assump

struct	ATEliminator

struct	ATRecordEliminator

struct	ATRecordUnqualify

struct	Autorelease

struct	AutoreleaseSet

struct	binding

class	bit_table

struct	bnamesF

class	Bool

struct	BoundGrammarValue

class	Byte

struct	ByteRangeWatch

class	Case

class	castexp

class	cc

class	CCServer

class	Char

struct	char_range_ord

class	character

class	ClassDef

class	Client

struct	cloneF

struct	clos1

struct	clos2

struct	ClosureConvertF

class	compile_table_failure

class	compileConstExpF

class	compileExpF

class	compileIntConstF

struct	ComprehensionDef

class	ConnectionP

struct	ConsRecord

class	Constraint

class	ConstraintSet

struct	ConsVariant

struct	CPtr

class	cptrrefbyF

struct	CRegexes

class	CtorVerifier

class	DataP

struct	dballocArrF

struct	dballocArrPF

struct	dballocF

struct	dbarrCapacityF

struct	dbarrCapacityPF

struct	dbArrIdxRefF

class	DBFieldLookup

class	DBFileRefLoader

struct	DBFLUnqualify

struct	dbloadF

struct	dbloadPF

class	dbloadVF

struct	dbRefFileF

struct	dbseq

struct	dbstoreF

struct	dbstorePF

class	dbstoreVF

struct	dbunloadF

class	DeconstructP

struct	defaultLift

struct	defaultLift< const T &, InStruct >

struct	defaultLift< const T *, InStruct >

struct	defaultLift< T &, InStruct >

struct	defaultLift< T *, InStruct >

struct	destructType

struct	DFAState

class	digraphF

class	Double

struct	encodeCtorForm

struct	encodeExprF

class	encodeMonoTypeF

class	endOfFile

struct	eqsetmem

class	EqualTypes

class	equivalence_mapping

struct	etvarNamesF

struct	eventcbclosure

class	Existentials

class	Exists

class	Expr

class	ExprCase

struct	exprTypeSubst

struct	expTypeInfF

struct	falloc

class	FieldVerifier

struct	filehead

struct	fileref

struct	FileWatch

class	FinishExpr

class	FixedArray

class	FixIsoRecur

class	Float

class	Fn

struct	freeVarF

struct	FRefLoadable

struct	frefty

struct	frefty< array< T > *>

struct	frefty< array< T > >

struct	frefty< dbseq< T > *>

struct	frefty< dbseq< T > >

struct	frefty< recursive< T > *>

struct	frefty< recursive< T > >

struct	fregion

struct	func

class	Func

struct	func< R(Args...)>

struct	func< R(C::*)(Args...)>

struct	genHash

struct	genHash< MonoTypePtr >

struct	genHash< Record::Member >

struct	genHash< Variant::Member >

struct	GrammarRule

class	GrammarValue

class	GStr

class	GSymRef

struct	HasCtor

struct	HasField

struct	hasSingularTypeF

struct	HCEliminator

struct	HCVariantEliminator

struct	HCVariantUnqualify

struct	HFDBFLUnqualify

struct	HFEliminator

struct	HFLookupEliminator

struct	HFLookupUnqualify

struct	HFRecordEliminator

struct	HFRecordUnqualify

struct	HFSLookupEliminator

struct	HFSLookupUnqualify

struct	HFTEnvLookupEliminator

struct	HFTEnvLookupUnqualify

struct	HTTPRequest

class	idexp

struct	IDFAState

struct	IfCheck

class	ifexp

struct	imagefile

struct	inferMappingF

struct	inferTypeF

struct	injFileReferencesF

class	InstanceDef

class	instantiateF

class	Int

class	InvokeP

struct	isConstP

struct	IsoRecUnqualify

struct	IsoRecur

struct	item

class	jitcc

struct	label

class	Let

class	LetRec

struct	LexicalAnnotation

class	LexicallyAnnotated

struct	lift

struct	lift< array< T > *, InStruct >

struct	lift< const T(&)[N], InStruct >

struct	lift< const T(*)[N], InStruct >

struct	lift< const T[N], InStruct >

struct	lift< dbseq< T > *, InStruct >

struct	lift< fileref< T >, InStruct >

struct	lift< R(*)(Args...), false >

struct	lift< R(*)(Args...), true >

struct	lift< R(Args...), false >

struct	lift< R(Args...), true >

struct	lift< recursion, InStruct >

struct	lift< recursive< T > *, InStruct >

struct	lift< seq< T > *, InStruct >

struct	lift< std::pair< F, S > *, false >

struct	lift< std::pair< F, S >, true >

struct	lift< std::string *, InStruct >

struct	lift< std::string, true >

struct	lift< T *, false, typename T::is_hobbes_enum >

struct	lift< T *, false, typename T::is_hobbes_struct >

struct	lift< T(&)[N], InStruct >

struct	lift< T(*)[N], InStruct >

struct	lift< T, true, typename T::is_hobbes_enum >

struct	lift< T, true, typename T::is_hobbes_struct >

struct	lift< T[N], InStruct >

struct	lift< typeAlias< TN, T > *, InStruct >

struct	lift< typeAlias< TN, T >, InStruct >

struct	lift< variant< CTys... > *, false >

struct	lift< variant< CTys... >, true >

struct	liftDFAExprF

struct	liftEnum

struct	liftFixedArray

struct	liftFunction

struct	liftFunction< R(Args...)>

struct	liftPair

struct	liftRecursive

struct	liftSeq

struct	liftStruct

struct	liftTypeAsAssumpF

struct	LiftUType

struct	liftValue

struct	liftValue< reader *>

struct	liftValue< writer *>

struct	liftVarArray

struct	liftVarCtor

struct	liftVarCtor< label< TN, T > >

struct	liftVarCtors

struct	liftVarCtors< CTy, CTys... >

struct	liftVariant

struct	liftVariant< variant< CTys... > >

class	linedb

struct	linkStateF

class	LoadFileP

class	LoadVars

class	Long

class	LsP

struct	macroExpandF

struct	makePrimDFASF

struct	makeSuccStateF

struct	mapFileRefs

class	MatchAny

class	MatchArray

class	MatchLiteral

class	MatchRecord

class	MatchRegex

class	MatchVariant

struct	maximum

struct	maybe

struct	MDFA

struct	mempage

struct	mfnThunk

struct	mfnThunk< R(C::*)(Args...) const, T, f >

struct	mfnThunk< R(C::*)(Args...), T, f >

struct	mfnThunk< void(C::*)(Args...) const, T, f >

struct	mfnThunk< void(C::*)(Args...), T, f >

struct	mfnTraits

struct	mfnTraits< R(C::*)(Args...) const >

struct	mfnTraits< R(C::*)(Args...)>

class	MImport

class	MkArray

class	MkRecord

class	MkVariant

class	Module

struct	ModuleDef

struct	ModuleDefCase

class	MonoType

class	MonoTypeCase

struct	MonoTypeLT

class	MonoTypeUnifier

struct	MoreDefinedType

struct	MPtr

class	MState

class	MStateCase

struct	mtyLT

struct	MTyMap

class	MTypeDef

class	MVarDef

class	MVarTypeDef

class	newArrayfn

class	newPrimfn

struct	NFAState

class	NotEqualTypes

struct	nulltypedb

class	Objs

struct	ObjUnqualify

struct	op

class	OpaquePtr

struct	opaquePtrLift

struct	opaquePtrLift< T, false >

struct	opaquePtrLift< T, true >

struct	openFileF

class	Pack

class	packIntF

class	packLongF

class	packShortF

struct	PacksTo

struct	pagedata

struct	pagetype

struct	PArgl

struct	PArgl< const char * >

struct	PArgl< const char *, NamesAndExpr... >

struct	PArgl< ExprPtr >

struct	PArgl< std::string >

struct	PArgl< std::string, NamesAndExpr... >

struct	parserdef

struct	ParserEvalInfo

struct	ParseRule

class	PartialHTTPRequestState

class	Pattern

class	PatternCase

struct	PatternRow

class	PolyType

struct	prec

class	prefix_tree

struct	prefix_tree_node

class	Prim

class	primdfafunc

class	Primitive

class	PrimitiveCase

struct	PrimPtrLT

struct	printConnectionF

struct	printFileF

struct	probe

struct	proc

class	ProcessP

struct	ProcessPUnqualify

class	ProcManager

struct	ProcManUnqualify

class	Proj

struct	PtrAdjustment

class	QualType

class	range_map

struct	RBind

struct	rccF

struct	rccF< R(*)(Args...)>

struct	RCharRange

struct	RDUnqualify

struct	reachableRowExprsF

class	reader

struct	readF

struct	readF< bool >

struct	readF< std::string >

struct	readF< std::vector< T > >

class	ReceiveP

class	recHLabel

class	recHValue

class	Record

class	RecordDeconstructor

class	recTail

struct	recursion

struct	recursive

class	Recursive

struct	refutableP

struct	Regex

class	region

struct	REither

struct	remoteHostF

struct	REps

struct	repTypeAliasesF

struct	RewriteFnAccess

struct	RewriteMSelect

struct	RSeq

struct	RStar

class	saacopy

class	saelem

class	salenexp

class	scoped_pool_reset

class	scoped_unification_suppression

struct	scorePatternF

struct	seq

class	series

struct	Server

class	Short

class	signalsF

struct	signalUpdateF

class	sizeOfF

class	SizeOfP

struct	SizeOfPUnqualify

class	SplitP

class	StoredSeries

struct	stripAssumpF

struct	StripCst

struct	StripEqCst

struct	StripTransparentPackF

class	substituteF

struct	substituteInto

struct	substTyF

struct	substVarF

struct	Subtype

struct	SubtypeEliminator

class	SubtypeUnqualifier

class	Switch

struct	switchConst

struct	switchExpr

struct	switchExprC

struct	switchExprM

struct	switchExprTyFn

struct	switchExprTyFnM

struct	switchGrammarValue

struct	switchMState

struct	switchPattern

struct	switchRegex

struct	switchTyFn

struct	switchType

class	SwitchVal

class	SwitchVariant

class	symbol

class	TAbs

struct	TAlignOfF

class	TApp

class	TCInstance

class	TCInstanceFn

class	TClass

struct	TCUnqualify

class	TEnv

struct	terminal

class	TExpr

class	TGen

struct	tgenSizeExprF

struct	tgenVarsF

class	threadF

struct	TIfF

struct	TIfF< false, T, F >

struct	TIfF< true, T, F >

struct	timed_region

class	TLong

class	translateTypeF

struct	TSizeOfF

class	TString

class	TVar

class	type_map

struct	typeAlias

struct	typedb

class	TypeofP

struct	typeSeq

struct	typeSeq< T, Ts... >

struct	unaliasPrimTypesF

class	unique_refc_map

struct	unit

class	Unit

class	Unpack

struct	Unqualifier

class	UnqualifierSet

struct	UnqualifySafePackF

struct	UTypeRec

class	Var

class	varHLabel

class	Variant

class	variant

class	VariantDeconstructor

class	varInjH

class	varSplit

struct	VDUnqualify

struct	walkTy

class	writer

Typedefs
typedef fileref< array< char > * >	strref

typedef std::map< std::string, PolyTypePtr >	TypeAliasMap

typedef std::map< std::string, MonoTypePtr >	MonoTypeAliasMap

typedef std::function< ExprPtr(const std::string &)>	ExprParser

typedef std::vector< llvm::Value * >	Values

typedef void(*	eventhandler) (int fd, void *ud)

typedef bool(*	timerfunc) ()

typedef void(*	HTTPRequestHandler) (const HTTPRequest &, int fd, void *ud)

typedef typeAlias< timespanTNV, int64_t >	timespanT

typedef typeAlias< timeTNV, int64_t >	timeT

typedef typeAlias< datetimeTNV, int64_t >	datetimeT

typedef std::vector< uint8_t >	RawData

typedef uint32_t	exprid

typedef std::pair< size_t, MonoTypePtr >	PrepProcExpr

typedef std::shared_ptr< Expr >	ExprPtr

typedef std::vector< ExprPtr >	Exprs

typedef std::pair< std::string, ExprPtr >	Definition

typedef std::vector< Definition >	Definitions

typedef std::shared_ptr< Primitive >	PrimitivePtr

typedef std::set< PrimitivePtr, PrimPtrLT >	PrimitiveSet

typedef std::map< std::string, ExprPtr >	VarMapping

typedef std::set< std::string >	VarSet

typedef std::vector< ComprehensionDef >	ComprehensionDefs

typedef std::shared_ptr< ModuleDef >	ModuleDefPtr

typedef std::vector< ModuleDefPtr >	ModuleDefs

typedef std::shared_ptr< MVarTypeDef >	MVarTypeDefPtr

typedef std::vector< MVarTypeDefPtr >	MVarTypeDefs

typedef std::shared_ptr< MVarDef >	MVarDefPtr

typedef std::vector< MVarDefPtr >	MVarDefs

typedef std::pair< str::seq, str::seq >	CFunDepDef

typedef std::vector< CFunDepDef >	CFunDepDefs

typedef std::shared_ptr< ClassDef >	ClassDefPtr

typedef std::vector< ClassDefPtr >	ClassDefs

typedef std::shared_ptr< InstanceDef >	InstanceDefPtr

typedef std::vector< InstanceDefPtr >	InstanceDefs

typedef std::shared_ptr< Module >	ModulePtr

typedef std::vector< ModulePtr >	Modules

typedef size_t	stateidx_t

typedef std::set< stateidx_t >	stateidxset

typedef std::pair< std::string, MonoTypePtr >	PrimFArg

typedef std::vector< PrimFArg >	PrimFArgs

typedef std::shared_ptr< MState >	MStatePtr

typedef std::vector< MStatePtr >	MStates

typedef std::unordered_map< std::string, stateidx_t >	StatesIdx

typedef std::unordered_map< std::string, ExprPtr >	VarNames

typedef std::map< size_t, ExprPtr >	ArrayElem

typedef std::unordered_map< std::string, ArrayElem >	VarArrayElem

typedef std::unordered_map< std::string, ExprPtr >	VarArrayLen

typedef std::unordered_map< std::string, ExprPtr >	StructField

typedef std::unordered_map< std::string, StructField >	VarStructField

typedef std::pair< std::string, ExprPtr >	FoldedState

typedef std::vector< FoldedState >	FoldedStates

typedef std::unordered_map< stateidx_t, ExprPtr >	FoldedStateCalls

typedef std::unordered_map< PatternRows, stateidx_t, hobbes::genHash< PatternRows > >	TableCfgStates

typedef std::unordered_map< Expr *, size_t >	ExprIdxs

typedef std::vector< size_t >	Idxs

typedef std::shared_ptr< Pattern >	PatternPtr

typedef std::vector< PatternPtr >	Patterns

typedef std::vector< PatternRow >	PatternRows

typedef std::shared_ptr< std::vector< std::pair< size_t, PatternRow > > >	UnreachableMatchRowsPtr

typedef std::shared_ptr< Regex >	RegexPtr

typedef std::vector< RegexPtr >	Regexes

typedef size_t	RegexIdx

typedef std::set< RegexIdx >	RegexIdxs

typedef std::map< size_t, RegexIdxs >	RStates

typedef std::map< size_t, str::seq >	CaptureVarsAt

typedef std::pair< std::string, ExprPtr >	CVarDef

typedef std::vector< CVarDef >	CVarDefs

typedef std::map< std::string, ExprPtr >	MemberMapping

typedef std::shared_ptr< TCInstance >	TCInstancePtr

typedef std::vector< TCInstancePtr >	TCInstances

typedef std::shared_ptr< TCInstanceFn >	TCInstanceFnPtr

typedef std::vector< TCInstanceFnPtr >	TCInstanceFns

typedef std::shared_ptr< TClass >	TClassPtr

typedef std::map< std::string, TClassPtr >	TClassEnv

typedef std::vector< PtrAdjustment >	PtrAdjustmentPath

typedef std::shared_ptr< Objs >	ObjsPtr

typedef std::shared_ptr< PolyType >	PolyTypePtr

typedef std::vector< PolyTypePtr >	PolyTypes

typedef std::shared_ptr< QualType >	QualTypePtr

typedef std::vector< QualTypePtr >	QualTypes

typedef std::shared_ptr< Constraint >	ConstraintPtr

typedef std::vector< ConstraintPtr >	Constraints

typedef MonoType::ptr	MonoTypePtr

typedef std::vector< MonoTypePtr >	MonoTypes

typedef std::shared_ptr< TEnv >	TEnvPtr

typedef std::shared_ptr< Unqualifier >	UnqualifierPtr

typedef std::shared_ptr< UnqualifierSet >	UnqualifierSetPtr

typedef std::string	TVName

typedef std::vector< TVName >	Names

typedef std::set< TVName >	NameSet

typedef std::map< TVName, MonoTypePtr >	MonoTypeSubst

typedef std::set< int >	TGenVarSet

typedef std::pair< Constraints, MonoTypes >	QualLiftedMonoTypes

typedef std::pair< Constraints, MonoTypePtr >	QualLiftedMonoType

typedef variant< unit, MonoTypePtr >	MaybePathPoint

typedef std::vector< MaybePathPoint >	MaybePathPoints

typedef std::set< std::string >	SymSet

typedef std::vector< int >	VarIDs

typedef std::pair< VarIDs, int >	FunDep

typedef std::vector< FunDep >	FunDeps

typedef unsigned int	nat

typedef std::vector< nat >	nats

typedef std::vector< std::string >	strings

typedef std::pair< nats, strings >	ldblines

typedef std::shared_ptr< GrammarValue >	GrammarValuePtr

typedef std::vector< BoundGrammarValue >	BoundGrammarValues

typedef std::vector< GrammarRule >	GrammarRules

typedef std::pair< std::string, GrammarRules >	GrammarSymDef

typedef std::vector< GrammarSymDef >	Grammar

typedef terminals	rule

typedef std::vector< rule >	rules

typedef std::map< terminal *, rules >	grammar

typedef std::set< item >	itemset

typedef std::vector< itemset >	itemsets

typedef std::map< terminal *, nat >	state_transitions

typedef std::map< itemset, nat >	parser_states

typedef std::map< nat, itemset >	state_definitions

typedef std::map< nat, state_transitions >	parser_state_transitions

typedef std::pair< nat, terminal * >	transition

typedef std::set< transition >	transitionset

typedef std::map< transition, terminalset >	transition_lookahead

typedef std::map< terminal *, action >	lrstate

typedef std::vector< lrstate >	lrtable

typedef std::vector< ParseRule >	Parser

typedef std::vector< terminal * >	terminals

typedef std::set< terminal * >	terminalset

typedef std::map< terminal *, prec >	precedence

typedef std::pair< std::string, ExprPtr >	ExprDefn

typedef Expr (	VarCtorFn) (const std::string &, const LexicalAnnotation &)

typedef Pattern (	PatVarCtorFn) (const std::string &, const LexicalAnnotation &)

typedef unsigned char	UnitV

typedef std::vector< uint8_t >	bytes

typedef std::pair< bool, std::string >	BuffOrFilename

typedef std::shared_ptr< BuffOrFilename >	BuffOrFilenamePtr

typedef std::pair< size_t, size_t >	Pos

typedef std::pair< Pos, Pos >	LexRange

typedef std::pair< std::string, LexicalAnnotation >	annmsg

typedef std::vector< annmsg >	annmsgs

typedef std::vector< llvm::Type * >	Types

typedef std::vector< llvm::Constant * >	Constants

typedef std::pair< std::string, llvm::Value * >	FieldValue

typedef std::vector< FieldValue >	RecordValue

typedef std::pair< std::string, llvm::Constant * >	ConstFieldValue

typedef std::vector< ConstFieldValue >	ConstRecordValue

typedef std::pair< std::vector< std::string >, Values >	UnzRecValues

typedef std::pair< bool, MonoTypePtr >	UTFileConfig

typedef std::pair< bool, const Record * >	FileConfig

typedef std::pair< MonoTypePtr, ExprPtr >	FRefT

typedef std::vector< pagedata >	pagetable

typedef uint64_t	file_pageindex_t

typedef std::map< std::string, binding >	bindingset

typedef std::map< file_pageindex_t, fregion >	fmappings

typedef std::map< char *, falloc >	fallocs

typedef std::vector< file_pageindex_t >	pageseq

typedef std::map< pagetype::code, pageseq >	ptyorder

typedef array< int >	PBatch

typedef fileref< PBatch * >	PBatchRef

typedef dbseq< PBatchRef >	PBatchList

typedef fileref< PBatchList * >	PBatchListRef

typedef bool(*	ChangeSignal) (long)

typedef std::set< ChangeSignal >	ChangeSignals

typedef std::map< uint64_t, ByteRangeWatch >	ByteRangeWatches

typedef std::vector< FileWatch >	FileWatches

typedef std::pair< bool, uint64_t >	IsArrOldVal

typedef std::pair< uint64_t, IsArrOldVal >	OffsetData

typedef std::pair< const array< char > , const array< OffsetData > >	FileWatchData

typedef std::vector< std::string >	ModulePaths

typedef std::map< std::string, int >	NameIndexing

typedef std::pair< std::string, region * >	NamedRegion

typedef std::vector< NamedRegion >	Regions

typedef std::map< int, eventcbclosure * >	EventClosures

typedef std::set< Client * >	Connections

typedef void(*	ThunkF) ()

typedef std::vector< ThunkF >	ThunkFs

typedef std::map< int, const char * >	Signames

typedef std::set< TEnvPtr >	TEnvs

typedef std::pair< ExprPtr, PrimitivePtr >	ExprCheck

typedef std::vector< ExprCheck >	ExprChecks

typedef std::map< size_t, ExprPtr >	RowResults

typedef std::map< std::string, llvm::Value * >	Args

typedef std::map< stateidx_t, llvm::BasicBlock * >	StateBranches

typedef variant< int, long >	IDFATransition

typedef array< std::pair< long, IDFATransition > >	IDFATransitions

typedef std::unordered_map< std::string, size_t >	ArgPos

typedef std::unordered_map< size_t, size_t >	GlobalToLocalState

typedef std::map< std::string, Patterns >	NamedPatternGroups

typedef uint8_t	rchar_t

typedef std::pair< rchar_t, rchar_t >	CharRange

typedef std::vector< CharRange >	CharRanges

typedef std::pair< size_t, std::set< rchar_t > >	DCharset

typedef std::pair< size_t, RegexPtr >	DRegex

typedef uint32_t	state

typedef std::set< state >	stateset

typedef uint32_t	result

typedef range_map< rchar_t, stateset, char_range_ord >	ntransitions

typedef std::map< result, str::set >	srcmarkers

typedef std::vector< NFAState >	NFA

typedef std::map< state, stateset >	EpsClosure

typedef std::vector< bool >	statemarks

typedef range_map< rchar_t, state, char_range_ord >	dtransitions

typedef std::vector< DFAState >	DFA

typedef std::map< stateset, state >	Nss2Ds

typedef std::map< state, state >	EqStates

typedef std::vector< const TClass * >	Classes

typedef unique_refc_map< const Prim, std::string, MonoTypePtr >	PrimMem

typedef unique_refc_map< const OpaquePtr, std::string, unsigned int, bool >	OpaquePtrMem

typedef unique_refc_map< const TVar, std::string >	TVarMem

typedef unique_refc_map< const TGen, int >	TGenMem

typedef unique_refc_map< const TAbs, str::seq, MonoTypePtr >	TAbsMem

typedef unique_refc_map< const TApp, MonoTypePtr, MonoTypes >	TAppMem

typedef unique_refc_map< const FixedArray, MonoTypePtr, MonoTypePtr >	FixedArrayMem

typedef unique_refc_map< const Array, MonoTypePtr >	ArrayMem

typedef unique_refc_map< const Variant, Variant::Members >	VariantMem

typedef unique_refc_map< const Record, Record::Members >	RecordMem

typedef unique_refc_map< const Func, MonoTypePtr, MonoTypePtr >	FuncMem

typedef unique_refc_map< const Exists, std::string, MonoTypePtr >	ExistsMem

typedef unique_refc_map< const Recursive, std::string, MonoTypePtr >	RecursiveMem

typedef unique_refc_map< const TString, std::string >	TStringMem

typedef unique_refc_map< const TLong, long >	TLongMem

typedef unique_refc_map< const TExpr, std::string >	TExprMem

typedef unique_refc_maps< PrimMem, OpaquePtrMem, TVarMem, TGenMem, TAbsMem, TAppMem, FixedArrayMem, ArrayMem, VariantMem, RecordMem, FuncMem, ExistsMem, RecursiveMem, TStringMem, TLongMem, TExprMem >	MTypeCtorMaps

typedef std::map< std::string, terminal * >	symbols

typedef std::map< char, terminal * >	chars

typedef std::vector< terminals >	prefixes

typedef terminalset(*	ptsappend) (const terminalset &, const terminalset &)

typedef clos1< parserdef, transition, terminalset >	DRT

typedef clos2< parserdef, transition, transition, bool >	readsT

typedef clos1< transition_lookahead, transition, terminalset >	RT

typedef clos2< parserdef, transition, transition, bool >	includesT

typedef std::stack< BuffOrFilenamePtr >	AnnContextStack

Functions
void	compileBootCode (cc &ctx)

void	initStorageFileDefs (FieldVerifier *, cc &)

bool	isDBFile (const std::string &)

bool	storedAsArray (const MonoTypePtr &)

size_t	storageSizeOf (const MonoTypePtr &)

void	ensureDirExists (const std::string &)

std::string	uniqueFilename (const std::string &prefix, const std::string &suffix)

std::string	moveToUniqueFilename (const std::string &oldpath, const std::string &fprefix, const std::string &fsuffix)

MonoTypePtr	filerefty (const MonoTypePtr &t)

void	initSignalsDefs (FieldVerifier *, cc &)

template<typename T >
T	compileTo (cc *c, const str::seq &vns, const std::string &expr)

llvm::Value *	toLLVM (jitcc *, const ExprPtr &exp)

llvm::Value *	toLLVM (jitcc *e, const std::string &vname, const ExprPtr &exp)

llvm::ConstantInt *	toLLVMConstantInt (const PrimitivePtr &)

llvm::Constant *	toLLVMConstant (jitcc *, const std::string &, const ExprPtr &)

void	import (cc *, const std::string &)

void	pushModuleDir (const std::string &)

void	popModuleDir ()

void	compile (cc *, const ModulePtr &m)

llvm::Type *	llvmVarArrType (llvm::Type *elemty, int size=1)

llvm::Type *	toLLVM (const MonoTypePtr &, bool asArg=false)

Types	toLLVM (const MonoTypes &, bool asArg=false)

bool	hasPointerRep (const MonoTypePtr &t)

bool	hasPointerRep (const PolyTypePtr &t)

bool	isLargeType (const MonoTypePtr &mty)

void	initDefOperators (cc *)

void	initStdFuncDefs (cc &ctx)

char *	memalloc (long n)

const array< char > *	makeString (const std::string &x)

std::string	makeStdString (const array< char > *x)

Values	compile (jitcc *, const Exprs &)

Values	compileArgs (jitcc *, const Exprs &)

void	addTimer (timerfunc f, int millisecInterval)

void	registerEventHandler (int fd, const std::function< void(int)> &fn, bool vn=false)

void	registerEventHandler (int fd, eventhandler f, void *ud, bool vn=false)

void	unregisterEventHandler (int fd)

bool	stepEventLoop ()

void	runEventLoop ()

void	runEventLoop (int microsecondDuration)

int	installHTTPD (int port, HTTPRequestHandler, void *ud=0)

const array< char > *	makeString (region &m, const char *s)

const array< char > *	makeString (region &m, const std::string &s)

const array< char > *	makeString (region &m, const char *s, size_t len)

const array< char > *	makeString (const char *s, size_t len)

std::ostream &	operator<< (std::ostream &out, const array< char > *x)

template<typename T >
array< T > *	makeArray (region &m, long n)

template<typename T >
array< T > *	makeArray (long n)

template<typename T , typename ... Args>
T *	make (const Args &... args)

void	resetMemoryPool ()

std::string	showMemoryPool ()

size_t	addThreadRegion (const std::string &, region *)

size_t	findThreadRegion (const std::string &)

void	removeThreadRegion (size_t)

size_t	setThreadRegion (size_t)

void	initNetworkDefs (cc &)

int	lookupPort (const std::string &)

int	allocateServer (int port)

int	allocateServer (const std::string &port)

int	connectSocket (const std::string &host, int port)

int	connectSocket (const std::string &hostport)

int	allocateFileSocketServer (const std::string &filepath)

std::string	remoteHostname (int socket)

int	installNetREPL (int port, Server *)

int	installNetREPL (const std::string &, Server *)

int	installNetREPL (int port, cc *)

int	installNetREPL (const std::string &, cc *)

void	spawn (const std::string &, proc *)

void	procDefine (proc *, const std::string &, const std::string &)

void	procEval (proc *, const std::string &)

void	procTypeof (proc *p, const std::string &x)

void	procTypeEnv (proc *p)

void	procRead (proc , std::ostream , uint64_t waitUS=0)

MonoTypePtr	refinedType (const proc &p, const std::string &fname, const MonoTypePtr &hasty)

int	invocationID (const proc &p, const std::string &fname, const MonoTypePtr &hasty)

PrepProcExpr	procPrepareExpr (const proc &, const ExprPtr &)

void	runMachineREPL (cc *)

MonoTypePtr	mkPidTy (long pid)

const TLong *	pidTy (const MonoTypePtr &mty)

ExprPtr	closureConvert (const TEnvPtr &rootTEnv, const ExprPtr &e)

ExprPtr	closureConvert (const TEnvPtr &rootTEnv, const std::string &vn, const ExprPtr &e)

void	typeSeqForm (const ConstraintPtr &, MonoTypes *)

std::string	show (const Expr &e)

std::string	show (const Expr *e)

std::string	show (const ExprPtr &e)

std::string	show (const Definition &d)

std::string	showAnnotated (const Expr &e)

std::string	showAnnotated (const Expr *e)

std::string	showAnnotated (const ExprPtr &e)

std::string	showAnnotated (const Definition &d)

ExprPtr	constant (bool x, const LexicalAnnotation &la)

ExprPtr	constant (uint8_t x, const LexicalAnnotation &la)

ExprPtr	constant (int x, const LexicalAnnotation &la)

ExprPtr	constant (long x, const LexicalAnnotation &la)

ExprPtr	constant (size_t x, const LexicalAnnotation &la)

ExprPtr	var (const std::string &vn, const LexicalAnnotation &la)

Exprs	vars (const std::vector< std::string > &vns, const LexicalAnnotation &la)

ExprPtr	var (const std::string &vn, const QualTypePtr &ty, const LexicalAnnotation &la)

ExprPtr	var (const std::string &vn, const MonoTypePtr &ty, const LexicalAnnotation &la)

ExprPtr	let (const std::string &vn, const ExprPtr &e, const ExprPtr &b, const LexicalAnnotation &la)

ExprPtr	let (const Definitions &bs, const ExprPtr &b, const LexicalAnnotation &la)

ExprPtr	let (const Exprs &es, const ExprPtr &b, const LexicalAnnotation &la)

ExprPtr	mktunit (const LexicalAnnotation &la)

ExprPtr	mkrecord (const MkRecord::FieldDefs &fds, const LexicalAnnotation &la)

ExprPtr	mktuple (const ExprPtr &e, const LexicalAnnotation &la)

ExprPtr	proj (const ExprPtr &rec, const Record *rty, const std::string &field, const LexicalAnnotation &la)

ExprPtr	proj (const ExprPtr &rec, const std::string &field, const LexicalAnnotation &la)

ExprPtr	proj (const ExprPtr &rec, const str::seq &fields, const LexicalAnnotation &la)

Case::Bindings	caseOfBindings ()

template<typename ... Cases>
Case::Bindings	caseOfBindings (const char ctor, const char vname, const ExprPtr &e, Cases... cs)

template<typename ... Cases>
ExprPtr	caseOf (const ExprPtr &e, Cases... cs)

Constraints	liftConstraints (const Exprs &es)

ExprPtr	fn (const str::seq &vns, const ExprPtr &b, const LexicalAnnotation &la)

ExprPtr	fn (const std::string &vn, const ExprPtr &b, const LexicalAnnotation &la)

ExprPtr	fncall (const ExprPtr &f, const Exprs &args, const LexicalAnnotation &la)

ExprPtr	fncall (const ExprPtr &f, const ExprPtr &a, const LexicalAnnotation &la)

ExprPtr	closcall (const ExprPtr &c, const Exprs &args, const LexicalAnnotation &la)

ExprPtr	etaLift (const std::string &opname, const MonoTypePtr &oty, const LexicalAnnotation &la)

Expr *	mkarray (const std::vector< unsigned char > &v, const LexicalAnnotation &la)

Expr *	mkarray (const std::string &v, const LexicalAnnotation &la)

ExprPtr	switchE (const ExprPtr &e, const Switch::Bindings &bs, const ExprPtr &def, const LexicalAnnotation &la)

ExprPtr	assume (const ExprPtr &e, const QualTypePtr &t, const LexicalAnnotation &la)

ExprPtr	assume (const ExprPtr &e, const MonoTypePtr &t, const LexicalAnnotation &la)

ExprPtr	justE (const ExprPtr &e, const LexicalAnnotation &la)

ExprPtr	nothingE (const LexicalAnnotation &la)

ExprPtr	nothingE (const MonoTypePtr &jt, const LexicalAnnotation &la)

ExprPtr	assign (const ExprPtr &lhs, const ExprPtr &rhs, const LexicalAnnotation &la)

Exprs	exprs (const MkRecord::FieldDefs &ms)

Exprs	exprs (const Case::Bindings &bs)

ExprPtr	substitute (const VarMapping &vm, const ExprPtr &e, bool *mapped=0)

ExprPtr	substitute (const MonoTypeSubst &s, const ExprPtr &e)

template<typename T >
T	switchOf (const PrimitivePtr &p, const switchConst< T > &f)

bool	isConst (const ExprPtr &)

template<typename T , typename F >
T	switchOfF (const Expr &e, F f)

template<typename T >
T	switchOf (const Expr &e, const switchExpr< T > &f)

template<typename T >
T	switchOf (const ExprPtr &e, const switchExpr< T > &f)

template<typename T >
T	switchOf (const ExprPtr &e, const switchExprM< T > &f)

template<typename T >
std::vector< T >	switchOf (const Exprs &es, const switchExpr< T > &f)

template<typename T >
std::vector< T >	switchOf (const Exprs &es, const switchExprM< T > &f)

template<typename K , typename T >
std::vector< std::pair< K, T > >	switchOf (const std::vector< std::pair< K, ExprPtr > > &kes, const switchExpr< T > &f)

template<typename K , typename T >
std::vector< std::pair< K, T > >	switchOf (const std::vector< std::pair< K, ExprPtr > > &kes, const switchExprM< T > &f)

Case::Bindings	switchOf (const Case::Bindings &bs, const switchExpr< ExprPtr > &f)

const MonoTypePtr &	requireMonotype (const ExprPtr &)

MonoTypes	requireMonotype (const Exprs &)

ExprPtr	liftTypesAsAssumptions (const ExprPtr &e)

ExprPtr	stripExplicitAssumptions (const ExprPtr &)

const ExprPtr &	stripAssumpHead (const ExprPtr &)

VarSet	freeVars (const ExprPtr &)

VarSet	freeVars (const Expr &)

NameSet	tvarNames (const ExprPtr &)

ExprPtr	desugarComprehension (const ExprPtr &ex, const ComprehensionDefs &cdefs, const LexicalAnnotation &la)

ExprPtr	mkFormatExpr (const std::string &fmt, const LexicalAnnotation &)

PrimitivePtr	mkTimespanPrim (const str::seq &, const LexicalAnnotation &)

ExprPtr	mkTimespanExpr (const str::seq &, const LexicalAnnotation &)

PrimitivePtr	mkTimePrim (const std::string &, const LexicalAnnotation &)

ExprPtr	mkTimeExpr (const std::string &, const LexicalAnnotation &)

ExprPtr	mkDateTimeExpr (const std::string &, const LexicalAnnotation &)

PrimitivePtr	mkDateTimePrim (const std::string &, const LexicalAnnotation &)

void	encode (const PrimitivePtr &, std::ostream &)

void	decode (PrimitivePtr *, std::istream &)

void	encode (const ExprPtr &, std::ostream &)

void	decode (ExprPtr *, std::istream &)

void	encode (const ExprPtr &, std::vector< uint8_t > *)

void	decode (const std::vector< uint8_t > &, ExprPtr *)

bool	hasSingularType (const ExprPtr &)

int	tgenSize (const ExprPtr &)

void	initMacroEnvironment (const TEnvPtr &tenv)

ExprPtr	macroExpand (const ExprPtr &e)

MVarDefs	substitute (const MonoTypeSubst &, const MVarDefs &)

std::string	show (const Module &m)

std::string	show (const Module *m)

std::string	show (const ModulePtr &m)

std::string	show (const MTypeDef *)

std::string	show (const ClassDef &cd)

std::string	show (const ClassDef *cd)

std::string	show (const InstanceDef &id)

std::string	show (const InstanceDef *id)

std::string	show (const ModuleDefPtr &md)

std::string	show (const CFunDepDef &fundep)

std::string	show (const CFunDepDefs &fundeps)

template<typename T >
T	switchOf (const MState &s, const switchMState< T > &f)

template<typename T >
T	switchOf (const MStatePtr &s, const switchMState< T > &f)

stateidx_t	makeDFA (MDFA *, const PatternRows &, const LexicalAnnotation &)

stateidx_t	makeDFAState (MDFA *dfa, const PatternRows &ps)

ExprPtr	liftDFAExpr (cc *, const PatternRows &, const LexicalAnnotation &)

bool	operator== (const PatternRow &, const PatternRow &)

size_t	hash (const PatternRow &)

ExprPtr	compileMatch (cc *, const Exprs &, const PatternRows &, const LexicalAnnotation &)

ExprPtr	compileMatchTest (cc *, const ExprPtr &, const PatternPtr &, const LexicalAnnotation &)

std::string	show (const PatternPtr &p)

std::string	show (const Patterns &ps)

std::string	show (const PatternRow &pr)

template<typename T >
T	switchOf (const PatternPtr &p, const switchPattern< T > &f)

template<typename T >
std::vector< T >	switchOf (const Patterns &ps, const switchPattern< T > &f)

MatchArray *	mkpatarray (const std::vector< unsigned char > &bs, const LexicalAnnotation &la)

MatchArray *	mkpatarray (const std::string &cs, const LexicalAnnotation &la)

bool	refutable (const PatternPtr &)

bool	isUnitPat (const PatternPtr &)

void	printMatchResult (std::ostream &, const ExprPtr &)

void	printMatchTable (std::ostream &, const PatternRows &)

RegexPtr	parseRegex (const std::string &)

str::seq	bindingNames (const RegexPtr &)

CRegexes	makeRegexFn (cc *, const Regexes &, const LexicalAnnotation &)

CVarDefs	unpackCaptureVars (const std::string &strVar, const std::string &bufferVar, const CRegexes &, size_t state, const LexicalAnnotation &)

bool	dec (const ConstraintPtr &, AppendsTo *)

FunDeps	inferFundeps (const TEnvPtr &tenv, const Constraints &cs)

FunDeps	mergeFundeps (const FunDeps &lhs, const FunDeps &rhs)

bool	isClassSatisfied (const TEnvPtr &, const std::string &, const MonoTypes &, Definitions *)

bool	isClassSatisfiable (const TEnvPtr &, const std::string &, const MonoTypes &, Definitions *)

ExprPtr	unqualifyClass (const TEnvPtr &, const std::string &, const MonoTypes &, const ExprPtr &, Definitions *)

void	definePrivateClass (const TEnvPtr &tenv, const std::string &memberName, const ExprPtr &expr)

bool	isClassMember (const TEnvPtr &tenv, const std::string &memberName)

Constraints	expandHiddenTCs (const TEnvPtr &, const Constraints &)

void	serializeGroundClasses (const TEnvPtr &, std::ostream &)

void	deserializeGroundClasses (const TEnvPtr &, std::istream &, Definitions *)

std::string	show (const TClassPtr &)

std::string	show (const TCInstancePtr &)

std::string	show (const TCInstanceFnPtr &)

bool	dec (const ConstraintPtr &, HasField *)

void	upd (const ConstraintPtr &, const HasField &)

void	initStrPredicates (const TEnvPtr &)

std::string	show (const PtrAdjustmentPath &p)

bool	dec (const ConstraintPtr &, Subtype *)

template<typename T >
const T *	begin (const array< T > *d)

template<typename T >
const T *	end (const array< T > *d)

template<typename T >
T *	begin (array< T > *d)

template<typename T >
T *	end (array< T > *d)

template<typename T >
const T *	begin (const array< T > &d)

template<typename T >
const T *	end (const array< T > &d)

template<typename T >
T *	begin (array< T > &d)

template<typename T >
T *	end (array< T > &d)

	HOBBES_LIFT_PRIMITIVE (void, unit)

	HOBBES_LIFT_PRIMITIVE (unit, unit)

	HOBBES_LIFT_PRIMITIVE (bool, bool)

	HOBBES_LIFT_PRIMITIVE (char, char)

	HOBBES_LIFT_PRIMITIVE (unsigned char, byte)

	HOBBES_LIFT_PRIMITIVE (short, short)

	HOBBES_LIFT_PRIMITIVE (unsigned short, short)

	HOBBES_LIFT_PRIMITIVE (int, int)

	HOBBES_LIFT_PRIMITIVE (unsigned int, int)

	HOBBES_LIFT_PRIMITIVE (long, long)

	HOBBES_LIFT_PRIMITIVE (unsigned long, long)

	HOBBES_LIFT_PRIMITIVE (float, float)

	HOBBES_LIFT_PRIMITIVE (double, double)

template<typename T >
MonoTypePtr	prim ()

std::ostream &	operator<< (std::ostream &out, const MonoTypePtr &t)

TEnvPtr	fnFrame (const TEnvPtr &, const str::seq &, const MonoTypes &)

TEnvPtr	bindFrame (const TEnvPtr &, const std::string &, const MonoTypePtr &)

TEnvPtr	bindFrame (const TEnvPtr &, const std::string &, const QualTypePtr &)

MonoTypeSubst	substitution (const str::seq &ns, const MonoTypes &ts)

bool	satisfied (const UnqualifierPtr &, const TEnvPtr &, const ConstraintPtr &, std::vector< std::pair< std::string, std::shared_ptr< Expr > > > *)

bool	satisfied (const TEnvPtr &tenv, const ConstraintPtr &c, std::vector< std::pair< std::string, std::shared_ptr< Expr > > > *)

bool	satisfied (const TEnvPtr &tenv, const Constraints &cs, std::vector< std::pair< std::string, std::shared_ptr< Expr > > > *)

bool	satisfiable (const UnqualifierPtr &, const TEnvPtr &, const ConstraintPtr &, std::vector< std::pair< std::string, std::shared_ptr< Expr > > > *)

bool	satisfiable (const TEnvPtr &tenv, const ConstraintPtr &c, std::vector< std::pair< std::string, std::shared_ptr< Expr > > > *)

bool	satisfiable (const TEnvPtr &tenv, const Constraints &cs, std::vector< std::pair< std::string, std::shared_ptr< Expr > > > *)

std::ostream &	operator<< (std::ostream &out, const PolyTypePtr &t)

std::ostream &	operator<< (std::ostream &out, const QualTypePtr &t)

std::ostream &	operator<< (std::ostream &out, const ConstraintPtr &t)

MonoTypePtr	normIfOpaquePtr (const MonoTypePtr &ty)

unsigned int	alignment (const MonoTypePtr &)

MonoTypePtr	unpackedType (const Exists *e)

MonoTypePtr	unpackedType (const MonoTypePtr &mty)

QualTypePtr	unpackedType (const QualTypePtr &qty)

std::string	show (const PolyType &e)

std::string	show (const PolyType *e)

std::string	show (const PolyTypePtr &e)

std::string	show (const QualType &e)

std::string	show (const QualType *e)

std::string	show (const QualTypePtr &e)

std::string	show (const Constraint &e)

std::string	show (const Constraint *e)

std::string	show (const ConstraintPtr &e)

std::string	show (const MonoType &e)

std::string	show (const MonoType *e)

std::string	show (const MonoTypePtr &e)

str::seq	showNoSimpl (const MonoTypes &)

str::seq	showNoSimpl (const Constraints &)

std::string	showNoSimpl (const PolyType &e)

std::string	showNoSimpl (const PolyType *e)

std::string	showNoSimpl (const PolyTypePtr &e)

std::string	showNoSimpl (const QualType &e)

std::string	showNoSimpl (const QualType *e)

std::string	showNoSimpl (const QualTypePtr &e)

std::string	showNoSimpl (const Constraint &e)

std::string	showNoSimpl (const Constraint *e)

std::string	showNoSimpl (const ConstraintPtr &e)

std::string	showNoSimpl (const MonoType &e)

std::string	showNoSimpl (const MonoType *e)

std::string	showNoSimpl (const MonoTypePtr &e)

template<typename T , typename Ptr , typename PtrC , typename F >
T	switchOfF (Ptr ty, F f)

template<typename T >
T	switchOf (const MonoType &ty, const switchType< T > &f)

template<typename T >
T	switchOf (const MonoTypePtr &ty, const switchType< T > &f)

template<typename T >
std::vector< T >	switchOf (const MonoTypes &ts, const switchType< T > &f)

template<typename T >
T	switchOf (const MonoTypes &ts, T s, T(*appendF)(T, T), const switchType< T > &f)

template<typename K , typename T >
std::vector< std::pair< K, T > >	switchOf (const std::vector< std::pair< K, MonoTypePtr > > &kts, const switchType< T > &f)

template<typename T >
Variant::Members	switchOf (const Variant::Members &ms, const switchType< T > &f)

template<typename T >
Record::Members	switchOf (const Record::Members &ms, const switchType< T > &f)

MonoTypes	selectTypes (const Variant::Members &ms)

str::seq	selectNames (const Variant::Members &ms)

MonoTypePtr	clone (const MonoTypePtr &)

MonoTypePtr	clone (const MonoType *)

MonoTypePtr	clone (const MonoType &)

QualTypePtr	cloneP (const QualTypePtr &p)

MonoTypePtr	cloneP (const MonoTypePtr &p)

QualTypePtr	lookupFieldType (const QualTypePtr &qt, const std::string &fieldName)

MonoTypePtr	lookupFieldType (const MonoTypePtr &mt, const std::string &fieldName)

Constraints	mergeConstraints (const Constraints &lhs, const Constraints &rhs)

void	mergeConstraints (const Constraints &fcs, Constraints *tcs)

MonoTypes	tgens (int vs)

int	tgenSize (const MonoTypePtr &mt)

int	tgenSize (const MonoTypes &mts)

int	tgenSize (const Constraints &cs)

int	tgenSize (const ConstraintPtr &c)

int	tgenSize (const QualTypePtr &qt)

TGenVarSet	tgenVars (const MonoTypePtr &)

TVName	canonicalName (int v)

MonoTypeSubst	canonicalNameSubst (const NameSet &ns)

TVName	freshName ()

Names	freshNames (int vs)

MonoTypePtr	freshTypeVar ()

MonoTypes	freshTypeVars (int vs)

MonoTypes	typeVars (const Names &ns)

MonoTypes	freshen (const MonoTypes &)

ConstraintPtr	freshen (const ConstraintPtr &)

Constraints	freshen (const Constraints &cs)

QualTypePtr	instantiate (int vs, const QualTypePtr &scheme)

Constraints	instantiate (int vs, const Constraints &cs)

ConstraintPtr	instantiate (int vs, const ConstraintPtr &c)

MonoTypePtr	instantiate (int vs, const MonoTypePtr &mt)

MonoTypes	instantiate (int vs, const MonoTypes &ts)

QualTypePtr	instantiate (const Names &ns, const QualTypePtr &scheme)

Constraints	instantiate (const Names &ns, const Constraints &cs)

ConstraintPtr	instantiate (const Names &ns, const ConstraintPtr &c)

MonoTypePtr	instantiate (const Names &ns, const MonoTypePtr &mt)

MonoTypes	instantiate (const Names &ns, const MonoTypes &ts)

QualTypePtr	instantiate (const MonoTypes &ts, const QualTypePtr &scheme)

Constraints	instantiate (const MonoTypes &ts, const Constraints &cs)

ConstraintPtr	instantiate (const MonoTypes &ts, const ConstraintPtr &c)

MonoTypePtr	instantiate (const MonoTypes &ts, const MonoTypePtr &mt)

MonoTypes	instantiate (const MonoTypes &ts, const MonoTypes &sts)

NameSet	tvarNames (const QualTypePtr &qt)

NameSet	tvarNames (const Constraints &cs)

NameSet	tvarNames (const ConstraintPtr &c)

NameSet	tvarNames (const MonoTypePtr &mt)

NameSet	tvarNames (const MonoType &mt)

NameSet	tvarNames (const MonoTypes &mts)

void	tvarNames (const QualTypePtr &qt, NameSet *out)

void	tvarNames (const Constraints &cs, NameSet *out)

void	tvarNames (const ConstraintPtr &c, NameSet *out)

void	tvarNames (const MonoTypePtr &mt, NameSet *out)

void	tvarNames (const MonoType &mt, NameSet *out)

void	tvarNames (const MonoTypes &mts, NameSet *out)

bool	isFreeVarNameIn (const TVName &, const MonoTypePtr &)

bool	isFreeVarNameIn (const TVName &, const MonoTypes &)

bool	hasFreeVariables (const QualTypePtr &)

bool	hasFreeVariables (const Constraints &)

bool	hasFreeVariables (const ConstraintPtr &)

bool	hasFreeVariables (const MonoTypePtr &)

bool	hasFreeVariables (const MonoTypes &)

void	show (const MonoTypeSubst &s, std::ostream &out)

std::string	show (const MonoTypeSubst &s)

QualTypePtr	substitute (const MonoTypeSubst &s, const QualTypePtr &qt)

Constraints	substitute (const MonoTypeSubst &s, const Constraints &cs)

ConstraintPtr	substitute (const MonoTypeSubst &s, const ConstraintPtr &p)

MonoTypePtr	substitute (const MonoTypeSubst &s, const MonoType &mt)

MonoTypePtr	substitute (const MonoTypeSubst &s, const MonoTypePtr &mt)

MonoTypes	substitute (const MonoTypeSubst &s, const MonoTypes &ts)

MonoTypePtr	substituteStep (const MonoTypeSubst &s, const MonoTypePtr &mt)

PolyTypePtr	generalize (const QualTypePtr &qt)

QualTypePtr	simplifyVarNames (const PolyType &)

QualTypePtr	simplifyVarNames (const PolyTypePtr &)

ConstraintPtr	simplifyVarNames (const Constraint &)

ConstraintPtr	simplifyVarNames (const ConstraintPtr &)

QualTypePtr	simplifyVarNames (const QualType &)

QualTypePtr	simplifyVarNames (const QualTypePtr &)

MonoTypePtr	simplifyVarNames (const MonoType &)

MonoTypePtr	simplifyVarNames (const MonoTypePtr &)

MonoTypes	simplifyVarNames (const MonoTypes &mts)

MonoTypePtr	primty (const char *x)

MonoTypePtr	primty (const char *x, const MonoTypePtr &aty)

QualTypePtr	qualtype (const Constraints &cs, const MonoTypePtr &p)

QualTypePtr	qualtype (const Constraints &cs, MonoType *mt)

QualTypePtr	qualtype (const MonoTypePtr &p)

QualTypePtr	qualtype (MonoType *mt)

QualTypePtr	qualtype (const char *x)

PolyTypePtr	polytype (int tvs, const QualTypePtr &qt)

PolyTypePtr	polytype (const QualTypePtr &qt)

PolyTypePtr	polytype (const MonoTypePtr &p)

PolyTypePtr	polytype (MonoType *mt)

PolyTypePtr	polytype (const char *x)

MonoTypePtr	tgen (int i)

MonoTypePtr	tvar (const std::string &vn)

MonoTypePtr	tstring (const std::string &x)

MonoTypePtr	tuple (const MonoTypes &mtys=MonoTypes())

MonoTypePtr	sumtype (const MonoTypePtr &t0, const MonoTypePtr &t1)

MonoTypePtr	maybety (const MonoTypePtr &t)

MonoTypePtr	isMaybe (const MonoTypePtr &t)

MonoTypePtr	tstrings (const std::vector< std::string > &xs)

MonoTypePtr	functy (const MonoTypePtr &aty, const MonoTypePtr &rty)

MonoTypePtr	functy (const MonoTypes &atys, const MonoTypePtr &rty)

MonoTypePtr	closty (const MonoTypePtr &aty, const MonoTypePtr &rty)

MonoTypePtr	closty (const MonoTypes &atys, const MonoTypePtr &rty)

MonoTypePtr	tabs (const str::seq &tns, const MonoTypePtr &body)

MonoTypePtr	tapp (const MonoTypePtr &f, const MonoTypes &args)

MonoTypePtr	tlong (long x)

MonoTypePtr	texpr (const ExprPtr &x)

bool	isMonoSingular (const MonoType &)

bool	isMonoSingular (const MonoType *)

bool	isMonoSingular (const MonoTypePtr &)

bool	isMonoSingular (const QualTypePtr &)

bool	isMonotype (const QualTypePtr &qt)

bool	isMonotype (const PolyTypePtr &pt)

MonoTypePtr	requireMonotype (const QualTypePtr &qt)

MonoTypePtr	requireMonotype (const PolyTypePtr &pt)

MonoTypes	requireMonotype (const PolyTypes &pts)

MonoTypePtr	arrayty (const MonoTypePtr &ty, size_t n)

MonoTypePtr	arrayty (const MonoTypePtr &ty)

template<typename T >
MonoTypePtr	opaqueptr (bool insertcontig)

bool	isVoid (const MonoTypePtr &t)

unsigned int	sizeOf (const MonoTypePtr &mt)

bool	isUnit (const MonoTypePtr &t)

bool	isPrimName (const std::string &tn)

MonoTypePtr	unroll (const MonoTypePtr &)

void	encode (const QualTypePtr &, std::ostream &)

void	encode (const MonoTypePtr &, std::ostream &)

void	decode (QualTypePtr *, std::istream &)

void	decode (MonoTypePtr *, std::istream &)

void	encode (const QualTypePtr &, std::vector< unsigned char > *)

void	encode (const MonoTypePtr &, std::vector< unsigned char > *)

MonoTypePtr	decode (const std::vector< unsigned char > &in)

MonoTypePtr	decode (const unsigned char b, const unsigned char e)

MonoTypePtr	unalias (const MonoTypePtr &)

template<typename ... Xs>
MonoTypePtr	makeRecordType (Xs ... xs)

MonoTypePtr	fnresult (const MonoTypePtr &fty)

void	compactMTypeMemory ()

MonoTypePtr	substitute (MonoTypeUnifier *, const MonoTypePtr &)

MonoTypes	substitute (MonoTypeUnifier *, const MonoTypes &)

ConstraintPtr	substitute (MonoTypeUnifier *, const ConstraintPtr &)

Constraints	substitute (MonoTypeUnifier *, const Constraints &)

QualTypePtr	substitute (MonoTypeUnifier *, const QualTypePtr &)

ExprPtr	substitute (MonoTypeUnifier *, const ExprPtr &)

bool	unifiable (const TEnvPtr &, const MonoTypePtr &, const MonoTypePtr &)

bool	unifiable (const TEnvPtr &, const MonoTypes &, const MonoTypes &)

bool	unifiable (const TEnvPtr &, const ConstraintPtr &, const ConstraintPtr &)

bool	refine (const TEnvPtr &tenv, const ConstraintPtr &c, MonoTypeUnifier s, Definitions )

bool	refine (const TEnvPtr &tenv, const Constraints &cs, MonoTypeUnifier s, Definitions )

ExprPtr	validateType (const TEnvPtr &tenv, const ExprPtr &e, Definitions *)

ExprPtr	validateType (const TEnvPtr &tenv, const std::string &vname, const ExprPtr &e, Definitions *)

void	mgu (const ExprPtr &, const ExprPtr &, MonoTypeUnifier *)

void	mgu (const ExprPtr &, const QualTypePtr &, MonoTypeUnifier *)

void	mgu (const ExprPtr &, const MonoTypePtr &, MonoTypeUnifier *)

void	mgu (const QualTypePtr &t0, const QualTypePtr &t1, MonoTypeUnifier *u)

void	mgu (const MonoTypePtr &t0, const MonoTypePtr &t1, MonoTypeUnifier *u)

void	mgu (const MonoTypes &ts0, const MonoTypes &ts1, MonoTypeUnifier *u)

void	mgu (const ConstraintPtr &, const ConstraintPtr &, MonoTypeUnifier *)

QualLiftedMonoTypes	liftQualifiers (const QualTypes &qts)

bool	hasConstraint (const ConstraintPtr &c, const Constraints &cs)

bool	hasConstraint (const ConstraintPtr &c, const QualTypePtr &qt)

Constraints	removeConstraint (const ConstraintPtr &c, const Constraints &cs)

QualTypePtr	removeConstraint (const ConstraintPtr &c, const QualTypePtr &qt)

ExprPtr	unqualifyTypes (const TEnvPtr &tenv, const ExprPtr &e, Definitions *ds)

template<typename T >
std::string	show (const T *t)

template<typename T >
std::string	show (const std::vector< T *> &ts)

ldblines	load (const linedb::ptr &ldb, const linedb::LineCol &i, const linedb::LineCol &f)

template<typename K , typename V >
V	mapLookup (const std::map< K, V > &m, const K &k)

template<typename T >
T	switchOf (const GrammarValuePtr &p, const switchGrammarValue< T > &f)

ExprPtr	makeParser (cc *, const Grammar &, const LexicalAnnotation &)

void	removeRuleDefs (terminal s, grammar g)

void	removeRuleRefs (terminal s, grammar g)

void	undefineSymbol (terminal s, grammar g)

grammar	removeRuleDefs (terminal *s, const grammar &g)

grammar	removeRuleRefs (terminal *s, const grammar &g)

grammar	undefineSymbol (terminal *s, const grammar &g)

terminalset	definedSymbols (const grammar &g)

terminalset	topLevelSymbols (const grammar &g)

void	symbolsUsed (const grammar &g, const rule &r, terminalset *ss)

void	symbolsUsed (const grammar &g, const rules &rs, terminalset *ss)

void	symbolsUsed (const grammar &g, terminal s, terminalset ss)

terminalset	symbolsUsed (const grammar &g, terminal *s)

terminalset	symbolsUsing (const grammar &g, terminal *s)

bool	hasRule (const grammar &g, terminal *t)

bool	directlyDerivesNull (const rule &r)

bool	directlyDerivesNull (const grammar &g, terminal *s)

bool	derivesNull (const terminalset &nullAggs, const rule &r)

bool	derivesNull (const grammar &g, const terminalset &nullAggs, terminal *s)

bool	derivesNull (const grammar &g, const terminalset &nullAggs, const terminals &ss)

bool	derivesNull (const parserdef &p, terminal *s)

terminalset	symbolsDerivingNull (const grammar &g)

item	succ (const item &i)

terminal *	next (const grammar &g, const item &i)

terminalset	next (const grammar &g, const itemset &is)

terminalset	nextPrim (const grammar &g, const itemset &is)

itemset	follow (const grammar &g, const itemset &is, terminal *v)

itemsets	follow (const grammar &g, const itemset &is, const terminals &vs)

itemset	closure (const grammar &g, const itemset &is)

void	closure (const grammar &g, itemset *is)

nat	parserState (const itemset &s, parserdef *p)

state_transitions	follow (const grammar &g, const itemset &is, const terminalset &vs, parserdef *p)

parserdef	lr0parser (const grammar &g, terminal *s)

nat	follow (const parserdef &p, nat q, terminal *t)

transitionset	transitions (const parserdef &p)

bool	lookback (const parserdef &p, nat q, terminal *r, const rule &w, const transition &t)

bool	includes (const parserdef &p, const transition &x, const transition &y)

bool	reads (const parserdef &p, const transition &x, const transition &y)

terminalset	directReads (const parserdef &p, const transition &x)

transition_lookahead	Reads (const parserdef &p, const transitionset &ts)

transition_lookahead	Follow (const parserdef &p, const transitionset &ts)

parserdef	lalr1parser (const grammar &g, terminal *s)

std::ostream &	operator<< (std::ostream &out, const action &act)

lrtable	lalrTable (const parserdef &pd, const precedence &p=precedence())

lrtable	lalrTable (const grammar &g, terminal *s, const precedence &p=precedence())

void	show (std::ostream &, const lrtable &)

ExprPtr	makeParser (cc *, const Parser &, const precedence &prec, const LexicalAnnotation &)

ExprPtr	makeParser (cc , const Parser &, terminal root, const precedence &prec, const LexicalAnnotation &)

void	show (std::ostream &, const Parser &)

ModulePtr	defReadModuleFile (cc *, const std::string &)

ModulePtr	defReadModule (cc , const char )

ModulePtr	defReadModule (cc *, const std::string &)

ExprDefn	defReadExprDefn (cc *, const std::string &)

ExprPtr	defReadExpr (cc *, const std::string &)

Expr *	defVarCtor (const std::string &, const LexicalAnnotation &)

Pattern *	defPatVarCtor (const std::string &, const LexicalAnnotation &)

void	overrideVarCtor (VarCtorFn)

void	overridePatVarCtor (PatVarCtorFn)

template<typename T >
std::vector< T >	list ()

template<typename T , typename ... Ts>
std::vector< T >	list (const T &x, const Ts &... xs)

template<typename T >
std::vector< T >	range (const T &i, const T &e)

template<typename T >
bool	in (T x, const std::set< T > &xs)

template<typename T >
bool	in (T x, const std::vector< T > &xs)

template<typename T >
int	index (const std::vector< T > &xs, T x)

template<typename T >
std::vector< int >	index (const std::vector< T > &xs, const std::vector< T > &lxs)

template<typename T , typename I >
T	select (const std::vector< T > &xs, I i)

template<typename T , typename I >
std::vector< T >	select (const std::vector< T > &xs, I b, I e)

template<typename T , typename I >
std::vector< T >	select (const std::vector< T > &xs, const std::vector< I > &is)

template<typename K , typename V >
std::pair< K, V >	select (const std::map< K, V > &m, K k)

template<typename K , typename V >
std::vector< std::pair< K, V > >	select (const std::map< K, V > &m, const std::vector< K > &ks)

template<typename K , typename V >
std::map< K, V >	drop (const std::map< K, V > &m, const std::set< K > &ks)

template<typename T >
std::vector< T >	toVector (const std::set< T > &xs)

template<typename CT >
std::set< typename CT::value_type >	toSet (const CT &xs)

template<typename CT >
CT	fromSet (const std::set< typename CT::value_type > &xs)

template<typename T >
std::set< T >	setUnion (const std::set< T > &lhs, const std::set< T > &rhs)

template<typename T >
std::set< T >	setUnion (const std::vector< std::set< T > > &ss)

template<typename T >
std::set< T >	setDifference (const std::set< T > &lhs, const std::set< T > &rhs)

template<typename T >
std::set< T >	setDifference (const std::set< T > &lhs, const T &x)

template<typename K , typename V >
std::set< K >	keys (const std::map< K, V > &m)

template<typename L , typename R >
std::vector< L >	first (const std::vector< std::pair< L, R > > &xs)

template<typename K , typename V >
std::vector< V >	values (const std::map< K, V > &m)

template<typename L , typename R >
std::vector< R >	second (const std::vector< std::pair< L, R > > &xs)

template<typename L , typename R >
std::pair< std::vector< L >, std::vector< R > >	unzip (const std::vector< std::pair< L, R > > &ps)

template<typename L , typename R >
std::vector< std::pair< L, R > >	zip (const std::vector< L > &left, const std::vector< R > &right)

template<typename T >
std::vector< T >	take (const std::vector< T > &xs, size_t n)

template<typename T >
std::vector< T >	drop (const std::vector< T > &xs, size_t n)

template<typename T >
std::vector< std::string >	show (const std::vector< T > &xs)

template<typename CT , typename CCT >
CT	concat (const CCT &cs)

template<typename T >
std::vector< T >	cons (T h, std::vector< T > t)

template<typename T >
void	append (std::vector< T > *xs, const std::vector< T > &ys)

template<typename T >
std::vector< T >	append (const std::vector< T > &xs, T x)

template<typename T >
std::vector< T >	append (const std::vector< T > &xs, const std::vector< T > &ys)

std::ostream &	operator<< (std::ostream &out, const bit_table &bt)

template<typename T >
T *	autorelease (T *x)

	PRIM_CODEC (bool)

	PRIM_CODEC (unsigned char)

	PRIM_CODEC (char)

	PRIM_CODEC (short)

	PRIM_CODEC (int)

	PRIM_CODEC (long)

	PRIM_CODEC (size_t)

	PRIM_CODEC (float)

	PRIM_CODEC (double)

void	encode (const std::string &x, std::ostream &out)

void	decode (std::string *x, std::istream &in)

template<typename T >
void	encode (const std::vector< T > &xs, std::ostream &out)

template<typename T >
void	decode (std::vector< T > *xs, std::istream &in)

template<typename U , typename V >
void	encode (const std::pair< U, V > &p, std::ostream &out)

template<typename U , typename V >
void	decode (std::pair< U, V > *p, std::istream &in)

template<typename K , typename V >
void	encode (const std::map< K, V > &m, std::ostream &out)

template<typename K , typename V >
void	decode (std::map< K, V > *m, std::istream &in)

void	fdread (int fd, char *x, size_t len)

void	fdread (int fd, unsigned char *x, size_t len)

void	fdread (int fd, char *x)

void	fdread (int fd, uint8_t *x)

void	fdread (int fd, int *x)

void	fdread (int fd, uint32_t *x)

void	fdread (int fd, size_t *x)

void	fdread (int fd, std::string *x)

template<typename T >
void	fdread (int fd, std::vector< T > *xs)

void	fdwrite (int fd, const char *x, size_t len)

void	fdwrite (int fd, const unsigned char *x, size_t len)

void	fdwrite (int fd, char x)

void	fdwrite (int fd, uint8_t x)

void	fdwrite (int fd, int x)

void	fdwrite (int fd, uint32_t x)

void	fdwrite (int fd, size_t x)

void	fdwrite (int fd, const std::string &x)

template<typename T >
void	fdwrite (int fd, const std::vector< T > &xs)

bool	unmarkBadFD (int fd)

template<typename T >
void	hashAppend (std::size_t &seed, const T &x)

template<std::size_t i, typename ... Ts>
std::enable_if< i==sizeof...(Ts), void >::type	hashTuple (std::size_t *, const std::tuple< Ts... > &)

llvm::LLVMContext &	context ()

llvm::Type *	voidType ()

llvm::Type *	boolType ()

llvm::Type *	charType ()

llvm::Type *	byteType ()

llvm::Type *	shortType ()

llvm::Type *	intType ()

llvm::Type *	longType ()

llvm::Type *	floatType ()

llvm::Type *	doubleType ()

llvm::PointerType *	ptrType (llvm::Type *ty)

llvm::ArrayType *	arrayType (llvm::Type *ty, size_t sz)

llvm::StructType *	packedRecordType (const Types &tys)

llvm::StructType *	recordType (const Types &tys)

llvm::StructType *	recordType (llvm::Type *t0)

llvm::StructType *	recordType (llvm::Type t0, llvm::Type t1)

llvm::StructType *	recordType (llvm::Type t0, llvm::Type t1, llvm::Type *t2)

llvm::StructType *	recordType (llvm::Type t0, llvm::Type t1, llvm::Type t2, llvm::Type t3)

llvm::StructType *	recordType (llvm::Type t0, llvm::Type t1, llvm::Type t2, llvm::Type t3, llvm::Type *t4)

llvm::StructType *	recordType (llvm::Type t0, llvm::Type t1, llvm::Type t2, llvm::Type t3, llvm::Type t4, llvm::Type t5)

llvm::StructType *	recordType (llvm::Type t0, llvm::Type t1, llvm::Type t2, llvm::Type t3, llvm::Type t4, llvm::Type t5, llvm::Type *t6)

llvm::FunctionType *	functionType (const Types &argTys, llvm::Type *rty)

llvm::StructType *	varArrayType (llvm::Type *elemty, size_t sz=1)

llvm::Value *	cast (llvm::IRBuilder<> b, llvm::Type ty, llvm::Value *v)

llvm::Constant *	ccast (llvm::Type ty, llvm::Constant v)

llvm::Constant *	cvalue (bool x)

llvm::Constant *	cvalue (char x)

llvm::Constant *	cvalue (unsigned char x)

llvm::Constant *	cvalue (short x)

llvm::Constant *	cvalue (int x)

llvm::Constant *	cvalue (unsigned int x)

llvm::Constant *	cvalue (long x)

llvm::Constant *	cvalue (float x)

llvm::Constant *	cvalue (double x)

llvm::ConstantInt *	civalue (bool x)

llvm::ConstantInt *	civalue (char x)

llvm::ConstantInt *	civalue (unsigned char x)

llvm::ConstantInt *	civalue (short x)

llvm::ConstantInt *	civalue (int x)

llvm::ConstantInt *	civalue (unsigned int x)

llvm::ConstantInt *	civalue (long x)

llvm::GlobalVariable *	prepgv (llvm::GlobalVariable gv, unsigned int align=sizeof(void ))

llvm::Constant *	constant (llvm::Value *v, bool globalPtrRefs)

llvm::Constant *	liftAsGlobalRef (llvm::Module m, llvm::Constant c)

Constants	varArrayConstants (const Values &vs, bool globalPtrRefs)

Constants	liftAsGlobalRefs (llvm::Module *m, const Constants &cs)

llvm::Constant *	constArray (llvm::Module m, const Constants &cs, llvm::Type elemTy, bool boxAsGlobalRefs=false)

llvm::Value *	tryMkConstVarArray (llvm::IRBuilder<> b, llvm::Module m, llvm::Type *elemTy, const Values &vs, bool globalPtrRefs)

llvm::Constant *	padding (unsigned int len)

Constants	mergePadding (const Constants &cs, const Record::Members &ms)

Types	types (const Constants &cs)

Constants	recordUZConstants (const UnzRecValues &rps, const Record *rty)

Constants	liftArraysAsGlobals (llvm::Module *m, const Constants &cs, const MonoTypes &tys)

llvm::Constant *	constantRecord (llvm::Module , const Constants &cs, const Record rty)

llvm::Value *	tryMkConstRecord (llvm::IRBuilder<> , llvm::Module m, const RecordValue &rv, const Record *rty)

llvm::Value *	offset (llvm::IRBuilder<> b, llvm::Value p, llvm::Value *o0)

llvm::Value *	offset (llvm::IRBuilder<> b, llvm::Value p, int o0)

llvm::Value *	offset (llvm::IRBuilder<> b, llvm::Value p, int o0, int o1)

llvm::Value *	offset (llvm::IRBuilder<> b, llvm::Value p, int o0, llvm::Value *o1)

llvm::Value *	structOffset (llvm::IRBuilder<> b, llvm::Value p, unsigned int fieldOffset)

llvm::Function *	externDecl (llvm::Function remoteFn, llvm::Module thisModule)

llvm::Function *	cloneFunction (llvm::Function f, llvm::Module targetMod)

llvm::Value *	fncall (llvm::IRBuilder<> b, llvm::Value vfn, const Values &args)

llvm::Value *	fncall (llvm::IRBuilder<> b, llvm::Value fn, llvm::Value *arg)

long	tick ()

long	time ()

std::string	describeNanoTime (long x)

template<size_t i, typename ... UniqueRefcMaps>
std::enable_if< i==sizeof...(UniqueRefcMaps), size_t >::type	compactAll (std::tuple< UniqueRefcMaps... > &)

size_t	compact ()

template<typename T >
T	align (T x, T m)

template<typename T , typename S >
const T *	is (const S *s)

template<typename T , typename S >
T *	isM (S *s)

template<typename T , typename S >
T *	is (const std::shared_ptr< S > &s)

long	readTimespan (std::string s)

long	readTimespan (const str::seq &ss)

std::string	showTimespan (long ts)

long	mkTime (int h, int m, int s, int u)

long	readTime (const std::string &x)

std::string	showTime (long x)

long	mkDateTime (int y, int mon, int d, int h, int min, int s, int u)

long	timeFromDateTime (long x)

long	dateFromDateTime (long x)

long	readDateTime (const std::string &x)

std::string	showDateTime (long x)

template<typename T , typename ... Ctors>
T *	get (variant< Ctors... > &v)

template<typename T , typename ... Ctors>
const T *	get (const variant< Ctors... > &v)

MonoTypePtr	fileType (bool writeable, const MonoTypePtr &stype)

static uint32_t	fileModeFlags (const MonoTypePtr &t)

static bool	isFileMode (const MonoTypePtr &t)

static bool	isWriteable (uint32_t f)

bool	unpackFileType (const MonoTypePtr &fty, UTFileConfig *fcfg)

bool	unpackFileType (const MonoTypePtr &fty, FileConfig *fcfg)

bool	isFileType (const MonoTypePtr &fty)

FRefT	assumeFRefT (const MonoTypePtr &ty, const LexicalAnnotation &la)

MonoTypePtr	injFileReferences (const MonoTypePtr &ty, const ExprPtr &f)

unsigned int	storedOffset (const Record *rty, const std::string &lbl)

unsigned int	storedOffset (const FileConfig &fcfg, const std::string &lbl)

unsigned int	storedOffset (const MonoTypePtr &ty, const std::string &lbl)

unsigned int	storedOffset (const ExprPtr &e, const std::string &lbl)

const MonoTypePtr &	frefType (const MonoTypePtr &fref)

const MonoTypePtr &	arrType (const MonoTypePtr &arr)

char *	dbloado (long db, unsigned int o)

char *	dbloadv (long db, long offset, long sz)

char *	dbloadarr (long db, long offset)

void	dbunloadv (long db, long ptr, long sz)

void	dbunloadarr (long db, long ptr)

long	dballoc (long db, long datasz, size_t align)

long	dballocarr (long db, long elemsz, long len)

long	dbarrcapacity (long db, long elemsz, long arrref)

long	writeFileRT (const array< char > *fname, long tydef)

void	dbsignalupdate (long db)

long	readFileRT (const array< char > *fname, long tydef)

MonoTypePtr	inferFileType (reader *r)

void	printFileUF (long x)

static bool	decLF (const ConstraintPtr &c, MonoTypePtr lhs, MonoTypePtr rhs)

reader::PageEntries *	pageEntries (reader *r)

void	dbglog (const std::string &)

static void	raiseSysError (const std::string &msg, const std::string &fname)

uint16_t	restInPage (const imagefile *f, size_t idx)

size_t	pageCount (const imagefile *f, size_t sz)

static void	closeFile (imagefile *f)

static bool	loadFileSize (imagefile *f)

static void	seekAbs (const imagefile *f, size_t pos)

static off_t	filePosition (const imagefile *f)

static void	allocPages (imagefile *f, size_t pages)

static void	allocPage (imagefile *f)

template<typename T >
void	write (imagefile *f, const T &x)

template<typename TIter >
void	writes (imagefile *f, TIter begin, TIter end)

void	write (imagefile *f, const std::string &x)

void	write (imagefile *f, const std::vector< unsigned char > &xs)

template<typename T >
void	read (const imagefile f, T x)

template<typename T >
void	reads (const imagefile f, size_t sz, T x)

void	read (imagefile f, std::string x)

void	read (imagefile f, std::vector< unsigned char > xs)

size_t	pageOffset (const imagefile *f, file_pageindex_t page)

file_pageindex_t	pageIndex (const imagefile *f, uint64_t fpos)

static size_t	position (const imagefile *f, file_pageindex_t page, uint16_t offset)

file_pageindex_t	tocPageToFilePage (const imagefile *f, uint64_t tpage)

static uint64_t	tocPosToFilePos (const imagefile *f, uint64_t spos)

static size_t	pageTOCPosition (const imagefile *f, file_pageindex_t page)

static void	updatePageSizeIndex (imagefile *f, file_pageindex_t page)

static void	insertPageSizeIndex (imagefile *f, file_pageindex_t page)

static bool	findPageWithSpace (imagefile f, pagetype::code pt, size_t datalen, size_t alignment, file_pageindex_t idx)

static void	updateTOCData (imagefile *f, file_pageindex_t page, const pagedata &pd)

static void	appendTOCData (imagefile *f, const pagetable &newpages)

size_t	findSpace (imagefile *f, pagetype::code pt, size_t datalen, size_t alignment)

static void	addBinding (imagefile *f, const std::string &vname, const MonoTypePtr &type, size_t offset)

fregion &	createFileRegionMap (imagefile *f, file_pageindex_t page, size_t pages)

void	releaseFileRegionMap (imagefile *f, const fregion &fr)

template<typename K , typename V >
std::map< K, V >::iterator	gleb (std::map< K, V > &m, const K &x)

fregion &	mappedFileRegion (imagefile *f, file_pageindex_t page, size_t pages)

static char *	mapFileData (imagefile *f, size_t fpos, size_t sz)

static void	unmapFileData (imagefile f, void p, size_t sz)

uint16_t	assertValidPageSize (const imagefile *f, size_t psize)

static void	createFile (imagefile *f)

void	readPageData (imagefile *f)

static void	readEnvironmentRecord (imagefile *f)

static size_t	readEnvironmentPage (imagefile *f, file_pageindex_t p)

static void	readFile (imagefile *f)

static imagefile *	openFile (const std::string &fname, bool readonly)

MonoTypePtr	mkFR (const MonoTypePtr &t)

std::string	showPageDesc (const pagedata &pd)

std::string	withUniqueFilenameBy (const std::string &fprefix, const std::string &fsuffix, const std::function< bool(const std::string &)> &fileOp)

static MonoTypePtr	entuple (const MonoTypePtr &ty)

static MonoTypePtr	filerefTy (const MonoTypePtr &ty)

static MonoTypePtr	storedListOf (const MonoTypePtr &ty)

static MonoTypePtr	storedStreamOf (const MonoTypePtr &ty)

static MonoTypePtr	storeAs (cc *c, const MonoTypePtr &ty)

static void *	storageFunction (cc *c, const MonoTypePtr &ty, const MonoTypePtr &storageType, const LexicalAnnotation &la)

static void	unsafeWriteToSeries (long ss, char *rec)

static void	unsafeWriteUnitToSeries (long ss)

void	sweepFileWatch (FileWatch &fw)

const array< FileWatchData > *	fileWatchData ()

void	addFileSignal (long file, long off, long sz, bool isArr, ChangeSignal f)

void	addFileSOSignal (long file, unsigned int so, bool isArr, ChangeSignal f)

bool	pullTypeArg (const std::string &fname, size_t idx, MonoTypePtr *p, const MonoTypePtr &ty)

const Record *	signalRecord (const MonoTypePtr &r)

ExprPtr	sigFileExpr (const ExprPtr &e)

MonoTypePtr	sigFnType (const std::string &fn, const ExprPtr &db)

llvm::GlobalVariable *	extractGlobal (llvm::Value *e)

template<typename K , typename T >
T	lookup (const std::map< K, T > &tenv, const K &n)

TEnvPtr	allocTEnvFrame (const str::seq &names, const MonoTypes &tys, const TEnvPtr &ptenv)

Values	removeUnit (const Values &vs, const MonoTypes &mts)

MonoTypes	removeUnit (const MonoTypes &mts)

Record::Members	removeUnit (const Record::Members &ms)

bool	fileExists (const std::string &fname)

bool	importObject (cc *e, const std::string &sopath)

bool	importScript (cc *e, const std::string &fname)

static ModulePaths &	modulePaths ()

NameIndexing	nameIndexing (const str::seq &ns)

NameIndexing	nameIndexing (const std::set< std::string > &ns)

int	nameIndex (const NameIndexing &ns, const std::string &vn)

std::vector< int >	nameIndex (const NameIndexing &ns, const str::seq &vns)

MonoTypeSubst	substitution (const NameIndexing &ns)

MonoTypeSubst	uvarSubstitution (const NameIndexing &ns)

void	resolveNames (const NameIndexing &ns, const CFunDepDef &nfdep, FunDeps *out)

FunDeps	resolveNames (const NameIndexing &ns, const CFunDepDefs &nfdeps)

TClass::Members	resolveMembers (const MonoTypeSubst &s, const MVarTypeDefs &mvtds)

void	compile (cc e, const ClassDef cd)

MemberMapping	compileMembers (MonoTypeUnifier u, const TClassPtr &c, const MonoTypes &targs, cc e, const MVarDefs &ds, bool asfn)

void	compile (cc e, const InstanceDef id)

void	compile (cc e, const MImport mimp)

void	compile (cc e, const MTypeDef mtd)

void	compile (cc e, const MVarDef mvd)

void	compile (cc e, const MVarTypeDef vtd)

llvm::Type *	llvmPrim (const std::string &name, bool asArg)

	IOP (not, CreateNot, bool, bool)

	IOP (bnot, CreateNot, unsigned char, unsigned char)

	CASTOP (b2i, llvm::Instruction::ZExt, unsigned char, int)

	CASTOP (b2l, llvm::Instruction::ZExt, unsigned char, long)

	CASTOP (i2d, llvm::Instruction::SIToFP, int, double)

	CASTOP (i2f, llvm::Instruction::SIToFP, int, float)

	CASTOP (i2l, llvm::Instruction::SExt, int, long)

	CASTOP (l2d, llvm::Instruction::SIToFP, long, double)

	CASTOP (l2f, llvm::Instruction::SIToFP, long, float)

	CASTOP (s2i, llvm::Instruction::SExt, short, int)

	CASTOP (f2d, llvm::Instruction::FPExt, float, double)

	CASTOP (tl2i, llvm::Instruction::Trunc, long, int)

	CASTOP (ti2s, llvm::Instruction::Trunc, int, short)

	CASTOP (ti2b, llvm::Instruction::Trunc, int, unsigned char)

	CASTOP (tl2b, llvm::Instruction::Trunc, long, unsigned char)

	IOP (sneg, CreateNeg, short, short)

	IOP (ineg, CreateNeg, int, int)

	IOP (lneg, CreateNeg, long, long)

	IOP (fneg, CreateFNeg, float, float)

	IOP (dneg, CreateFNeg, double, double)

	BOP (ceq, CreateICmpEQ, char, char, bool)

	BOP (cneq, CreateICmpNE, char, char, bool)

	BOP (clt, CreateICmpULT, char, char, bool)

	BOP (clte, CreateICmpULE, char, char, bool)

	BOP (cgt, CreateICmpUGT, char, char, bool)

	BOP (cgte, CreateICmpUGE, char, char, bool)

	BOP (beq, CreateICmpEQ, unsigned char, unsigned char, bool)

	BOP (bneq, CreateICmpNE, unsigned char, unsigned char, bool)

	BOP (blt, CreateICmpULT, unsigned char, unsigned char, bool)

	BOP (blte, CreateICmpULE, unsigned char, unsigned char, bool)

	BOP (bgt, CreateICmpUGT, unsigned char, unsigned char, bool)

	BOP (bgte, CreateICmpUGE, unsigned char, unsigned char, bool)

	BOP (bshl, CreateShl, unsigned char, unsigned char, unsigned char)

	BOP (blshr, CreateLShr, unsigned char, unsigned char, unsigned char)

	BOP (bashr, CreateAShr, unsigned char, unsigned char, unsigned char)

	BOP (band, CreateAnd, unsigned char, unsigned char, unsigned char)

	BOP (bor, CreateOr, unsigned char, unsigned char, unsigned char)

	BOP (bxor, CreateXor, unsigned char, unsigned char, unsigned char)

	BOP (cadd, CreateAdd, char, char, char)

	BOP (csub, CreateSub, char, char, char)

	BOP (cmul, CreateMul, char, char, char)

	BOP (cdiv, CreateSDiv, char, char, char)

	BOP (crem, CreateSRem, char, char, char)

	BOP (badd, CreateAdd, unsigned char, unsigned char, unsigned char)

	BOP (bsub, CreateSub, unsigned char, unsigned char, unsigned char)

	BOP (bmul, CreateMul, unsigned char, unsigned char, unsigned char)

	BOP (bdiv, CreateSDiv, unsigned char, unsigned char, unsigned char)

	BOP (brem, CreateSRem, unsigned char, unsigned char, unsigned char)

	BOP (sadd, CreateAdd, short, short, short)

	BOP (ssub, CreateSub, short, short, short)

	BOP (smul, CreateMul, short, short, short)

	BOP (sdiv, CreateSDiv, short, short, short)

	BOP (srem, CreateSRem, short, short, short)

	BOP (seq, CreateICmpEQ, short, short, bool)

	BOP (sneq, CreateICmpNE, short, short, bool)

	BOP (slt, CreateICmpSLT, short, short, bool)

	BOP (slte, CreateICmpSLE, short, short, bool)

	BOP (sgt, CreateICmpSGT, short, short, bool)

	BOP (sgte, CreateICmpSGE, short, short, bool)

	BOP (iadd, CreateAdd, int, int, int)

	BOP (isub, CreateSub, int, int, int)

	BOP (imul, CreateMul, int, int, int)

	BOP (idiv, CreateSDiv, int, int, int)

	BOP (irem, CreateSRem, int, int, int)

	BOP (ishl, CreateShl, int, int, int)

	BOP (ilshr, CreateLShr, int, int, int)

	BOP (iashr, CreateAShr, int, int, int)

	BOP (iand, CreateAnd, int, int, int)

	BOP (ior, CreateOr, int, int, int)

	BOP (ixor, CreateXor, int, int, int)

	BOP (ieq, CreateICmpEQ, int, int, bool)

	BOP (ineq, CreateICmpNE, int, int, bool)

	BOP (ilt, CreateICmpSLT, int, int, bool)

	BOP (ilte, CreateICmpSLE, int, int, bool)

	BOP (igt, CreateICmpSGT, int, int, bool)

	BOP (igte, CreateICmpSGE, int, int, bool)

	BOP (ladd, CreateAdd, long, long, long)

	BOP (lsub, CreateSub, long, long, long)

	BOP (lmul, CreateMul, long, long, long)

	BOP (ldiv, CreateSDiv, long, long, long)

	BOP (lrem, CreateSRem, long, long, long)

	BOP (lshl, CreateShl, long, long, long)

	BOP (llshr, CreateLShr, long, long, long)

	BOP (lashr, CreateAShr, long, long, long)

	BOP (land, CreateAnd, long, long, long)

	BOP (lor, CreateOr, long, long, long)

	BOP (lxor, CreateXor, long, long, long)

	BOP (leq, CreateICmpEQ, long, long, bool)

	BOP (lneq, CreateICmpNE, long, long, bool)

	BOP (llt, CreateICmpSLT, long, long, bool)

	BOP (llte, CreateICmpSLE, long, long, bool)

	BOP (lgt, CreateICmpSGT, long, long, bool)

	BOP (lgte, CreateICmpSGE, long, long, bool)

	BOP (fadd, CreateFAdd, float, float, float)

	BOP (fsub, CreateFSub, float, float, float)

	BOP (fmul, CreateFMul, float, float, float)

	BOP (fdiv, CreateFDiv, float, float, float)

	BOP (feq, CreateFCmpOEQ, float, float, bool)

	BOP (fneq, CreateFCmpONE, float, float, bool)

	BOP (flt, CreateFCmpOLT, float, float, bool)

	BOP (flte, CreateFCmpOLE, float, float, bool)

	BOP (fgt, CreateFCmpOGT, float, float, bool)

	BOP (fgte, CreateFCmpOGE, float, float, bool)

	BOP (dadd, CreateFAdd, double, double, double)

	BOP (dsub, CreateFSub, double, double, double)

	BOP (dmul, CreateFMul, double, double, double)

	BOP (ddiv, CreateFDiv, double, double, double)

	BOP (deq, CreateFCmpOEQ, double, double, bool)

	BOP (dneq, CreateFCmpONE, double, double, bool)

	BOP (dlt, CreateFCmpOLT, double, double, bool)

	BOP (dlte, CreateFCmpOLE, double, double, bool)

	BOP (dgt, CreateFCmpOGT, double, double, bool)

	BOP (dgte, CreateFCmpOGE, double, double, bool)

size_t	stdstrsize (const std::string &x)

char	stdstrelem (const std::string &x, size_t i)

region &	threadRegion ()

static Regions &	threadRegions ()

size_t	makeMemRegion (const array< char > *n)

char *	memallocz (long n)

	DEFINE_STRUCT (RegionState,(const array< char > *, name),(size_t, id),(size_t, allocated),(size_t, used),(size_t, wasted))

array< RegionState > *	getMemoryPool ()

void	printMemoryPool ()

void	clearMemoryPool ()

void	abortAtMemUsage (size_t maxsz)

const array< char > *	showChar (char c)

const maybe< char >::ty *	readChar (const array< char > *x)

const array< char > *	showByteV (unsigned char b)

const array< char > *	showByte (unsigned char b)

const maybe< unsigned char >::ty *	readByte (const array< char > *x)

template<typename T >
const maybe< T >::ty *	readISV (const array< char > *x)

const array< char > *	showShort (short s)

const maybe< short >::ty *	readShort (const array< char > *x)

const array< char > *	showInt (int x)

const maybe< int >::ty *	readInt (const array< char > *x)

const array< char > *	showLong (long x)

const maybe< long >::ty *	readLong (const array< char > *x)

const array< char > *	showFloat (float x, int p)

const maybe< float >::ty *	readFloat (const array< char > *x)

const array< char > *	showDouble (double x, int p)

const maybe< double >::ty *	readDouble (const array< char > *x)

const array< char > *	showString (std::string *x)

const array< char > *	showTimespanV (timespanT x)

const array< char > *	showTimeV (timeT x)

const array< char > *	showDateTimeV (datetimeT x)

std::string	showUS (int64_t us)

const array< char > *	formatTimeV (const array< char > *fmt, long tus)

const array< char > *	formatDateTime (const array< char > *fmt, datetimeT x)

datetimeT	now ()

datetimeT	truncDate (datetimeT t)

timeT	truncTime (datetimeT t)

datetimeT	datetimeAt (datetimeT dt, timeT t)

timespanT	gmtoffset (datetimeT x)

std::ostringstream &	stdoutBuffer ()

void	stdoutBufferSwap (std::ostream *os)

void	captureStdout ()

const array< char > *	releaseStdout ()

void	putStr (array< char > *x)

size_t	cstrlen (char *x)

char	cstrelem (char *x, size_t i)

long	strsize (std::string *s)

char	strelem (std::string *s, long i)

void	stdstringAssign (std::string lhs, array< char > rhs)

double	random (double low, double high)

long	lrand (long low, long high)

long	truncd (double x)

void	failvarmatch (const array< char > file, size_t line, const array< char > txt, char *addr)

void	dumpBytes (char *d, long len)

void *	runClosThread (void *clos)

long	newThread (char *clos)

void	threadWait (long x)

void	threadSleep (timespanT dt)

std::set< int > &	badFDs ()

void	markBadFD (int fd)

void	readOrMark (int fd, char *b, size_t sz)

template<typename T >
T	fdRead (int fd)

void	writeOrMark (int fd, const char *b, size_t sz)

template<typename T >
void	fdWrite (int fd, T x)

void	fdWriteChars (int fd, const array< char > *cs)

void	fdWriteBytes (int fd, const array< unsigned char > *bs)

uint8_t	compressLength (size_t len, uint8_t slen[9])

uint8_t	uncompressLength (const uint8_t data, size_t len)

size_t	crossZLibCompressBound (size_t t)

const array< uint8_t > *	compressBytes (const array< uint8_t > *bs)

const array< uint8_t > *	uncompressBytes (const array< uint8_t > *bs)

void	runEvery (timespanT dt, bool(*pf)())

void	evaluatePartialHTTPRequest (int c, void *ud)

bool	isAllocatedConnection (Client *c)

Client *	makeConnection (const std::string &hp)

Client *	decodeConnType (const MonoTypePtr &t)

bool	isPartialConnection (const MonoTypePtr &t)

MonoTypePtr	makeConnType (Client *c)

void	printConnectionUF (long x)

int	connectSocket (int r, sockaddr *saddr, size_t len)

int	connectSocket (hostent *host, int port)

int	connectFileSocket (const std::string &filepath)

void	prepareStrExpr (Server *s, int c, exprid eid, const std::string &expr, const MonoTypes &intys, const MonoTypePtr &outty)

void	evaluateNetREPLRequest (int c, void *d)

void	registerNetREPL (int s, Server *svr)

void	execProcess (const std::string &cmd)

void	runMachineREPLStep (cc *c)

static void	deadlySignal (int sig, siginfo_t , void )

static bool	dec (const ConstraintPtr &c, MonoTypePtr lhs, MonoTypePtr rhs)

static MonoTypePtr	resultType (const MonoTypePtr &ftype)

ExprPtr	makeTuple (const Exprs &exprs, const LexicalAnnotation &la)

QualTypePtr	concreteClosureMethodType (const MonoTypePtr &envty, const MonoTypes &fargtys, const MonoTypePtr &rty)

QualTypePtr	abstractClosureType (const Fn *f, const MonoTypes &fargtys, const MonoTypePtr &rty)

ExprPtr	closLookup (const std::string &envVarName, const VarSet &vs, const MonoTypePtr &envty, const ExprPtr &fbody, const LexicalAnnotation &la)

ExprPtr	closureMethod (const Fn *f, const VarSet &vs, const MonoTypePtr &envty, const MonoTypes &fargtys, const MonoTypePtr &rty, const LexicalAnnotation &la)

ExprPtr	closureEnv (const VarSet &vs, const MonoTypePtr &envty, const LexicalAnnotation &la)

MonoTypePtr	concreteClosureEnvType (unsigned int size)

ExprPtr	makeClosureOver (const Fn *f, const VarSet &vs)

static bool	hasRootBinding (const std::string &vn, const TEnvPtr &tenv, const TEnvs roots)

template<typename T >
std::set< T >	set ()

template<typename T , typename ... Ts>
std::set< T >	set (const T &x, const Ts &... xs)

MaybePathPoints	focusOnFundep (const VarIDs &vs, const MonoTypes &mts)

Exprs	clones (const Exprs &es)

void	showTy (std::ostream &out, const QualTypePtr &qty)

UnitV	switchOf (const Case::Bindings &bs, const switchExprTyFnM &f)

ExprPtr	desugarCompFilter (const ExprPtr &ex, const ExprPtr &filterE, const LexicalAnnotation &la)

ExprPtr	desugarCompMap (const std::string &vn, const ExprPtr &ex, const ExprPtr &ae, const LexicalAnnotation &la)

ExprPtr	desugarCompConcat (const ExprPtr &ex, const LexicalAnnotation &la)

ExprPtr	desugarComprehensionFrom (const ExprPtr &ex, const ComprehensionDefs &cdefs, unsigned int i, const LexicalAnnotation &la)

ExprPtr	fmtFoldConst (const ExprPtr &e, const std::string &c)

ExprPtr	fmtFoldExpr (const ExprPtr &e, const std::string &expr)

void	encode (const Case::Binding &b, std::ostream &out)

void	decode (Case::Binding *b, std::istream &in)

void	encode (const Switch::Binding &b, std::ostream &out)

void	decode (Switch::Binding *b, std::istream &in)

str::seq	nameBlanks (const str::seq &xs)

MStatePtr	makeSwitch (const MDFA *dfa, const std::string &switchVar, const SwitchVal::Jumps &jmps, stateidx_t defState)

void	addRef (MDFA *dfa, stateidx_t s)

stateidx_t	addState (MDFA *dfa, const MStatePtr &state, bool addref=true)

ExprPtr	varName (MDFA *dfa, const std::string &vn)

ExprPtr	arrayElement (MDFA *dfa, const std::string &vn, size_t i)

ExprPtr	charArrElement (MDFA *dfa, const std::string &packFn, const std::string &vn, size_t i)

ExprPtr	openArray (MDFA *dfa, const std::string &vn)

ExprPtr	arraySize (MDFA *dfa, const std::string &vn)

ExprPtr	field (MDFA *dfa, const std::string &vn, const std::string &fn)

void	tableTail (PatternRows *out, const PatternRows &in)

void	dropUnusedColumns (PatternRows *out, const PatternRows &in)

void	copyRowWithoutColumn (PatternRows *out, const PatternRow &row, size_t c)

void	prependPatterns (PatternRow *row, const Patterns &ps)

Patterns	arrayPatterns (const MatchArray &ma)

Patterns	arrayAnyMatches (size_t n)

Patterns	recordFieldPatterns (const MatchRecord &mr)

template<typename MType , typename SValue , SValue()(const MType &) svalueF, void()(const MType &, PatternRows , const PatternRow &, size_t) makeMatchRow, void()(SValue, PatternRows , const PatternRow &, size_t) makeMatchAnyRow, stateidx_t()(const std::string &, SValue, MDFA , const PatternRows &) makeNextState, MStatePtr()(const std::string &, MDFA *, const std::vector< std::pair< SValue, stateidx_t > > &, stateidx_t) makeSwitchState, typename SVLT = std::less<SValue>>
MStatePtr	makeSplitState (MDFA *dfa, const PatternRows &ps, size_t c)

PrimitivePtr	litValue (const MatchLiteral &ml)

void	makeLitSplitRow (const MatchLiteral &, PatternRows *out, const PatternRow &r, size_t c)

void	makeLSAnyRow (PrimitivePtr, PatternRows *out, const PatternRow &r, size_t c)

stateidx_t	makeLSSuccState (const std::string &, PrimitivePtr, MDFA *dfa, const PatternRows &nps)

MStatePtr	makeLSSwitch (const std::string &switchVar, MDFA *dfa, const SwitchVal::Jumps &jmps, stateidx_t defState)

MStatePtr	makeLSCvtSwitch (const std::string &switchVar, MDFA *dfa, const SwitchVal::Jumps &jmps, stateidx_t defState)

bool	forConvertibility (const PatternPtr &p)

MStatePtr	makeLiteralState (MDFA *dfa, const PatternRows &ps, size_t c)

size_t	maSize (const MatchArray &ma)

void	makeASplitRow (const MatchArray &ma, PatternRows *out, const PatternRow &r, size_t c)

void	makeASAnyRow (size_t len, PatternRows *out, const PatternRow &r, size_t c)

stateidx_t	makeASSuccState (const std::string &arrayVar, size_t len, MDFA *dfa, const PatternRows &nps)

MStatePtr	makeASSwitch (const std::string &arrayVar, MDFA *dfa, const std::vector< std::pair< size_t, stateidx_t > > &lenjmps, stateidx_t defState)

MStatePtr	makeArrayState (MDFA *dfa, const PatternRows &ps, size_t c)

size_t	maxStringLen (const PatternRows &ps, size_t c)

size_t	packedSValues (size_t cs)

unsigned char	spatChar (const MatchArray &ma, size_t i)

template<typename T >
T	translatep (const MatchArray &ma, size_t i)

Patterns	sarrayPatterns (const std::string &svarName, size_t cs, const MatchArray &ma)

void	addSATableRow (size_t len, const PatternRow &r, size_t c, PatternRows *out)

MStatePtr	makeCharArrayState (MDFA *dfa, const PatternRows &ps, size_t c)

bool	canMakeCharArrayState (const PatternRows &ps, size_t c)

size_t	canMakeCharArrStateAtColumn (const PatternRows &ps)

MStatePtr	makeRecordState (MDFA *dfa, const PatternRows &ps, size_t c)

std::string	varCtor (const MatchVariant &mv)

void	makeVariantSplitRow (const MatchVariant &mv, PatternRows *out, const PatternRow &r, size_t c)

void	makeVSAnyRow (std::string, PatternRows *out, const PatternRow &r, size_t c)

stateidx_t	makeVSSuccState (const std::string &, std::string, MDFA *dfa, const PatternRows &nps)

MStatePtr	makeVSSwitch (const std::string &switchVar, MDFA *dfa, const SwitchVariant::CtorJumps &jmps, stateidx_t defState)

MStatePtr	makeVariantState (MDFA *dfa, const PatternRows &ps, size_t c)

MStatePtr	makeRegexState (MDFA *dfa, const PatternRows &ps, size_t c)

MStatePtr	makeSuccState (MDFA *dfa, const PatternRows &ps, size_t c)

size_t	columnScore (const PatternRows &ps, size_t c)

size_t	choosePivotColumn (const PatternRows &ps)

bool	isPrimSelection (bool alwaysLowerPrimMatchTables, const PatternRows &ps)

PrimFArgs	makePrimFArgs (const PatternRows &ps)

ExprPtr	liftDFAExpr (MDFA *dfa, stateidx_t state)

ExprPtr	checkExpr (const ExprChecks &cs, const LexicalAnnotation &la)

bool	compressToIfCheck (MDFA dfa, const SwitchVal &sv, IfCheck out)

ExprPtr	liftDFAExprWithSwitchCompression (MDFA *dfa, stateidx_t state)

bool	shouldInlineState (const MDFA *dfa, stateidx_t state)

ExprPtr	liftPrimMatchExpr (MDFA *dfa, stateidx_t state)

RowResults	findRowResults (MDFA *dfa, stateidx_t s)

llvm::Function *	makePrimMatchDFAFunc (const std::string &fname, MDFA *dfa, stateidx_t s, const PrimFArgs &args)

void	makeCompiledPrimMatchFunction (const std::string &fname, MDFA *dfa, stateidx_t state)

MonoTypePtr	dfaStateType ()

void	mapStatesFrom (MDFA dfa, stateidx_t state, GlobalToLocalState localstate)

size_t	localState (const GlobalToLocalState &localstate, stateidx_t state)

size_t	reads (const ArgPos &argpos, const std::string &a)

IDFATransitions *	transitions (const ArgPos &, MDFA , const SwitchVal::Jumps &, const GlobalToLocalState &, std::set< stateidx_t > , array< IDFAState > *)

IDFATransition	transitionDef (const ArgPos &, MDFA , stateidx_t, const GlobalToLocalState &, std::set< stateidx_t > , array< IDFAState > *)

void	copyStateDef (const ArgPos &argpos, MDFA dfa, stateidx_t state, const GlobalToLocalState &localstate, std::set< stateidx_t > dones, array< IDFAState > *dfaStates)

void	makeInterpretedPrimMatchFunction (const std::string &fname, MDFA *dfa, stateidx_t state)

bool	canMakeInterpretedPrimMatchFunction (MDFA *dfa, stateidx_t state)

void	normalizeRecPatterns (MatchRecord *r, const std::set< std::string > &fnames)

void	normalizeRecPatterns (const Patterns &ps, const std::set< std::string > &fnames)

NamedPatternGroups	groupRecordPatterns (const Patterns &ps)

NamedPatternGroups	groupVariantPatterns (const Patterns &ps)

Patterns	concatArrayPatterns (const Patterns &ps)

void	normalizeRecAccess (const Patterns &ps)

bool	canHoldRecPatterns (const PatternPtr &p)

void	normalizeRecAccess (const PatternRows &prs)

void	validateDimensions (size_t c, const PatternRows &ps, const LexicalAnnotation &la)

MonoTypes	matchRowType (const TEnvPtr &tenv, const PatternRows &ps)

void	validate (const TEnvPtr &tenv, size_t c, const PatternRows &ps, const LexicalAnnotation &la)

str::seq	varNames (unsigned int n)

ExprPtr	inLetExp (const str::seq &vns, const Exprs &es, const ExprPtr &b, const LexicalAnnotation &la)

VarMapping	varMapping (const Patterns &ps)

void	assignNames (const str::seq &vns, PatternRows &ps, bool *mappedVs)

void	printMatchExp (std::ostream &out, const ExprPtr &e)

void	printMatchResult (const std::string &indent, std::ostream &out, const ExprPtr &e)

template<typename T >
T	switchOf (const RegexPtr &p, const switchRegex< T > &f)

RegexPtr	epsilon ()

RegexPtr	charLit (rchar_t c)

RegexPtr	charRange (rchar_t b, rchar_t e)

RegexPtr	zeroOrMore (const RegexPtr &p)

RegexPtr	either (const RegexPtr &p0, const RegexPtr &p1)

RegexPtr	bindTo (const std::string &name, const RegexPtr &p)

RegexPtr	sequence (const RegexPtr &p0, const RegexPtr &p1)

RegexPtr	anyOf (const Regexes &rs)

CharRanges	toRanges (const std::set< rchar_t > &cs)

RegexPtr	anyOf (const std::set< rchar_t > &cs)

void	unescapeInto (rchar_t e, std::set< rchar_t > *out)

RegexPtr	unescapePatChar (rchar_t x)

void	charRange (rchar_t i, rchar_t e, std::set< rchar_t > *out)

const std::set< rchar_t > &	anyChars ()

DCharset	readCharset (const std::string &x, size_t i)

DRegex	diffRegex (const RegexPtr &lhs, const std::string &x, size_t i)

DRegex	returnR (const std::string &x, size_t k, const RegexPtr &r)

DRegex	seqR (const RegexPtr &lhs, const RegexPtr &c, const std::string &x, size_t k)

CharRanges	usedCharRanges (const NFA &nfa, const stateset &ss)

state	regexBefore (const RegexPtr &, state cont, result, NFA *)

state	accumRegex (const RegexPtr &p, result x, NFA *nfa)

std::set< rchar_t >	usedChars (const NFA &nfa)

std::string	descStates (const stateset &ss)

void	print (std::ostream &out, const NFA &nfa)

void	findEpsClosure (const NFA &nfa, state s, statemarks sms, EpsClosure ec)

void	findEpsClosure (const NFA &nfa, EpsClosure *ec)

const stateset &	epsState (const EpsClosure &ec, state s)

stateset	epsState (const EpsClosure &ec, const stateset &ss)

void	print (std::ostream &out, const EpsClosure &ec)

void	insert (stateset *o, const stateset &i)

stateset	nfaTransition (const NFA &nfa, const EpsClosure &ec, const stateset &ss, const CharRange &cr)

state	dfaState (const NFA &nfa, const EpsClosure &ec, Nss2Ds nss2ds, DFA dfa, const stateset &ss, RStates *rstates)

void	disambiguate (const NFA &nfa, DFA dfa, RStates rstates)

std::set< rchar_t >	usedChars (const DFA &dfa)

void	print (std::ostream &out, const DFA &dfa)

static ExprPtr	transitionToState (const std::string &fname, int s, const LexicalAnnotation &rootLA)

static ExprPtr	transitionAsCharSwitch (const std::string &fname, const DFAState &s, const ExprPtr &charExpr, const ExprPtr &defaultResult, const LexicalAnnotation &rootLA)

static ExprPtr	charInRange (const ExprPtr &c, const std::pair< rchar_t, rchar_t > &crange, const LexicalAnnotation &rootLA)

static ExprPtr	transitionAsRangeChecks (const std::string &fname, const std::vector< std::pair< std::pair< rchar_t, rchar_t >, state >> &ranges, const ExprPtr &charExpr, const ExprPtr &defaultResult, const LexicalAnnotation &rootLA)

static ExprPtr	transitionMapping (const std::string &fname, const DFAState &s, const ExprPtr &charExpr, const ExprPtr &defaultResult, const LexicalAnnotation &rootLA)

void	makeDFAFunc (cc *c, const std::string &fname, const DFA &dfa, const LexicalAnnotation &rootLA)

void	mergeCharRangesAndEqResults (DFA dfa, const RStates &fstates, RStates rstates)

EqStates	findEquivStates (const DFA &dfa)

DFA	removeEquivStates (const DFA &dfa, const EqStates &eqs)

MonoTypePtr	regexCaptureBufferType (const Regexes &regexes)

ExprPtr	makeRegexCaptureBuffer (const Regexes &regexes, const LexicalAnnotation &rootLA)

bool	isRecordLike (const MonoTypePtr &mt)

const Record::Members &	recordMembers (const MonoTypePtr &mt)

bool	isTupleLike (const std::string &fname)

bool	isTupleLike (const Record::Members &ms)

bool	isTupleLike (const MkRecord::FieldDefs &fds)

Record::Members	tupleNormalize (const Record::Members &ms)

MkRecord::FieldDefs	tupleNormalize (const MkRecord::FieldDefs &fds)

MonoTypePtr	makeRecordType (const Record::Members &ms)

ExprPtr	makeRecord (const MkRecord::FieldDefs &fds, const LexicalAnnotation &la)

void	failAppendRecordConstraint (const std::string &lhs, const std::string &rhs, const std::string &result)

void	importDefs (const Record::Members &ms, Record::Members *out)

MonoTypePtr	joinedRecord (const MonoTypePtr &lhs, const MonoTypePtr &rhs)

QualTypePtr	joinedRecord (const QualTypePtr &lhs, const QualTypePtr &rhs)

bool	equivalent (const TEnvPtr &tenv, const Record::Member &m0, const Record::Member &m1)

MonoTypePtr	recordSuffix (const TEnvPtr &tenv, const MonoTypePtr &lhs, const MonoTypePtr &result)

MonoTypePtr	recordPrefix (const TEnvPtr &tenv, const MonoTypePtr &rhs, const MonoTypePtr &result)

void	checkSatisfiable (const MonoTypePtr &ty)

void	tryRefine (const TEnvPtr &tenv, const MonoTypePtr &lhs, const MonoTypePtr &rhs, const MonoTypePtr &result, MonoTypeUnifier *s)

void	insertFieldDefs (const MkRecord::FieldDefs &ifds, MkRecord::FieldDefs *out)

void	insertFieldDefs (const MkRecord::FieldDefs &ifds, size_t c, MkRecord::FieldDefs *out)

void	insertFieldDefsSfx (const MkRecord::FieldDefs &ifds, size_t c, MkRecord::FieldDefs *out)

void	insertFieldDefsFromProj (const ExprPtr &rec, const Record rty, MkRecord::FieldDefs out)

void	insertFieldDefsFromProj (const ExprPtr &rec, const MonoTypePtr &rty, MkRecord::FieldDefs *out)

void	insertFieldDefsFromProj (const ExprPtr &rec, MkRecord::FieldDefs *out)

ExprPtr	recordAppendExpr (const MkRecord lhs, const MkRecord rhs)

ExprPtr	recordAppendExpr (const MkRecord *lhs, const ExprPtr &rhs)

ExprPtr	recordAppendExpr (const ExprPtr &lhs, const MkRecord *rhs)

ExprPtr	recordAppendExpr (const ExprPtr &lhs, const ExprPtr &rhs)

ExprPtr	recordAppendFunction (const MonoTypePtr &lty, const MonoTypePtr &rty, const MonoTypePtr &resty, const LexicalAnnotation &la)

ExprPtr	recordPrefixFunction (const MonoTypePtr &recty, const MonoTypePtr &resty, const LexicalAnnotation &la)

ExprPtr	recordPrefix (const ExprPtr &rec, const MonoTypePtr &resty)

ExprPtr	recordSuffixFunction (const MonoTypePtr &recty, const MonoTypePtr &resty, const LexicalAnnotation &la)

ExprPtr	recordSuffix (const ExprPtr &rec, const MonoTypePtr &resty)

bool	isHiddenTCName (const std::string &n)

void	includeFundep (const Constraint &c, const FunDep &fd, FunDeps *out)

bool	isLiteralFnTerm (const ExprPtr &e)

void	showFundep (const FunDep &fd, std::ostream &out)

const TClass *	findClass (const TEnvPtr &tenv, const std::string &cname)

void	serializeGroundInstance (const TEnvPtr &tenv, const TClass *c, const TCInstancePtr &inst, std::ostream &out)

void	serializeGroundInstances (const TEnvPtr &tenv, const TClass *c, const TCInstances &insts, std::ostream &out)

void	serializeGroundClasses (const TEnvPtr &tenv, const Classes &cs, std::ostream &out)

Record::Members	stripHiddenFields (const Record *rty)

MonoTypePtr	stripHiddenFields (const MonoTypePtr &ty)

static bool	dec (const ConstraintPtr &c, ConsRecord *cr)

ExprPtr	stripAssumps (const ExprPtr &e)

Variant::Members	normalizeCtorIDs (const Variant::Members &ms)

MonoTypePtr	normalizeCtorIDs (const MonoTypePtr &t)

static bool	dec (const ConstraintPtr &c, ConsVariant *cv)

static bool	asDestruct (const MonoTypePtr &t, MonoTypePtr *dty)

static bool	asRestruct (const MonoTypePtr &t, MonoTypePtr *rty)

static bool	dec (const ConstraintPtr &c, MonoTypePtr lhs, MonoTypePtr rhs)

static MonoTypePtr	impliedType (const std::string &fieldName)

static ExprPtr	impliedValue (const std::string &fieldName, const LexicalAnnotation &la)

static bool	decFieldName (const MonoTypePtr &fieldName, std::string *fn)

static bool	canDecFieldName (const MonoTypePtr &fieldName)

static bool	mightRewriteToLookup (const TEnvPtr &tenv, const MonoTypePtr &rty, const std::string &fieldName, const MonoTypePtr &fty, Definitions *ds)

static MonoTypePtr	rewritesToLookup (const TEnvPtr &tenv, const MonoTypePtr &rty, const std::string &fieldName, const MonoTypePtr &fty, Definitions *ds)

static ExprPtr	rewriteLookup (const TEnvPtr &tenv, const ExprPtr &r, const std::string &fieldName, const MonoTypePtr &rty, const MonoTypePtr &fty, Definitions *ds, const LexicalAnnotation &la)

static bool	isFieldName (const MonoTypePtr &fn, std::string *sfn)

static MonoTypePtr	impliedType (const std::string &fieldName)

static MonoTypePtr	impliedType (const MonoTypePtr &fieldName)

bool	mightRewriteToSLookup (const TEnvPtr &tenv, const MonoTypePtr &rty, const MonoTypePtr &fieldName, const MonoTypePtr &fty, Definitions *ds)

MonoTypePtr	rewritesToSLookup (const TEnvPtr &tenv, const MonoTypePtr &rty, const MonoTypePtr &fieldName, const MonoTypePtr &fty, Definitions *ds)

ExprPtr	rewriteSLookup (const TEnvPtr &tenv, const ExprPtr &r, const std::string &fieldName, const MonoTypePtr &rty, const MonoTypePtr &fty, Definitions *ds, const LexicalAnnotation &la)

MonoTypePtr	objViewToFlatView (const MonoTypePtr &obj, const Func *fty)

MonoTypes	trCons (const MonoTypePtr &hty, const MonoTypes &ttys)

Exprs	trCons (const ExprPtr &hexp, const Exprs &texps)

QualTypePtr	underlyingFnType (const TEnvPtr &tenv, const MonoTypePtr &rty, const std::string &fieldName, const MonoTypePtr &fty, MonoTypeUnifier *s)

QualTypePtr	underlyingFnType (const TEnvPtr &tenv, const ConstraintPtr &c)

static bool	dec (const ConstraintPtr &c, FRefLoadable *fl)

static bool	dec (const ConstraintPtr &c, MonoTypePtr lhs, MonoTypePtr rhs)

bool	isSafeExistentialType (const Exists *e)

static bool	dec (const ConstraintPtr &c, PacksTo *pt)

static void	upd (const ConstraintPtr &c, const PacksTo &pt)

static bool	dec (const ConstraintPtr &c, IsoRecur *ir)

void	appendPath (PtrAdjustmentPath *p, const PtrAdjustmentPath &sfx)

ExprPtr	applyVtblAdjustment (const ExprPtr &e, int o, const std::string &targetTy)

ExprPtr	applyOffsetAdjustment (const ExprPtr &e, int o, const std::string &targetTy)

ExprPtr	applyAdjustment (const PtrAdjustment &p, const ExprPtr &e)

ExprPtr	applyAdjustments (const PtrAdjustmentPath &p, const ExprPtr &e)

static bool	decodeTO (const ConstraintPtr &c, ExprPtr e, MonoTypePtr t)

static bool	decideTO (const TEnvPtr &tenv, Definitions ds, const ConstraintPtr &c, MonoTypePtr t0, MonoTypePtr *t1)

template<typename T >
std::string	showT (const T &t)

template<typename T >
std::string	show (const std::set< T > &ts)

bool	satisfied (const UnqualifierPtr &uq, const TEnvPtr &tenv, const ConstraintPtr &c, Definitions *ds)

bool	satisfied (const TEnvPtr &tenv, const ConstraintPtr &c, Definitions *ds)

bool	satisfied (const TEnvPtr &tenv, const Constraints &cs, Definitions *ds)

bool	satisfiable (const UnqualifierPtr &uq, const TEnvPtr &tenv, const ConstraintPtr &c, Definitions *ds)

bool	satisfiable (const TEnvPtr &tenv, const ConstraintPtr &c, Definitions *ds)

bool	satisfiable (const TEnvPtr &tenv, const Constraints &cs, Definitions *ds)

bool	isFileRef (const MonoTypePtr &mt)

MTypeCtorMaps *	tctorMaps ()

bool	showFileRef (const MonoTypePtr &f, const MonoTypes &targs, std::ostream &out)

static void	resetCtorIDs (Variant::Members *ms)

int	findHiddenMember (int i, const std::string &lbl, const Variant::Members &ms)

Variant::Members	consMember (const std::string &lbl, const MonoTypePtr &hty, const Variant::Members &tty)

static bool	hiddenCtor (const Variant::Member &m)

static void	normalizeSumFields (Variant::Members *ms)

size_t	nextVisibleMember (size_t i, const Variant::Members &ms)

void	showFullVarPayloadSuffix (const MonoTypePtr &t, std::ostream &out)

void	showFull (const Variant::Members &ms, std::ostream &out)

void	showSum (const Variant::Members &ms, std::ostream &out)

bool	looksLikeSum (const Variant::Members &ms)

Variant::Members	tailMembers (const Variant::Members &ms)

Record::Member	addoffset (const Record::Member &m, int o)

unsigned int	nextVisibleMember (unsigned int i, const Record::Members &ms)

static void	resetFieldOffsets (Record::Members *ms)

static void	normalizeTupleFields (Record::Members *ms)

Record::Members	tailMembers (bool tup, const Record::Members &ms)

unsigned int	maxFieldAlignmentF (const Record::Members &ms)

bool	isTupleDesc (const Record::Members &ms)

void	showAsTuple (std::ostream &out, const Record::Members &ms)

void	showAsRecord (std::ostream &out, const Record::Members &ms)

static std::atomic< std::size_t >	uidCtr (0)

bool	in (const ConstraintPtr &c, const Constraints &cs)

nat	nadd (nat lhs, nat rhs)

nat	nmax (nat lhs, nat rhs)

void	write (bool b, bytes *out)

void	write (char c, bytes *out)

void	write (unsigned char c, bytes *out)

void	write (int x, bytes *out)

void	write (long x, bytes *out)

void	write (size_t x, bytes *out)

void	write (unsigned int x, bytes *out)

void	write (const std::string &s, bytes *out)

template<typename T >
void	write (const std::vector< T > &xs, bytes *out)

template<typename T >
T	read (const bytes &in, unsigned int *n)

MonoTypePtr	decodeFrom (const bytes &in, unsigned int *n)

MonoTypePtr	decodePrim (const bytes &in, unsigned int *n)

MonoTypePtr	decodeOpaquePtr (const bytes &in, unsigned int *n)

MonoTypePtr	decodeTGen (const bytes &in, unsigned int *n)

MonoTypePtr	decodeTAbs (const bytes &in, unsigned int *n)

MonoTypePtr	decodeTApp (const bytes &in, unsigned int *n)

MonoTypePtr	decodeTVar (const bytes &in, unsigned int *n)

MonoTypePtr	decodeFixedArr (const bytes &in, unsigned int *n)

MonoTypePtr	decodeArr (const bytes &in, unsigned int *n)

MonoTypePtr	decodeVariant (const bytes &in, unsigned int *n)

MonoTypePtr	decodeRecord (const bytes &in, unsigned int *n)

MonoTypePtr	decodeFunc (const bytes &in, unsigned int *n)

MonoTypePtr	decodeExists (const bytes &in, unsigned int *n)

MonoTypePtr	decodeRecursive (const bytes &in, unsigned int *n)

MonoTypePtr	decodeTString (const bytes &in, unsigned int *n)

MonoTypePtr	decodeTLong (const bytes &in, unsigned int *n)

MonoTypePtr	decodeTExpr (const bytes &in, unsigned int *n)

MonoTypePtr	makeFileRef (const MonoTypePtr &ty, const MonoTypePtr &f)

void	typeCtorForm (const MonoTypePtr &ty, std::string cname, MonoTypes targs, str::seq *ignvs)

bool	refine (const TEnvPtr &tenv, const QualTypePtr &qty, MonoTypeUnifier s, Definitions ds)

bool	refine (const TEnvPtr &tenv, const ExprPtr &e, MonoTypeUnifier s, Definitions ds)

Record::Members	makeRecordMembers (const MkRecord::FieldDefs &fds, const MonoTypes &mts)

terminal *	sym (symbols *ss, const std::string &x)

terminal *	chr (chars *cs, char x)

ParseRule::Bindings	toParseRuleBindings (symbols ss, chars cs, const BoundGrammarValues &gvs)

const rules *	aggRules (const grammar &g, terminal *t)

const rule &	nthRule (const rules *rs, nat n)

terminal *	ruleElement (const rule &r, nat i)

void	show (std::ostream &out, const grammar &g, const item &i)

void	show (std::ostream &out, const grammar &g, const itemset &is)

bool	ruleItems (const grammar &g, terminal t, itemset is)

itemset	ruleItems (const grammar &g, terminal *t)

const itemset &	parserStateDef (const parserdef &p, nat n)

const state_transitions &	transitions (const parserdef &p, nat q)

bool	follows (const state_transitions &st, terminal *t)

bool	follows (const parserdef &p, nat q, terminal *t)

nat	follow (const state_transitions &st, terminal *t)

nat	follow (const parserdef &p, const transition &x)

nat	follow (const parserdef &p, nat s, const terminals &ts)

prefixes	endingAt (const parserdef &p, const rule &w, terminal *a)

void	apply (const transition_lookahead &tl, parserdef *p)

terminal *	reduceOpTerminal (const parserdef &pd, const action &a)

bool	shiftInstead (const parserdef &pd, const precedence &px, nat shs, terminal *t, const action &a)

void	addAction (const parserdef &pd, lrstate &s, terminal *t, const action &a, const precedence &px)

void	addAccept (lrstate &s, terminal *t)

void	addReduce (const parserdef &pd, lrstate &s, const terminalset &ts, terminal *agg, nat rule, nat len, const precedence &px)

void	addGoto (lrstate &s, terminal *nt, nat next)

void	addShift (const parserdef &pd, lrstate &s, terminal *t, nat next, const precedence &px)

bool	referencesSym (const grammar &g, const item &i, terminal *t)

void	beginHighlight (std::ostream &out)

void	endHighlight (std::ostream &out)

void	showHLTerm (std::ostream &out, terminal x, terminal hx)

terminalset	definedSymbols (const lrtable &t)

terminals	dispOrd (const terminalset &ts)

terminals	extractGrammarRule (const ParseRule::Bindings &bs)

grammar	extractGrammar (const Parser &p)

std::string	constructorName (terminal *t)

void	prepareEvalInfo (cc c, const Parser &p, terminal root, const precedence &prec, ParserEvalInfo *pei, const LexicalAnnotation &la)

ExprPtr	evalExpr (const ParserEvalInfo &pei, terminal *s, size_t rule)

MonoTypePtr	parseVariant (const ParserEvalInfo &pei)

MonoTypePtr	parseResultType (const ParserEvalInfo &pei)

ExprPtr	lengthOf (const ExprPtr &arr, const LexicalAnnotation &la)

ExprPtr	elementOf (const ExprPtr &arr, const ExprPtr &i, const LexicalAnnotation &la)

size_t	stateCount (const ParserEvalInfo &pei)

bool	isNonTerminal (const ParserEvalInfo &pei, terminal *t)

bool	needsOutputFunction (const ParserEvalInfo &pei, size_t i)

str::seq	varNames (size_t n)

size_t	parseDepth (const ParserEvalInfo &pei, size_t i)

str::seq	shiftVarNames (const ParserEvalInfo &pei, size_t fromS, size_t toS)

ExprPtr	parseFailure (const ParserEvalInfo &pei, size_t i)

ExprPtr	makeOutputParserState (const ParserEvalInfo &pei, size_t i)

ExprPtr	makeReduction (const ParserEvalInfo &pei, size_t i, terminal *sym, size_t rule)

ExprPtr	doAction (const ParserEvalInfo &pei, size_t i, const action &act)

ExprPtr	makeInputParserState (const ParserEvalInfo &pei, size_t i)

LetRec::Bindings	makeParserStates (const ParserEvalInfo &pei)

void	throwFileError (const std::string &fname, const YYLTYPE &errPos, const std::string &emsg)

void	throwBufferError (const char *buffer, const YYLTYPE &errPos, const std::string &emsg)

void	freeParserData ()

template<typename T >
const T &	checkReturn (const T &x)

void	runParserOnBuffer (cc *c, int initTok, YY_BUFFER_STATE bs)

void	runParserOnFile (cc *c, int initTok, const std::string &fname)

void	runParserOnString (cc c, int initTok, const char s)

str::seq	slurpLines (std::istream &in, size_t i, size_t f)

static AnnContextStack &	annotationCtxStack ()

size_t	sumAttr (const mempage *p, pattr::E a)

std::string	showPage (mempage *p)

std::string	showPages (mempage *ps)

Variables
template<size_t i, typename ... UniqueRefcMaps>
std::enable_if< i< sizeof...(UniqueRefcMaps), size_t >::type compactAll(std::tuple< UniqueRefcMaps... > &ms) { return std::get< i >ms).compact()+compactAll< i+1, UniqueRefcMaps... >ms);}template< size_t i, typename T, typename ... Ts > struct TypeIndex { static const size_t value=i;};template< size_t i, typename T, typename ... Ts > struct TypeIndex< i, T, T, Ts... > { static const size_t value=i;};template< size_t i, typename T, typename U, typename ... Ts > struct TypeIndex< i, T, U, Ts... > { static const size_t value=TypeIndex< i+1, T, Ts... >::value;};template< typename ... UniqueRefcMaps > class unique_refc_maps { private:typedef std::tuple< UniqueRefcMaps... > RefcMaps;RefcMaps refcMaps;public:template< typename T > typename std::tuple_element< TypeIndex< 0, T, UniqueRefcMaps... >::value, RefcMaps >::type &at() { return std::get< TypeIndex< 0, T, UniqueRefcMaps... >::value >this->	refcMaps

const char	timespanTNV [] = "timespan"

const char	timeTNV [] = "time"

const char	datetimeTNV [] = "datetime"

stateidx_t	nullState = (stateidx_t)-1

nulltypedb	nulltdb

static const UnitV	unitv = 0x00

const size_t	FUNCTION_SIZE_THRESHOLD = 64

template<template< class > class SzP, typename T0 , typename T1 , typename ... Ts>
	else

static const size_t	minPageSize = 256

static const size_t	maxPageSize = ((1 << 14) - 1)

static const uint32_t	filePrefixBytes = 0x10a1db0d

static const size_t	pageDataOffset = sizeof(filehead)

static __thread region *	threadRegionp = 0

static __thread Regions *	threadRegionsp = 0

static __thread size_t	currentRegion = 0

static Connections	connections

static int	machineREPLLogFD = -1

static Signames	rsignames

static const result	nullResult = (result)-1

static MonoTypePtr	stdstrty = OpaquePtr::make("std::string", 0, false)

static MonoTypePtr	chararrty = arrayty(primty("char"))

static MonoTypePtr	unitty = primty("unit")

const bool	unit = true

std::stack< YY_BUFFER_STATE >	activeParseBuffers

VarCtorFn	varCtorFn = &defVarCtor

PatVarCtorFn	patVarCtorFn = &defPatVarCtor

Typedef Documentation

◆ AnnContextStack

typedef std::stack<BuffOrFilenamePtr> hobbes::AnnContextStack

◆ annmsg

typedef std::pair<std::string, LexicalAnnotation> hobbes::annmsg

◆ annmsgs

typedef std::vector<annmsg> hobbes::annmsgs

◆ ArgPos

typedef std::unordered_map<std::string, size_t> hobbes::ArgPos

◆ Args

typedef std::map<std::string, llvm::Value*> hobbes::Args

◆ ArrayElem

typedef std::map<size_t, ExprPtr> hobbes::ArrayElem

◆ ArrayMem

typedef unique_refc_map<const Array, MonoTypePtr> hobbes::ArrayMem

◆ bindingset

typedef std::map<std::string, binding> hobbes::bindingset

◆ BoundGrammarValues

typedef std::vector<BoundGrammarValue> hobbes::BoundGrammarValues

◆ BuffOrFilename

typedef std::pair<bool, std::string> hobbes::BuffOrFilename

◆ BuffOrFilenamePtr

typedef std::shared_ptr<BuffOrFilename> hobbes::BuffOrFilenamePtr

◆ ByteRangeWatches

typedef std::map<uint64_t, ByteRangeWatch> hobbes::ByteRangeWatches

◆ bytes

typedef std::vector< unsigned char > hobbes::bytes

◆ CaptureVarsAt

typedef std::map<size_t, str::seq> hobbes::CaptureVarsAt

◆ CFunDepDef

typedef std::pair<str::seq, str::seq> hobbes::CFunDepDef

◆ CFunDepDefs

typedef std::vector<CFunDepDef> hobbes::CFunDepDefs

◆ ChangeSignal

typedef bool(* hobbes::ChangeSignal) (long)

◆ ChangeSignals

typedef std::set<ChangeSignal> hobbes::ChangeSignals

◆ CharRange

typedef std::pair<rchar_t, rchar_t> hobbes::CharRange

◆ CharRanges

typedef std::vector<CharRange> hobbes::CharRanges

◆ chars

typedef std::map<char, terminal*> hobbes::chars

◆ ClassDefPtr

typedef std::shared_ptr<ClassDef> hobbes::ClassDefPtr

◆ ClassDefs

typedef std::vector<ClassDefPtr> hobbes::ClassDefs

◆ Classes

typedef std::vector<const TClass*> hobbes::Classes

◆ ComprehensionDefs

typedef std::vector<ComprehensionDef> hobbes::ComprehensionDefs

◆ Connections

typedef std::set<Client*> hobbes::Connections

◆ Constants

typedef std::vector<llvm::Constant*> hobbes::Constants

◆ ConstFieldValue

typedef std::pair<std::string, llvm::Constant*> hobbes::ConstFieldValue

◆ ConstraintPtr

typedef std::shared_ptr<Constraint> hobbes::ConstraintPtr

◆ Constraints

typedef std::vector<ConstraintPtr> hobbes::Constraints

◆ ConstRecordValue

typedef std::vector<ConstFieldValue> hobbes::ConstRecordValue

◆ CVarDef

typedef std::pair<std::string, ExprPtr> hobbes::CVarDef

◆ CVarDefs

typedef std::vector<CVarDef> hobbes::CVarDefs

◆ datetimeT

typedef typeAlias<datetimeTNV, int64_t> hobbes::datetimeT

◆ DCharset

typedef std::pair<size_t, std::set<rchar_t> > hobbes::DCharset

◆ Definition

typedef std::pair<std::string, ExprPtr> hobbes::Definition

◆ Definitions

typedef std::vector<Definition> hobbes::Definitions

◆ DFA

typedef std::vector<DFAState> hobbes::DFA

◆ DRegex

typedef std::pair<size_t, RegexPtr> hobbes::DRegex

◆ DRT

typedef clos1<parserdef, transition, terminalset> hobbes::DRT

◆ dtransitions

typedef range_map<rchar_t, state, char_range_ord> hobbes::dtransitions

◆ EpsClosure

typedef std::map<state, stateset> hobbes::EpsClosure

◆ EqStates

typedef std::map<state, state> hobbes::EqStates

◆ EventClosures

typedef std::map<int, eventcbclosure*> hobbes::EventClosures

◆ eventhandler

typedef void(* hobbes::eventhandler) (int fd, void *ud)

◆ ExistsMem

typedef unique_refc_map<const Exists, std::string, MonoTypePtr> hobbes::ExistsMem

◆ ExprCheck

typedef std::pair<ExprPtr, PrimitivePtr> hobbes::ExprCheck

◆ ExprChecks

typedef std::vector<ExprCheck> hobbes::ExprChecks

◆ ExprDefn

typedef std::pair<std::string, ExprPtr> hobbes::ExprDefn

◆ exprid

typedef uint32_t hobbes::exprid

◆ ExprIdxs

typedef std::unordered_map<Expr*, size_t> hobbes::ExprIdxs

◆ ExprParser

typedef std::function<ExprPtr(const std::string&)> hobbes::ExprParser

◆ ExprPtr

typedef std::shared_ptr< Expr > hobbes::ExprPtr

◆ Exprs

typedef std::vector<ExprPtr> hobbes::Exprs

◆ fallocs

typedef std::map<char*, falloc> hobbes::fallocs

◆ FieldValue

typedef std::pair<std::string, llvm::Value*> hobbes::FieldValue

◆ file_pageindex_t

typedef uint64_t hobbes::file_pageindex_t

◆ FileConfig

typedef std::pair< bool, const Record * > hobbes::FileConfig

◆ FileWatchData

typedef std::pair<const array<char>*, const array<OffsetData>*> hobbes::FileWatchData

◆ FileWatches

typedef std::vector<FileWatch> hobbes::FileWatches

◆ FixedArrayMem

typedef unique_refc_map<const FixedArray, MonoTypePtr, MonoTypePtr> hobbes::FixedArrayMem

◆ fmappings

typedef std::map<file_pageindex_t, fregion> hobbes::fmappings

◆ FoldedState

typedef std::pair<std::string, ExprPtr> hobbes::FoldedState

◆ FoldedStateCalls

typedef std::unordered_map<stateidx_t, ExprPtr> hobbes::FoldedStateCalls

◆ FoldedStates

typedef std::vector<FoldedState> hobbes::FoldedStates

◆ FRefT

typedef std::pair< MonoTypePtr, ExprPtr > hobbes::FRefT

◆ FuncMem

typedef unique_refc_map<const Func, MonoTypePtr, MonoTypePtr> hobbes::FuncMem

◆ FunDep

typedef std::pair<VarIDs, int> hobbes::FunDep

◆ FunDeps

typedef std::vector<FunDep> hobbes::FunDeps

◆ GlobalToLocalState

typedef std::unordered_map<size_t, size_t> hobbes::GlobalToLocalState

◆ grammar

typedef std::map<terminal*, rules> hobbes::grammar

◆ Grammar

typedef std::vector<GrammarSymDef> hobbes::Grammar

◆ GrammarRules

typedef std::vector<GrammarRule> hobbes::GrammarRules

◆ GrammarSymDef

typedef std::pair<std::string, GrammarRules> hobbes::GrammarSymDef

◆ GrammarValuePtr

typedef std::shared_ptr<GrammarValue> hobbes::GrammarValuePtr

◆ HTTPRequestHandler

typedef void(* hobbes::HTTPRequestHandler) (const HTTPRequest &, int fd, void *ud)

◆ IDFATransition

typedef variant<int, long> hobbes::IDFATransition

◆ IDFATransitions

typedef array< std::pair<long, IDFATransition> > hobbes::IDFATransitions

◆ Idxs

typedef std::vector<size_t> hobbes::Idxs

◆ includesT

typedef clos2<parserdef, transition, transition, bool> hobbes::includesT

◆ InstanceDefPtr

typedef std::shared_ptr<InstanceDef> hobbes::InstanceDefPtr

◆ InstanceDefs

typedef std::vector<InstanceDefPtr> hobbes::InstanceDefs

◆ IsArrOldVal

typedef std::pair<bool, uint64_t> hobbes::IsArrOldVal

◆ itemset

typedef std::set<item> hobbes::itemset

◆ itemsets

typedef std::vector<itemset> hobbes::itemsets

◆ ldblines

typedef std::pair<nats, strings> hobbes::ldblines

◆ LexRange

typedef std::pair<Pos, Pos> hobbes::LexRange

◆ lrstate

typedef std::map<terminal*, action> hobbes::lrstate

◆ lrtable

typedef std::vector<lrstate> hobbes::lrtable

◆ MaybePathPoint

typedef variant<unit, MonoTypePtr> hobbes::MaybePathPoint

◆ MaybePathPoints

typedef std::vector<MaybePathPoint> hobbes::MaybePathPoints

◆ MemberMapping

typedef std::map<std::string, ExprPtr> hobbes::MemberMapping

◆ ModuleDefPtr

typedef std::shared_ptr<ModuleDef> hobbes::ModuleDefPtr

◆ ModuleDefs

typedef std::vector<ModuleDefPtr> hobbes::ModuleDefs

◆ ModulePaths

typedef std::vector<std::string> hobbes::ModulePaths

◆ ModulePtr

typedef std::shared_ptr<Module> hobbes::ModulePtr

◆ Modules

typedef std::vector<ModulePtr> hobbes::Modules

◆ MonoTypeAliasMap

typedef std::map<std::string, MonoTypePtr> hobbes::MonoTypeAliasMap

◆ MonoTypePtr

typedef MonoType::ptr hobbes::MonoTypePtr

◆ MonoTypes

typedef std::vector<MonoTypePtr> hobbes::MonoTypes

◆ MonoTypeSubst

typedef std::map<TVName, MonoTypePtr> hobbes::MonoTypeSubst

◆ MStatePtr

typedef std::shared_ptr<MState> hobbes::MStatePtr

◆ MStates

typedef std::vector<MStatePtr> hobbes::MStates

◆ MTypeCtorMaps

typedef unique_refc_maps< PrimMem, OpaquePtrMem, TVarMem, TGenMem, TAbsMem, TAppMem, FixedArrayMem, ArrayMem, VariantMem, RecordMem, FuncMem, ExistsMem, RecursiveMem, TStringMem, TLongMem, TExprMem > hobbes::MTypeCtorMaps

◆ MVarDefPtr

typedef std::shared_ptr<MVarDef> hobbes::MVarDefPtr

◆ MVarDefs

typedef std::vector<MVarDefPtr> hobbes::MVarDefs

◆ MVarTypeDefPtr

typedef std::shared_ptr<MVarTypeDef> hobbes::MVarTypeDefPtr

◆ MVarTypeDefs

typedef std::vector<MVarTypeDefPtr> hobbes::MVarTypeDefs

◆ NamedPatternGroups

typedef std::map<std::string, Patterns> hobbes::NamedPatternGroups

◆ NamedRegion

typedef std::pair<std::string, region*> hobbes::NamedRegion

◆ NameIndexing

typedef std::map<std::string, int> hobbes::NameIndexing

◆ Names

typedef std::vector<TVName> hobbes::Names

◆ NameSet

typedef std::set<TVName> hobbes::NameSet

◆ nat

typedef unsigned int hobbes::nat

◆ nats

typedef std::vector<nat> hobbes::nats

◆ NFA

typedef std::vector<NFAState> hobbes::NFA

◆ Nss2Ds

typedef std::map<stateset, state> hobbes::Nss2Ds

◆ ntransitions

typedef range_map<rchar_t, stateset, char_range_ord> hobbes::ntransitions

◆ ObjsPtr

typedef std::shared_ptr<Objs> hobbes::ObjsPtr

◆ OffsetData

typedef std::pair<uint64_t, IsArrOldVal> hobbes::OffsetData

◆ OpaquePtrMem

typedef unique_refc_map<const OpaquePtr, std::string, unsigned int, bool> hobbes::OpaquePtrMem

◆ pageseq

typedef std::vector<file_pageindex_t> hobbes::pageseq

◆ pagetable

typedef std::vector<pagedata> hobbes::pagetable

◆ Parser

typedef std::vector<ParseRule> hobbes::Parser

◆ parser_state_transitions

typedef std::map<nat, state_transitions> hobbes::parser_state_transitions

◆ parser_states

typedef std::map<itemset, nat> hobbes::parser_states

◆ PatternPtr

typedef std::shared_ptr<Pattern> hobbes::PatternPtr

◆ PatternRows

typedef std::vector<PatternRow> hobbes::PatternRows

◆ Patterns

typedef std::vector<PatternPtr> hobbes::Patterns

◆ PatVarCtorFn

typedef Pattern *(* hobbes::PatVarCtorFn)(const std::string &, const LexicalAnnotation &)

◆ PBatch

typedef array<int> hobbes::PBatch

◆ PBatchList

typedef dbseq<PBatchRef> hobbes::PBatchList

◆ PBatchListRef

typedef fileref<PBatchList*> hobbes::PBatchListRef

◆ PBatchRef

typedef fileref<PBatch*> hobbes::PBatchRef

◆ PolyTypePtr

typedef std::shared_ptr<PolyType> hobbes::PolyTypePtr

◆ PolyTypes

typedef std::vector<PolyTypePtr> hobbes::PolyTypes

◆ Pos

typedef std::pair<size_t, size_t> hobbes::Pos

◆ precedence

typedef std::map<terminal*, prec> hobbes::precedence

◆ prefixes

typedef std::vector<terminals> hobbes::prefixes

◆ PrepProcExpr

typedef std::pair<size_t, MonoTypePtr> hobbes::PrepProcExpr

◆ PrimFArg

typedef std::pair<std::string, MonoTypePtr> hobbes::PrimFArg

◆ PrimFArgs

typedef std::vector<PrimFArg> hobbes::PrimFArgs

◆ PrimitivePtr

typedef std::shared_ptr<Primitive> hobbes::PrimitivePtr

◆ PrimitiveSet

typedef std::set<PrimitivePtr, PrimPtrLT> hobbes::PrimitiveSet

◆ PrimMem

typedef unique_refc_map<const Prim, std::string, MonoTypePtr> hobbes::PrimMem

◆ PtrAdjustmentPath

typedef std::vector<PtrAdjustment> hobbes::PtrAdjustmentPath

◆ ptsappend

typedef terminalset(* hobbes::ptsappend) (const terminalset &, const terminalset &)

◆ ptyorder

typedef std::map<pagetype::code, pageseq> hobbes::ptyorder

◆ QualLiftedMonoType

typedef std::pair<Constraints, MonoTypePtr> hobbes::QualLiftedMonoType

◆ QualLiftedMonoTypes

typedef std::pair<Constraints, MonoTypes> hobbes::QualLiftedMonoTypes

◆ QualTypePtr

typedef std::shared_ptr<QualType> hobbes::QualTypePtr

◆ QualTypes

typedef std::vector<QualTypePtr> hobbes::QualTypes

◆ RawData

typedef std::vector<uint8_t> hobbes::RawData

◆ rchar_t

typedef uint8_t hobbes::rchar_t

◆ readsT

typedef clos2<parserdef, transition, transition, bool> hobbes::readsT

◆ RecordMem

typedef unique_refc_map<const Record, Record::Members> hobbes::RecordMem

◆ RecordValue

typedef std::vector<FieldValue> hobbes::RecordValue

◆ RecursiveMem

typedef unique_refc_map<const Recursive, std::string, MonoTypePtr> hobbes::RecursiveMem

◆ Regexes

typedef std::vector<RegexPtr> hobbes::Regexes

◆ RegexIdx

typedef size_t hobbes::RegexIdx

◆ RegexIdxs

typedef std::set<RegexIdx> hobbes::RegexIdxs

◆ RegexPtr

typedef std::shared_ptr<Regex> hobbes::RegexPtr

◆ Regions

typedef std::vector<NamedRegion> hobbes::Regions

◆ result

typedef uint32_t hobbes::result

◆ RowResults

typedef std::map<size_t, ExprPtr> hobbes::RowResults

◆ RStates

typedef std::map<size_t, RegexIdxs> hobbes::RStates

◆ RT

typedef clos1<transition_lookahead, transition, terminalset> hobbes::RT

◆ rule

typedef terminals hobbes::rule

◆ rules

typedef std::vector<rule> hobbes::rules

◆ Signames

typedef std::map<int,const char*> hobbes::Signames

◆ srcmarkers

typedef std::map<result, str::set> hobbes::srcmarkers

◆ state

typedef uint32_t hobbes::state

◆ state_definitions

typedef std::map<nat, itemset> hobbes::state_definitions

◆ state_transitions

typedef std::map< terminal *, nat > hobbes::state_transitions

◆ StateBranches

typedef std::map<stateidx_t, llvm::BasicBlock*> hobbes::StateBranches

◆ stateidx_t

typedef size_t hobbes::stateidx_t

◆ stateidxset

typedef std::set<stateidx_t> hobbes::stateidxset

◆ statemarks

typedef std::vector<bool> hobbes::statemarks

◆ stateset

typedef std::set<state> hobbes::stateset

◆ StatesIdx

typedef std::unordered_map<std::string, stateidx_t> hobbes::StatesIdx

◆ strings

typedef std::vector<std::string> hobbes::strings

◆ strref

typedef fileref<array<char>*> hobbes::strref

◆ StructField

typedef std::unordered_map<std::string, ExprPtr> hobbes::StructField

◆ symbols

typedef std::map<std::string, terminal*> hobbes::symbols

◆ SymSet

typedef std::set<std::string> hobbes::SymSet

◆ TableCfgStates

typedef std::unordered_map<PatternRows, stateidx_t, hobbes::genHash<PatternRows> > hobbes::TableCfgStates

◆ TAbsMem

typedef unique_refc_map<const TAbs, str::seq, MonoTypePtr> hobbes::TAbsMem

◆ TAppMem

typedef unique_refc_map<const TApp, MonoTypePtr, MonoTypes> hobbes::TAppMem

◆ TCInstanceFnPtr

typedef std::shared_ptr<TCInstanceFn> hobbes::TCInstanceFnPtr

◆ TCInstanceFns

typedef std::vector<TCInstanceFnPtr> hobbes::TCInstanceFns

◆ TCInstancePtr

typedef std::shared_ptr<TCInstance> hobbes::TCInstancePtr

◆ TCInstances

typedef std::vector<TCInstancePtr> hobbes::TCInstances

◆ TClassEnv

typedef std::map<std::string, TClassPtr> hobbes::TClassEnv

◆ TClassPtr

typedef std::shared_ptr<TClass> hobbes::TClassPtr

◆ TEnvPtr

typedef std::shared_ptr<TEnv> hobbes::TEnvPtr

◆ TEnvs

typedef std::set<TEnvPtr> hobbes::TEnvs

◆ terminals

typedef std::vector<terminal*> hobbes::terminals

◆ terminalset

typedef std::set<terminal*> hobbes::terminalset

◆ TExprMem

typedef unique_refc_map<const TExpr, std::string> hobbes::TExprMem

◆ TGenMem

typedef unique_refc_map<const TGen, int> hobbes::TGenMem

◆ TGenVarSet

typedef std::set<int> hobbes::TGenVarSet

◆ ThunkF

typedef void(* hobbes::ThunkF) ()

◆ ThunkFs

typedef std::vector<ThunkF> hobbes::ThunkFs

◆ timerfunc

typedef bool(* hobbes::timerfunc) ()

◆ timespanT

typedef typeAlias<timespanTNV, int64_t> hobbes::timespanT

◆ timeT

typedef typeAlias<timeTNV, int64_t> hobbes::timeT

◆ TLongMem

typedef unique_refc_map<const TLong, long> hobbes::TLongMem

◆ transition

typedef std::pair<nat, terminal*> hobbes::transition

◆ transition_lookahead

typedef std::map<transition, terminalset> hobbes::transition_lookahead

◆ transitionset

typedef std::set<transition> hobbes::transitionset

◆ TStringMem

typedef unique_refc_map<const TString, std::string> hobbes::TStringMem

◆ TVarMem

typedef unique_refc_map<const TVar, std::string> hobbes::TVarMem

◆ TVName

typedef std::string hobbes::TVName

◆ TypeAliasMap

typedef std::map<std::string, PolyTypePtr> hobbes::TypeAliasMap

◆ Types

typedef std::vector<llvm::Type*> hobbes::Types

◆ UnitV

typedef unsigned char hobbes::UnitV

◆ UnqualifierPtr

typedef std::shared_ptr< Unqualifier > hobbes::UnqualifierPtr

◆ UnqualifierSetPtr

typedef std::shared_ptr< UnqualifierSet > hobbes::UnqualifierSetPtr

◆ UnreachableMatchRowsPtr

typedef std::shared_ptr<std::vector<std::pair<size_t, PatternRow> > > hobbes::UnreachableMatchRowsPtr

◆ UnzRecValues

typedef std::pair<std::vector<std::string>, Values> hobbes::UnzRecValues

◆ UTFileConfig

typedef std::pair< bool, MonoTypePtr > hobbes::UTFileConfig

◆ Values

typedef std::vector< llvm::Value * > hobbes::Values

◆ VarArrayElem

typedef std::unordered_map<std::string, ArrayElem> hobbes::VarArrayElem

◆ VarArrayLen

typedef std::unordered_map<std::string, ExprPtr> hobbes::VarArrayLen

◆ VarCtorFn

typedef Expr *(* hobbes::VarCtorFn)(const std::string &, const LexicalAnnotation &)

◆ VariantMem

typedef unique_refc_map<const Variant, Variant::Members> hobbes::VariantMem

◆ VarIDs

typedef std::vector<int> hobbes::VarIDs

◆ VarMapping

typedef std::map<std::string, ExprPtr> hobbes::VarMapping

◆ VarNames

typedef std::unordered_map<std::string, ExprPtr> hobbes::VarNames

◆ VarSet

typedef std::set<std::string> hobbes::VarSet

◆ VarStructField

typedef std::unordered_map<std::string, StructField> hobbes::VarStructField

Function Documentation

◆ abortAtMemUsage()

void hobbes::abortAtMemUsage ( size_t maxsz )

◆ abstractClosureType()

QualTypePtr hobbes::abstractClosureType	(	const Fn *	f,
		const MonoTypes &	fargtys,
		const MonoTypePtr &	rty
	)

◆ accumRegex()

state hobbes::accumRegex	(	const RegexPtr &	p,
		result	x,
		NFA *	nfa
	)

◆ addAccept()

void hobbes::addAccept	(	lrstate &	s,
		terminal *	t
	)

◆ addAction()

void hobbes::addAction	(	const parserdef &	pd,
		lrstate &	s,
		terminal *	t,
		const action &	a,
		const precedence &	px
	)

◆ addBinding()

static void hobbes::addBinding	(	imagefile *	f,
		const std::string &	vname,
		const MonoTypePtr &	type,
		size_t	offset
	)

static

◆ addFileSignal()

void hobbes::addFileSignal	(	long	file,
		long	off,
		long	sz,
		bool	isArr,
		ChangeSignal	f
	)

◆ addFileSOSignal()

void hobbes::addFileSOSignal	(	long	file,
		unsigned int	so,
		bool	isArr,
		ChangeSignal	f
	)

◆ addGoto()

void hobbes::addGoto	(	lrstate &	s,
		terminal *	nt,
		nat	next
	)

◆ addoffset()

Record::Member hobbes::addoffset	(	const Record::Member &	m,
		int	o
	)

inline

◆ addReduce()

void hobbes::addReduce	(	const parserdef &	pd,
		lrstate &	s,
		const terminalset &	ts,
		terminal *	agg,
		nat	rule,
		nat	len,
		const precedence &	px
	)

◆ addRef()

void hobbes::addRef	(	MDFA *	dfa,
		stateidx_t	s
	)

◆ addSATableRow()

void hobbes::addSATableRow	(	size_t	len,
		const PatternRow &	r,
		size_t	c,
		PatternRows *	out
	)

◆ addShift()

void hobbes::addShift	(	const parserdef &	pd,
		lrstate &	s,
		terminal *	t,
		nat	next,
		const precedence &	px
	)

◆ addState()

stateidx_t hobbes::addState	(	MDFA *	dfa,
		const MStatePtr &	state,
		bool	addref = `true`
	)

◆ addThreadRegion()

size_t hobbes::addThreadRegion	(	const std::string &	n,
		region *	r
	)

◆ addTimer()

void hobbes::addTimer	(	timerfunc	f,
		int	millisecInterval
	)

◆ aggRules()

const rules* hobbes::aggRules	(	const grammar &	g,
		terminal *	t
	)

◆ align()

template<typename T >

T hobbes::align	(	T	x,
		T	m
	)

◆ alignment()

unsigned int hobbes::alignment ( const MonoTypePtr & ty )

◆ allocateFileSocketServer()

int hobbes::allocateFileSocketServer ( const std::string & filepath )

◆ allocateServer() [1/2]

int hobbes::allocateServer ( int port )

◆ allocateServer() [2/2]

int hobbes::allocateServer ( const std::string & port )

◆ allocPage()

static void hobbes::allocPage ( imagefile * f )

static

◆ allocPages()

static void hobbes::allocPages	(	imagefile *	f,
		size_t	pages
	)

static

◆ allocTEnvFrame()

TEnvPtr hobbes::allocTEnvFrame	(	const str::seq &	names,
		const MonoTypes &	tys,
		const TEnvPtr &	ptenv
	)

inline

◆ annotationCtxStack()

static AnnContextStack& hobbes::annotationCtxStack ( )

static

◆ anyChars()

const std::set<rchar_t>& hobbes::anyChars ( )

◆ anyOf() [1/2]

RegexPtr hobbes::anyOf ( const Regexes & rs )

◆ anyOf() [2/2]

RegexPtr hobbes::anyOf ( const std::set< rchar_t > & cs )

◆ append() [1/3]

template<typename T >

void hobbes::append	(	std::vector< T > *	xs,
		const std::vector< T > &	ys
	)

◆ append() [2/3]

template<typename T >

std::vector<T> hobbes::append	(	const std::vector< T > &	xs,
		T	x
	)

◆ append() [3/3]

template<typename T >

std::vector<T> hobbes::append	(	const std::vector< T > &	xs,
		const std::vector< T > &	ys
	)

◆ appendPath()

void hobbes::appendPath	(	PtrAdjustmentPath *	p,
		const PtrAdjustmentPath &	sfx
	)

◆ appendTOCData()

static void hobbes::appendTOCData	(	imagefile *	f,
		const pagetable &	newpages
	)

static

◆ apply()

void hobbes::apply	(	const transition_lookahead &	tl,
		parserdef *	p
	)

◆ applyAdjustment()

ExprPtr hobbes::applyAdjustment	(	const PtrAdjustment &	p,
		const ExprPtr &	e
	)

◆ applyAdjustments()

ExprPtr hobbes::applyAdjustments	(	const PtrAdjustmentPath &	p,
		const ExprPtr &	e
	)

◆ applyOffsetAdjustment()

ExprPtr hobbes::applyOffsetAdjustment	(	const ExprPtr &	e,
		int	o,
		const std::string &	targetTy
	)

◆ applyVtblAdjustment()

ExprPtr hobbes::applyVtblAdjustment	(	const ExprPtr &	e,
		int	o,
		const std::string &	targetTy
	)

◆ arrayAnyMatches()

Patterns hobbes::arrayAnyMatches ( size_t n )

◆ arrayElement()

ExprPtr hobbes::arrayElement	(	MDFA *	dfa,
		const std::string &	vn,
		size_t	i
	)

◆ arrayPatterns()

Patterns hobbes::arrayPatterns ( const MatchArray & ma )

◆ arraySize()

ExprPtr hobbes::arraySize	(	MDFA *	dfa,
		const std::string &	vn
	)

◆ arrayty() [1/2]

MonoTypePtr hobbes::arrayty	(	const MonoTypePtr &	ty,
		size_t	n
	)

inline

◆ arrayty() [2/2]

MonoTypePtr hobbes::arrayty ( const MonoTypePtr & ty )

inline

◆ arrayType()

llvm::ArrayType* hobbes::arrayType	(	llvm::Type *	ty,
		size_t	sz
	)

inline

◆ arrType()

const MonoTypePtr& hobbes::arrType ( const MonoTypePtr & arr )

◆ asDestruct()

static bool hobbes::asDestruct	(	const MonoTypePtr &	t,
		MonoTypePtr *	dty
	)

static

◆ asRestruct()

static bool hobbes::asRestruct	(	const MonoTypePtr &	t,
		MonoTypePtr *	rty
	)

static

◆ assertValidPageSize()

uint16_t hobbes::assertValidPageSize	(	const imagefile *	f,
		size_t	psize
	)

◆ assign()

ExprPtr hobbes::assign	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs,
		const LexicalAnnotation &	la
	)

inline

◆ assignNames()

void hobbes::assignNames	(	const str::seq &	vns,
		PatternRows &	ps,
		bool *	mappedVs
	)

◆ assume() [1/2]

ExprPtr hobbes::assume	(	const ExprPtr &	e,
		const QualTypePtr &	t,
		const LexicalAnnotation &	la
	)

inline

◆ assume() [2/2]

ExprPtr hobbes::assume	(	const ExprPtr &	e,
		const MonoTypePtr &	t,
		const LexicalAnnotation &	la
	)

inline

◆ assumeFRefT()

FRefT hobbes::assumeFRefT	(	const MonoTypePtr &	ty,
		const LexicalAnnotation &	la
	)

◆ autorelease()

template<typename T >

T* hobbes::autorelease ( T * x )

◆ badFDs()

std::set<int>& hobbes::badFDs ( )

◆ begin() [1/4]

template<typename T >

const T* hobbes::begin ( const array< T > * d )

◆ begin() [2/4]

template<typename T >

T* hobbes::begin ( array< T > * d )

◆ begin() [3/4]

template<typename T >

const T* hobbes::begin ( const array< T > & d )

◆ begin() [4/4]

template<typename T >

T* hobbes::begin ( array< T > & d )

◆ beginHighlight()

void hobbes::beginHighlight ( std::ostream & out )

◆ bindFrame() [1/2]

TEnvPtr hobbes::bindFrame	(	const TEnvPtr &	p,
		const std::string &	vn,
		const MonoTypePtr &	vty
	)

◆ bindFrame() [2/2]

TEnvPtr hobbes::bindFrame	(	const TEnvPtr &	p,
		const std::string &	vn,
		const QualTypePtr &	qty
	)

◆ bindingNames()

str::seq hobbes::bindingNames ( const RegexPtr & rgx )

◆ bindTo()

RegexPtr hobbes::bindTo	(	const std::string &	name,
		const RegexPtr &	p
	)

◆ boolType()

llvm::Type* hobbes::boolType ( )

inline

◆ BOP() [1/93]

hobbes::BOP	(	ceq	,
		CreateICmpEQ	,
		char	,
		char	,
		bool
	)

◆ BOP() [2/93]

hobbes::BOP	(	cneq	,
		CreateICmpNE	,
		char	,
		char	,
		bool
	)

◆ BOP() [3/93]

hobbes::BOP	(	clt	,
		CreateICmpULT	,
		char	,
		char	,
		bool
	)

◆ BOP() [4/93]

hobbes::BOP	(	clte	,
		CreateICmpULE	,
		char	,
		char	,
		bool
	)

◆ BOP() [5/93]

hobbes::BOP	(	cgt	,
		CreateICmpUGT	,
		char	,
		char	,
		bool
	)

◆ BOP() [6/93]

hobbes::BOP	(	cgte	,
		CreateICmpUGE	,
		char	,
		char	,
		bool
	)

◆ BOP() [7/93]

hobbes::BOP	(	beq	,
		CreateICmpEQ	,
		unsigned	char,
		unsigned	char,
		bool
	)

◆ BOP() [8/93]

hobbes::BOP	(	bneq	,
		CreateICmpNE	,
		unsigned	char,
		unsigned	char,
		bool
	)

◆ BOP() [9/93]

hobbes::BOP	(	blt	,
		CreateICmpULT	,
		unsigned	char,
		unsigned	char,
		bool
	)

◆ BOP() [10/93]

hobbes::BOP	(	blte	,
		CreateICmpULE	,
		unsigned	char,
		unsigned	char,
		bool
	)

◆ BOP() [11/93]

hobbes::BOP	(	bgt	,
		CreateICmpUGT	,
		unsigned	char,
		unsigned	char,
		bool
	)

◆ BOP() [12/93]

hobbes::BOP	(	bgte	,
		CreateICmpUGE	,
		unsigned	char,
		unsigned	char,
		bool
	)

◆ BOP() [13/93]

hobbes::BOP	(	bshl	,
		CreateShl	,
		unsigned	char,
		unsigned	char,
		unsigned	char
	)

◆ BOP() [14/93]

hobbes::BOP	(	blshr	,
		CreateLShr	,
		unsigned	char,
		unsigned	char,
		unsigned	char
	)

◆ BOP() [15/93]

hobbes::BOP	(	bashr	,
		CreateAShr	,
		unsigned	char,
		unsigned	char,
		unsigned	char
	)

◆ BOP() [16/93]

hobbes::BOP	(	band	,
		CreateAnd	,
		unsigned	char,
		unsigned	char,
		unsigned	char
	)

◆ BOP() [17/93]

hobbes::BOP	(	bor	,
		CreateOr	,
		unsigned	char,
		unsigned	char,
		unsigned	char
	)

◆ BOP() [18/93]

hobbes::BOP	(	bxor	,
		CreateXor	,
		unsigned	char,
		unsigned	char,
		unsigned	char
	)

◆ BOP() [19/93]

hobbes::BOP	(	cadd	,
		CreateAdd	,
		char	,
		char	,
		char
	)

◆ BOP() [20/93]

hobbes::BOP	(	csub	,
		CreateSub	,
		char	,
		char	,
		char
	)

◆ BOP() [21/93]

hobbes::BOP	(	cmul	,
		CreateMul	,
		char	,
		char	,
		char
	)

◆ BOP() [22/93]

hobbes::BOP	(	cdiv	,
		CreateSDiv	,
		char	,
		char	,
		char
	)

◆ BOP() [23/93]

hobbes::BOP	(	crem	,
		CreateSRem	,
		char	,
		char	,
		char
	)

◆ BOP() [24/93]

hobbes::BOP	(	badd	,
		CreateAdd	,
		unsigned	char,
		unsigned	char,
		unsigned	char
	)

◆ BOP() [25/93]

hobbes::BOP	(	bsub	,
		CreateSub	,
		unsigned	char,
		unsigned	char,
		unsigned	char
	)

◆ BOP() [26/93]

hobbes::BOP	(	bmul	,
		CreateMul	,
		unsigned	char,
		unsigned	char,
		unsigned	char
	)

◆ BOP() [27/93]

hobbes::BOP	(	bdiv	,
		CreateSDiv	,
		unsigned	char,
		unsigned	char,
		unsigned	char
	)

◆ BOP() [28/93]

hobbes::BOP	(	brem	,
		CreateSRem	,
		unsigned	char,
		unsigned	char,
		unsigned	char
	)

◆ BOP() [29/93]

hobbes::BOP	(	sadd	,
		CreateAdd	,
		short	,
		short	,
		short
	)

◆ BOP() [30/93]

hobbes::BOP	(	ssub	,
		CreateSub	,
		short	,
		short	,
		short
	)

◆ BOP() [31/93]

hobbes::BOP	(	smul	,
		CreateMul	,
		short	,
		short	,
		short
	)

◆ BOP() [32/93]

hobbes::BOP	(	sdiv	,
		CreateSDiv	,
		short	,
		short	,
		short
	)

◆ BOP() [33/93]

hobbes::BOP	(	srem	,
		CreateSRem	,
		short	,
		short	,
		short
	)

◆ BOP() [34/93]

hobbes::BOP	(	seq	,
		CreateICmpEQ	,
		short	,
		short	,
		bool
	)

◆ BOP() [35/93]

hobbes::BOP	(	sneq	,
		CreateICmpNE	,
		short	,
		short	,
		bool
	)

◆ BOP() [36/93]

hobbes::BOP	(	slt	,
		CreateICmpSLT	,
		short	,
		short	,
		bool
	)

◆ BOP() [37/93]

hobbes::BOP	(	slte	,
		CreateICmpSLE	,
		short	,
		short	,
		bool
	)

◆ BOP() [38/93]

hobbes::BOP	(	sgt	,
		CreateICmpSGT	,
		short	,
		short	,
		bool
	)

◆ BOP() [39/93]

hobbes::BOP	(	sgte	,
		CreateICmpSGE	,
		short	,
		short	,
		bool
	)

◆ BOP() [40/93]

hobbes::BOP	(	iadd	,
		CreateAdd	,
		int	,
		int	,
		int
	)

◆ BOP() [41/93]

hobbes::BOP	(	isub	,
		CreateSub	,
		int	,
		int	,
		int
	)

◆ BOP() [42/93]

hobbes::BOP	(	imul	,
		CreateMul	,
		int	,
		int	,
		int
	)

◆ BOP() [43/93]

hobbes::BOP	(	idiv	,
		CreateSDiv	,
		int	,
		int	,
		int
	)

◆ BOP() [44/93]

hobbes::BOP	(	irem	,
		CreateSRem	,
		int	,
		int	,
		int
	)

◆ BOP() [45/93]

hobbes::BOP	(	ishl	,
		CreateShl	,
		int	,
		int	,
		int
	)

◆ BOP() [46/93]

hobbes::BOP	(	ilshr	,
		CreateLShr	,
		int	,
		int	,
		int
	)

◆ BOP() [47/93]

hobbes::BOP	(	iashr	,
		CreateAShr	,
		int	,
		int	,
		int
	)

◆ BOP() [48/93]

hobbes::BOP	(	iand	,
		CreateAnd	,
		int	,
		int	,
		int
	)

◆ BOP() [49/93]

hobbes::BOP	(	ior	,
		CreateOr	,
		int	,
		int	,
		int
	)

◆ BOP() [50/93]

hobbes::BOP	(	ixor	,
		CreateXor	,
		int	,
		int	,
		int
	)

◆ BOP() [51/93]

hobbes::BOP	(	ieq	,
		CreateICmpEQ	,
		int	,
		int	,
		bool
	)

◆ BOP() [52/93]

hobbes::BOP	(	ineq	,
		CreateICmpNE	,
		int	,
		int	,
		bool
	)

◆ BOP() [53/93]

hobbes::BOP	(	ilt	,
		CreateICmpSLT	,
		int	,
		int	,
		bool
	)

◆ BOP() [54/93]

hobbes::BOP	(	ilte	,
		CreateICmpSLE	,
		int	,
		int	,
		bool
	)

◆ BOP() [55/93]

hobbes::BOP	(	igt	,
		CreateICmpSGT	,
		int	,
		int	,
		bool
	)

◆ BOP() [56/93]

hobbes::BOP	(	igte	,
		CreateICmpSGE	,
		int	,
		int	,
		bool
	)

◆ BOP() [57/93]

hobbes::BOP	(	ladd	,
		CreateAdd	,
		long	,
		long	,
		long
	)

◆ BOP() [58/93]

hobbes::BOP	(	lsub	,
		CreateSub	,
		long	,
		long	,
		long
	)

◆ BOP() [59/93]

hobbes::BOP	(	lmul	,
		CreateMul	,
		long	,
		long	,
		long
	)

◆ BOP() [60/93]

hobbes::BOP	(	ldiv	,
		CreateSDiv	,
		long	,
		long	,
		long
	)

◆ BOP() [61/93]

hobbes::BOP	(	lrem	,
		CreateSRem	,
		long	,
		long	,
		long
	)

◆ BOP() [62/93]

hobbes::BOP	(	lshl	,
		CreateShl	,
		long	,
		long	,
		long
	)

◆ BOP() [63/93]

hobbes::BOP	(	llshr	,
		CreateLShr	,
		long	,
		long	,
		long
	)

◆ BOP() [64/93]

hobbes::BOP	(	lashr	,
		CreateAShr	,
		long	,
		long	,
		long
	)

◆ BOP() [65/93]

hobbes::BOP	(	land	,
		CreateAnd	,
		long	,
		long	,
		long
	)

◆ BOP() [66/93]

hobbes::BOP	(	lor	,
		CreateOr	,
		long	,
		long	,
		long
	)

◆ BOP() [67/93]

hobbes::BOP	(	lxor	,
		CreateXor	,
		long	,
		long	,
		long
	)

◆ BOP() [68/93]

hobbes::BOP	(	leq	,
		CreateICmpEQ	,
		long	,
		long	,
		bool
	)

◆ BOP() [69/93]

hobbes::BOP	(	lneq	,
		CreateICmpNE	,
		long	,
		long	,
		bool
	)

◆ BOP() [70/93]

hobbes::BOP	(	llt	,
		CreateICmpSLT	,
		long	,
		long	,
		bool
	)

◆ BOP() [71/93]

hobbes::BOP	(	llte	,
		CreateICmpSLE	,
		long	,
		long	,
		bool
	)

◆ BOP() [72/93]

hobbes::BOP	(	lgt	,
		CreateICmpSGT	,
		long	,
		long	,
		bool
	)

◆ BOP() [73/93]

hobbes::BOP	(	lgte	,
		CreateICmpSGE	,
		long	,
		long	,
		bool
	)

◆ BOP() [74/93]

hobbes::BOP	(	fadd	,
		CreateFAdd	,
		float	,
		float	,
		float
	)

◆ BOP() [75/93]

hobbes::BOP	(	fsub	,
		CreateFSub	,
		float	,
		float	,
		float
	)

◆ BOP() [76/93]

hobbes::BOP	(	fmul	,
		CreateFMul	,
		float	,
		float	,
		float
	)

◆ BOP() [77/93]

hobbes::BOP	(	fdiv	,
		CreateFDiv	,
		float	,
		float	,
		float
	)

◆ BOP() [78/93]

hobbes::BOP	(	feq	,
		CreateFCmpOEQ	,
		float	,
		float	,
		bool
	)

◆ BOP() [79/93]

hobbes::BOP	(	fneq	,
		CreateFCmpONE	,
		float	,
		float	,
		bool
	)

◆ BOP() [80/93]

hobbes::BOP	(	flt	,
		CreateFCmpOLT	,
		float	,
		float	,
		bool
	)

◆ BOP() [81/93]

hobbes::BOP	(	flte	,
		CreateFCmpOLE	,
		float	,
		float	,
		bool
	)

◆ BOP() [82/93]

hobbes::BOP	(	fgt	,
		CreateFCmpOGT	,
		float	,
		float	,
		bool
	)

◆ BOP() [83/93]

hobbes::BOP	(	fgte	,
		CreateFCmpOGE	,
		float	,
		float	,
		bool
	)

◆ BOP() [84/93]

hobbes::BOP	(	dadd	,
		CreateFAdd	,
		double	,
		double	,
		double
	)

◆ BOP() [85/93]

hobbes::BOP	(	dsub	,
		CreateFSub	,
		double	,
		double	,
		double
	)

◆ BOP() [86/93]

hobbes::BOP	(	dmul	,
		CreateFMul	,
		double	,
		double	,
		double
	)

◆ BOP() [87/93]

hobbes::BOP	(	ddiv	,
		CreateFDiv	,
		double	,
		double	,
		double
	)

◆ BOP() [88/93]

hobbes::BOP	(	deq	,
		CreateFCmpOEQ	,
		double	,
		double	,
		bool
	)

◆ BOP() [89/93]

hobbes::BOP	(	dneq	,
		CreateFCmpONE	,
		double	,
		double	,
		bool
	)

◆ BOP() [90/93]

hobbes::BOP	(	dlt	,
		CreateFCmpOLT	,
		double	,
		double	,
		bool
	)

◆ BOP() [91/93]

hobbes::BOP	(	dlte	,
		CreateFCmpOLE	,
		double	,
		double	,
		bool
	)

◆ BOP() [92/93]

hobbes::BOP	(	dgt	,
		CreateFCmpOGT	,
		double	,
		double	,
		bool
	)

◆ BOP() [93/93]

hobbes::BOP	(	dgte	,
		CreateFCmpOGE	,
		double	,
		double	,
		bool
	)

◆ byteType()

llvm::Type* hobbes::byteType ( )

inline

◆ canDecFieldName()

static bool hobbes::canDecFieldName ( const MonoTypePtr & fieldName )

static

◆ canHoldRecPatterns()

bool hobbes::canHoldRecPatterns ( const PatternPtr & p )

◆ canMakeCharArrayState()

bool hobbes::canMakeCharArrayState	(	const PatternRows &	ps,
		size_t	c
	)

◆ canMakeCharArrStateAtColumn()

size_t hobbes::canMakeCharArrStateAtColumn ( const PatternRows & ps )

◆ canMakeInterpretedPrimMatchFunction()

bool hobbes::canMakeInterpretedPrimMatchFunction	(	MDFA *	dfa,
		stateidx_t	state
	)

◆ canonicalName()

TVName hobbes::canonicalName ( int v )

◆ canonicalNameSubst()

MonoTypeSubst hobbes::canonicalNameSubst ( const NameSet & ns )

◆ captureStdout()

void hobbes::captureStdout ( )

◆ caseOf()

template<typename ... Cases>

ExprPtr hobbes::caseOf	(	const ExprPtr &	e,
		Cases...	cs
	)

◆ caseOfBindings() [1/2]

Case::Bindings hobbes::caseOfBindings ( )

inline

◆ caseOfBindings() [2/2]

template<typename ... Cases>

Case::Bindings hobbes::caseOfBindings	(	const char *	ctor,
		const char *	vname,
		const ExprPtr &	e,
		Cases...	cs
	)

◆ cast()

llvm::Value* hobbes::cast	(	llvm::IRBuilder<> *	b,
		llvm::Type *	ty,
		llvm::Value *	v
	)

inline

◆ CASTOP() [1/13]

hobbes::CASTOP	(	b2i	,
		llvm::Instruction::ZExt	,
		unsigned	char,
		int
	)

◆ CASTOP() [2/13]

hobbes::CASTOP	(	b2l	,
		llvm::Instruction::ZExt	,
		unsigned	char,
		long
	)

◆ CASTOP() [3/13]

hobbes::CASTOP	(	i2d	,
		llvm::Instruction::SIToFP	,
		int	,
		double
	)

◆ CASTOP() [4/13]

hobbes::CASTOP	(	i2f	,
		llvm::Instruction::SIToFP	,
		int	,
		float
	)

◆ CASTOP() [5/13]

hobbes::CASTOP	(	i2l	,
		llvm::Instruction::SExt	,
		int	,
		long
	)

◆ CASTOP() [6/13]

hobbes::CASTOP	(	l2d	,
		llvm::Instruction::SIToFP	,
		long	,
		double
	)

◆ CASTOP() [7/13]

hobbes::CASTOP	(	l2f	,
		llvm::Instruction::SIToFP	,
		long	,
		float
	)

◆ CASTOP() [8/13]

hobbes::CASTOP	(	s2i	,
		llvm::Instruction::SExt	,
		short	,
		int
	)

◆ CASTOP() [9/13]

hobbes::CASTOP	(	f2d	,
		llvm::Instruction::FPExt	,
		float	,
		double
	)

◆ CASTOP() [10/13]

hobbes::CASTOP	(	tl2i	,
		llvm::Instruction::Trunc	,
		long	,
		int
	)

◆ CASTOP() [11/13]

hobbes::CASTOP	(	ti2s	,
		llvm::Instruction::Trunc	,
		int	,
		short
	)

◆ CASTOP() [12/13]

hobbes::CASTOP	(	ti2b	,
		llvm::Instruction::Trunc	,
		int	,
		unsigned	char
	)

◆ CASTOP() [13/13]

hobbes::CASTOP	(	tl2b	,
		llvm::Instruction::Trunc	,
		long	,
		unsigned	char
	)

◆ ccast()

llvm::Constant* hobbes::ccast	(	llvm::Type *	ty,
		llvm::Constant *	v
	)

inline

◆ charArrElement()

ExprPtr hobbes::charArrElement	(	MDFA *	dfa,
		const std::string &	packFn,
		const std::string &	vn,
		size_t	i
	)

◆ charInRange()

static ExprPtr hobbes::charInRange	(	const ExprPtr &	c,
		const std::pair< rchar_t, rchar_t > &	crange,
		const LexicalAnnotation &	rootLA
	)

static

◆ charLit()

RegexPtr hobbes::charLit ( rchar_t c )

◆ charRange() [1/2]

RegexPtr hobbes::charRange	(	rchar_t	b,
		rchar_t	e
	)

◆ charRange() [2/2]

void hobbes::charRange	(	rchar_t	i,
		rchar_t	e,
		std::set< rchar_t > *	out
	)

◆ charType()

llvm::Type* hobbes::charType ( )

inline

◆ checkExpr()

ExprPtr hobbes::checkExpr	(	const ExprChecks &	cs,
		const LexicalAnnotation &	la
	)

◆ checkReturn()

template<typename T >

const T& hobbes::checkReturn ( const T & x )

◆ checkSatisfiable()

void hobbes::checkSatisfiable ( const MonoTypePtr & ty )

◆ choosePivotColumn()

size_t hobbes::choosePivotColumn ( const PatternRows & ps )

◆ chr()

terminal* hobbes::chr	(	chars *	cs,
		char	x
	)

◆ civalue() [1/7]

llvm::ConstantInt* hobbes::civalue ( bool x )

inline

◆ civalue() [2/7]

llvm::ConstantInt* hobbes::civalue ( char x )

inline

◆ civalue() [3/7]

llvm::ConstantInt* hobbes::civalue ( unsigned char x )

inline

◆ civalue() [4/7]

llvm::ConstantInt* hobbes::civalue ( short x )

inline

◆ civalue() [5/7]

llvm::ConstantInt* hobbes::civalue ( int x )

inline

◆ civalue() [6/7]

llvm::ConstantInt* hobbes::civalue ( unsigned int x )

inline

◆ civalue() [7/7]

llvm::ConstantInt* hobbes::civalue ( long x )

inline

◆ clearMemoryPool()

void hobbes::clearMemoryPool ( )

◆ clone() [1/3]

MonoTypePtr hobbes::clone ( const MonoTypePtr & t )

◆ clone() [2/3]

MonoTypePtr hobbes::clone ( const MonoType * t )

◆ clone() [3/3]

MonoTypePtr hobbes::clone ( const MonoType & t )

◆ cloneFunction()

llvm::Function* hobbes::cloneFunction	(	llvm::Function *	f,
		llvm::Module *	targetMod
	)

inline

◆ cloneP() [1/2]

QualTypePtr hobbes::cloneP ( const QualTypePtr & p )

◆ cloneP() [2/2]

MonoTypePtr hobbes::cloneP ( const MonoTypePtr & p )

◆ clones()

Exprs hobbes::clones ( const Exprs & es )

◆ closcall()

ExprPtr hobbes::closcall	(	const ExprPtr &	c,
		const Exprs &	args,
		const LexicalAnnotation &	la
	)

inline

◆ closeFile()

static void hobbes::closeFile ( imagefile * f )

static

◆ closLookup()

ExprPtr hobbes::closLookup	(	const std::string &	envVarName,
		const VarSet &	vs,
		const MonoTypePtr &	envty,
		const ExprPtr &	fbody,
		const LexicalAnnotation &	la
	)

◆ closty() [1/2]

MonoTypePtr hobbes::closty	(	const MonoTypePtr &	aty,
		const MonoTypePtr &	rty
	)

inline

◆ closty() [2/2]

MonoTypePtr hobbes::closty	(	const MonoTypes &	atys,
		const MonoTypePtr &	rty
	)

inline

◆ closure() [1/2]

itemset hobbes::closure	(	const grammar &	g,
		const itemset &	is
	)

◆ closure() [2/2]

void hobbes::closure	(	const grammar &	g,
		itemset *	is
	)

◆ closureConvert() [1/2]

ExprPtr hobbes::closureConvert	(	const TEnvPtr &	rootTEnv,
		const ExprPtr &	e
	)

◆ closureConvert() [2/2]

ExprPtr hobbes::closureConvert	(	const TEnvPtr &	rootTEnv,
		const std::string &	vn,
		const ExprPtr &	e
	)

◆ closureEnv()

ExprPtr hobbes::closureEnv	(	const VarSet &	vs,
		const MonoTypePtr &	envty,
		const LexicalAnnotation &	la
	)

◆ closureMethod()

ExprPtr hobbes::closureMethod	(	const Fn *	f,
		const VarSet &	vs,
		const MonoTypePtr &	envty,
		const MonoTypes &	fargtys,
		const MonoTypePtr &	rty,
		const LexicalAnnotation &	la
	)

◆ columnScore()

size_t hobbes::columnScore	(	const PatternRows &	ps,
		size_t	c
	)

◆ compact()

size_t hobbes::compact ( )

◆ compactAll()

template<size_t i, typename ... UniqueRefcMaps>

std::enable_if<i == sizeof...(UniqueRefcMaps), size_t>::type hobbes::compactAll ( std::tuple< UniqueRefcMaps... > & )

inline

◆ compactMTypeMemory()

void hobbes::compactMTypeMemory ( )

◆ compile() [1/8]

void hobbes::compile	(	cc *	e,
		const ModulePtr &	m
	)

◆ compile() [2/8]

void hobbes::compile	(	cc *	e,
		const ClassDef *	cd
	)

◆ compile() [3/8]

Values hobbes::compile	(	jitcc *	c,
		const Exprs &	es
	)

◆ compile() [4/8]

void hobbes::compile	(	cc *	e,
		const InstanceDef *	id
	)

◆ compile() [5/8]

void hobbes::compile	(	cc *	e,
		const MImport *	mimp
	)

◆ compile() [6/8]

void hobbes::compile	(	cc *	e,
		const MTypeDef *	mtd
	)

◆ compile() [7/8]

void hobbes::compile	(	cc *	e,
		const MVarDef *	mvd
	)

◆ compile() [8/8]

void hobbes::compile	(	cc *	e,
		const MVarTypeDef *	vtd
	)

◆ compileArgs()

Values hobbes::compileArgs	(	jitcc *	c,
		const Exprs &	es
	)

◆ compileBootCode()

void hobbes::compileBootCode ( cc & ctx )

◆ compileMatch()

ExprPtr hobbes::compileMatch	(	cc *	c,
		const Exprs &	es,
		const PatternRows &	ps,
		const LexicalAnnotation &	rootLA
	)

◆ compileMatchTest()

ExprPtr hobbes::compileMatchTest	(	cc *	c,
		const ExprPtr &	e,
		const PatternPtr &	p,
		const LexicalAnnotation &	rootLA
	)

◆ compileMembers()

MemberMapping hobbes::compileMembers	(	MonoTypeUnifier *	u,
		const TClassPtr &	c,
		const MonoTypes &	targs,
		cc *	e,
		const MVarDefs &	ds,
		bool	asfn
	)

◆ compileTo()

template<typename T >

T hobbes::compileTo	(	cc *	c,
		const str::seq &	vns,
		const std::string &	expr
	)

◆ compressBytes()

const array<uint8_t>* hobbes::compressBytes ( const array< uint8_t > * bs )

◆ compressLength()

uint8_t hobbes::compressLength	(	size_t	len,
		uint8_t	slen[9]
	)

◆ compressToIfCheck()

bool hobbes::compressToIfCheck	(	MDFA *	dfa,
		const SwitchVal &	sv,
		IfCheck *	out
	)

◆ concat()

template<typename CT , typename CCT >

CT hobbes::concat ( const CCT & cs )

◆ concatArrayPatterns()

Patterns hobbes::concatArrayPatterns ( const Patterns & ps )

◆ concreteClosureEnvType()

MonoTypePtr hobbes::concreteClosureEnvType ( unsigned int size )

◆ concreteClosureMethodType()

QualTypePtr hobbes::concreteClosureMethodType	(	const MonoTypePtr &	envty,
		const MonoTypes &	fargtys,
		const MonoTypePtr &	rty
	)

◆ connectFileSocket()

int hobbes::connectFileSocket ( const std::string & filepath )

◆ connectSocket() [1/4]

int hobbes::connectSocket	(	const std::string &	host,
		int	port
	)

◆ connectSocket() [2/4]

int hobbes::connectSocket ( const std::string & hostport )

◆ connectSocket() [3/4]

int hobbes::connectSocket	(	int	r,
		sockaddr *	saddr,
		size_t	len
	)

◆ connectSocket() [4/4]

int hobbes::connectSocket	(	hostent *	host,
		int	port
	)

◆ cons()

template<typename T >

std::vector<T> hobbes::cons	(	T	h,
		std::vector< T >	t
	)

◆ consMember()

Record::Members hobbes::consMember	(	const std::string &	lbl,
		const MonoTypePtr &	hty,
		const Variant::Members &	tty
	)

◆ constant() [1/6]

llvm::Constant* hobbes::constant	(	llvm::Value *	v,
		bool	globalPtrRefs
	)

inline

◆ constant() [2/6]

ExprPtr hobbes::constant	(	bool	x,
		const LexicalAnnotation &	la
	)

inline

◆ constant() [3/6]

ExprPtr hobbes::constant	(	uint8_t	x,
		const LexicalAnnotation &	la
	)

inline

◆ constant() [4/6]

ExprPtr hobbes::constant	(	int	x,
		const LexicalAnnotation &	la
	)

inline

◆ constant() [5/6]

ExprPtr hobbes::constant	(	long	x,
		const LexicalAnnotation &	la
	)

inline

◆ constant() [6/6]

ExprPtr hobbes::constant	(	size_t	x,
		const LexicalAnnotation &	la
	)

inline

◆ constantRecord()

llvm::Constant* hobbes::constantRecord	(	llvm::Module *	,
		const Constants &	cs,
		const Record *	rty
	)

inline

◆ constArray()

llvm::Constant* hobbes::constArray	(	llvm::Module *	m,
		const Constants &	cs,
		llvm::Type *	elemTy,
		bool	boxAsGlobalRefs = `false`
	)

inline

◆ constructorName()

std::string hobbes::constructorName ( terminal * t )

◆ context()

llvm::LLVMContext& hobbes::context ( )

inline

◆ copyRowWithoutColumn()

void hobbes::copyRowWithoutColumn	(	PatternRows *	out,
		const PatternRow &	row,
		size_t	c
	)

◆ copyStateDef()

void hobbes::copyStateDef	(	const ArgPos &	argpos,
		MDFA *	dfa,
		stateidx_t	state,
		const GlobalToLocalState &	localstate,
		std::set< stateidx_t > *	dones,
		array< IDFAState > *	dfaStates
	)

◆ createFile()

static void hobbes::createFile ( imagefile * f )

static

◆ createFileRegionMap()

fregion& hobbes::createFileRegionMap	(	imagefile *	f,
		file_pageindex_t	page,
		size_t	pages
	)

◆ crossZLibCompressBound()

size_t hobbes::crossZLibCompressBound ( size_t t )

◆ cstrelem()

char hobbes::cstrelem	(	char *	x,
		size_t	i
	)

◆ cstrlen()

size_t hobbes::cstrlen ( char * x )

◆ cvalue() [1/9]

llvm::Constant* hobbes::cvalue ( bool x )

inline

◆ cvalue() [2/9]

llvm::Constant* hobbes::cvalue ( char x )

inline

◆ cvalue() [3/9]

llvm::Constant* hobbes::cvalue ( unsigned char x )

inline

◆ cvalue() [4/9]

llvm::Constant* hobbes::cvalue ( short x )

inline

◆ cvalue() [5/9]

llvm::Constant* hobbes::cvalue ( int x )

inline

◆ cvalue() [6/9]

llvm::Constant* hobbes::cvalue ( unsigned int x )

inline

◆ cvalue() [7/9]

llvm::Constant* hobbes::cvalue ( long x )

inline

◆ cvalue() [8/9]

llvm::Constant* hobbes::cvalue ( float x )

inline

◆ cvalue() [9/9]

llvm::Constant* hobbes::cvalue ( double x )

inline

◆ dateFromDateTime()

long hobbes::dateFromDateTime ( long x )

inline

◆ datetimeAt()

datetimeT hobbes::datetimeAt	(	datetimeT	dt,
		timeT	t
	)

◆ dballoc()

long hobbes::dballoc	(	long	db,
		long	datasz,
		size_t	align
	)

◆ dballocarr()

long hobbes::dballocarr	(	long	db,
		long	elemsz,
		long	len
	)

◆ dbarrcapacity()

long hobbes::dbarrcapacity	(	long	db,
		long	elemsz,
		long	arrref
	)

◆ dbglog()

void hobbes::dbglog ( const std::string & )

◆ dbloadarr()

char* hobbes::dbloadarr	(	long	db,
		long	offset
	)

◆ dbloado()

char* hobbes::dbloado	(	long	db,
		unsigned int	o
	)

◆ dbloadv()

char* hobbes::dbloadv	(	long	db,
		long	offset,
		long	sz
	)

◆ dbsignalupdate()

void hobbes::dbsignalupdate ( long db )

◆ dbunloadarr()

void hobbes::dbunloadarr	(	long	db,
		long	ptr
	)

◆ dbunloadv()

void hobbes::dbunloadv	(	long	db,
		long	ptr,
		long	sz
	)

◆ deadlySignal()

static void hobbes::deadlySignal	(	int	sig,
		siginfo_t *	,
		void *
	)

static

◆ dec() [1/11]

static bool hobbes::dec	(	const ConstraintPtr &	c,
		MonoTypePtr *	lhs,
		MonoTypePtr *	rhs
	)

static

◆ dec() [2/11]

static bool hobbes::dec	(	const ConstraintPtr &	c,
		MonoTypePtr *	lhs,
		MonoTypePtr *	rhs
	)

static

◆ dec() [3/11]

static bool hobbes::dec	(	const ConstraintPtr &	c,
		IsoRecur *	ir
	)

static

◆ dec() [4/11]

static bool hobbes::dec	(	const ConstraintPtr &	c,
		MonoTypePtr *	lhs,
		MonoTypePtr *	rhs
	)

static

◆ dec() [5/11]

bool hobbes::dec	(	const ConstraintPtr &	c,
		Subtype *	st
	)

◆ dec() [6/11]

static bool hobbes::dec	(	const ConstraintPtr &	c,
		FRefLoadable *	fl
	)

static

◆ dec() [7/11]

bool hobbes::dec	(	const ConstraintPtr &	c,
		AppendsTo *	r
	)

◆ dec() [8/11]

bool hobbes::dec	(	const ConstraintPtr &	c,
		HasField *	hf
	)

◆ dec() [9/11]

static bool hobbes::dec	(	const ConstraintPtr &	c,
		ConsVariant *	cv
	)

static

◆ dec() [10/11]

static bool hobbes::dec	(	const ConstraintPtr &	c,
		PacksTo *	pt
	)

static

◆ dec() [11/11]

static bool hobbes::dec	(	const ConstraintPtr &	c,
		ConsRecord *	cr
	)

static

◆ decFieldName()

static bool hobbes::decFieldName	(	const MonoTypePtr &	fieldName,
		std::string *	fn
	)

static

◆ decideTO()

static bool hobbes::decideTO	(	const TEnvPtr &	tenv,
		Definitions *	ds,
		const ConstraintPtr &	c,
		MonoTypePtr *	t0,
		MonoTypePtr *	t1
	)

static

◆ decLF()

static bool hobbes::decLF	(	const ConstraintPtr &	c,
		MonoTypePtr *	lhs,
		MonoTypePtr *	rhs
	)

static

◆ decode() [1/13]

void hobbes::decode	(	std::string *	x,
		std::istream &	in
	)

inline

◆ decode() [2/13]

template<typename T >

void hobbes::decode	(	std::vector< T > *	xs,
		std::istream &	in
	)

inline

◆ decode() [3/13]

template<typename U , typename V >

void hobbes::decode	(	std::pair< U, V > *	p,
		std::istream &	in
	)

inline

◆ decode() [4/13]

template<typename K , typename V >

void hobbes::decode	(	std::map< K, V > *	m,
		std::istream &	in
	)

inline

◆ decode() [5/13]

void hobbes::decode	(	QualTypePtr *	qty,
		std::istream &	in
	)

◆ decode() [6/13]

void hobbes::decode	(	MonoTypePtr *	mty,
		std::istream &	in
	)

◆ decode() [7/13]

MonoTypePtr hobbes::decode ( const std::vector< unsigned char > & in )

◆ decode() [8/13]

MonoTypePtr hobbes::decode	(	const unsigned char *	b,
		const unsigned char *	e
	)

◆ decode() [9/13]

void hobbes::decode	(	PrimitivePtr *	p,
		std::istream &	in
	)

◆ decode() [10/13]

void hobbes::decode	(	ExprPtr *	out,
		std::istream &	in
	)

◆ decode() [11/13]

void hobbes::decode	(	const std::vector< uint8_t > &	d,
		ExprPtr *	e
	)

◆ decode() [12/13]

void hobbes::decode	(	Case::Binding *	b,
		std::istream &	in
	)

◆ decode() [13/13]

void hobbes::decode	(	Switch::Binding *	b,
		std::istream &	in
	)

◆ decodeArr()

MonoTypePtr hobbes::decodeArr	(	const bytes &	in,
		unsigned int *	n
	)

◆ decodeConnType()

Client* hobbes::decodeConnType ( const MonoTypePtr & t )

◆ decodeExists()

MonoTypePtr hobbes::decodeExists	(	const bytes &	in,
		unsigned int *	n
	)

◆ decodeFixedArr()

MonoTypePtr hobbes::decodeFixedArr	(	const bytes &	in,
		unsigned int *	n
	)

◆ decodeFrom()

MonoTypePtr hobbes::decodeFrom	(	const bytes &	in,
		unsigned int *	n
	)

◆ decodeFunc()

MonoTypePtr hobbes::decodeFunc	(	const bytes &	in,
		unsigned int *	n
	)

◆ decodeOpaquePtr()

MonoTypePtr hobbes::decodeOpaquePtr	(	const bytes &	in,
		unsigned int *	n
	)

◆ decodePrim()

MonoTypePtr hobbes::decodePrim	(	const bytes &	in,
		unsigned int *	n
	)

◆ decodeRecord()

MonoTypePtr hobbes::decodeRecord	(	const bytes &	in,
		unsigned int *	n
	)

◆ decodeRecursive()

MonoTypePtr hobbes::decodeRecursive	(	const bytes &	in,
		unsigned int *	n
	)

◆ decodeTAbs()

MonoTypePtr hobbes::decodeTAbs	(	const bytes &	in,
		unsigned int *	n
	)

◆ decodeTApp()

MonoTypePtr hobbes::decodeTApp	(	const bytes &	in,
		unsigned int *	n
	)

◆ decodeTExpr()

MonoTypePtr hobbes::decodeTExpr	(	const bytes &	in,
		unsigned int *	n
	)

◆ decodeTGen()

MonoTypePtr hobbes::decodeTGen	(	const bytes &	in,
		unsigned int *	n
	)

◆ decodeTLong()

MonoTypePtr hobbes::decodeTLong	(	const bytes &	in,
		unsigned int *	n
	)

◆ decodeTO()

static bool hobbes::decodeTO	(	const ConstraintPtr &	c,
		ExprPtr *	e,
		MonoTypePtr *	t
	)

static

◆ decodeTString()

MonoTypePtr hobbes::decodeTString	(	const bytes &	in,
		unsigned int *	n
	)

◆ decodeTVar()

MonoTypePtr hobbes::decodeTVar	(	const bytes &	in,
		unsigned int *	n
	)

◆ decodeVariant()

MonoTypePtr hobbes::decodeVariant	(	const bytes &	in,
		unsigned int *	n
	)

◆ DEFINE_STRUCT()

hobbes::DEFINE_STRUCT	(	RegionState	,
		(const array< char > *, name)	,
		(size_t, id)	,
		(size_t, allocated)	,
		(size_t, used)	,
		(size_t, wasted)
	)

◆ definedSymbols() [1/2]

terminalset hobbes::definedSymbols ( const grammar & g )

◆ definedSymbols() [2/2]

terminalset hobbes::definedSymbols ( const lrtable & t )

◆ definePrivateClass()

void hobbes::definePrivateClass	(	const TEnvPtr &	tenv,
		const std::string &	memberName,
		const ExprPtr &	expr
	)

◆ defPatVarCtor()

Pattern * hobbes::defPatVarCtor	(	const std::string &	vn,
		const LexicalAnnotation &	la
	)

◆ defReadExpr()

ExprPtr hobbes::defReadExpr	(	cc *	c,
		const std::string &	expr
	)

◆ defReadExprDefn()

ExprDefn hobbes::defReadExprDefn	(	cc *	c,
		const std::string &	expr
	)

◆ defReadModule() [1/2]

ModulePtr hobbes::defReadModule	(	cc *	c,
		const char *	text
	)

◆ defReadModule() [2/2]

ModulePtr hobbes::defReadModule	(	cc *	c,
		const std::string &	text
	)

◆ defReadModuleFile()

ModulePtr hobbes::defReadModuleFile	(	cc *	c,
		const std::string &	file
	)

◆ defVarCtor()

Expr * hobbes::defVarCtor	(	const std::string &	vn,
		const LexicalAnnotation &	la
	)

◆ derivesNull() [1/4]

bool hobbes::derivesNull	(	const terminalset &	nullAggs,
		const rule &	r
	)

◆ derivesNull() [2/4]

bool hobbes::derivesNull	(	const grammar &	g,
		const terminalset &	nullAggs,
		terminal *	s
	)

◆ derivesNull() [3/4]

bool hobbes::derivesNull	(	const grammar &	g,
		const terminalset &	nullAggs,
		const terminals &	ss
	)

◆ derivesNull() [4/4]

bool hobbes::derivesNull	(	const parserdef &	p,
		terminal *	s
	)

◆ describeNanoTime()

std::string hobbes::describeNanoTime ( long x )

inline

◆ descStates()

std::string hobbes::descStates ( const stateset & ss )

◆ deserializeGroundClasses()

void hobbes::deserializeGroundClasses	(	const TEnvPtr &	tenv,
		std::istream &	in,
		Definitions *	ds
	)

◆ desugarCompConcat()

ExprPtr hobbes::desugarCompConcat	(	const ExprPtr &	ex,
		const LexicalAnnotation &	la
	)

◆ desugarCompFilter()

ExprPtr hobbes::desugarCompFilter	(	const ExprPtr &	ex,
		const ExprPtr &	filterE,
		const LexicalAnnotation &	la
	)

◆ desugarCompMap()

ExprPtr hobbes::desugarCompMap	(	const std::string &	vn,
		const ExprPtr &	ex,
		const ExprPtr &	ae,
		const LexicalAnnotation &	la
	)

◆ desugarComprehension()

ExprPtr hobbes::desugarComprehension	(	const ExprPtr &	ex,
		const ComprehensionDefs &	cdefs,
		const LexicalAnnotation &	la
	)

◆ desugarComprehensionFrom()

ExprPtr hobbes::desugarComprehensionFrom	(	const ExprPtr &	ex,
		const ComprehensionDefs &	cdefs,
		unsigned int	i,
		const LexicalAnnotation &	la
	)

◆ dfaState()

state hobbes::dfaState	(	const NFA &	nfa,
		const EpsClosure &	ec,
		Nss2Ds *	nss2ds,
		DFA *	dfa,
		const stateset &	ss,
		RStates *	rstates
	)

◆ dfaStateType()

MonoTypePtr hobbes::dfaStateType ( )

◆ diffRegex()

DRegex hobbes::diffRegex	(	const RegexPtr &	lhs,
		const std::string &	x,
		size_t	i
	)

◆ directlyDerivesNull() [1/2]

bool hobbes::directlyDerivesNull ( const rule & r )

◆ directlyDerivesNull() [2/2]

bool hobbes::directlyDerivesNull	(	const grammar &	g,
		terminal *	s
	)

◆ directReads()

terminalset hobbes::directReads	(	const parserdef &	p,
		const transition &	x
	)

◆ disambiguate()

void hobbes::disambiguate	(	const NFA &	nfa,
		DFA *	dfa,
		RStates *	rstates
	)

◆ dispOrd()

terminals hobbes::dispOrd ( const terminalset & ts )

◆ doAction()

ExprPtr hobbes::doAction	(	const ParserEvalInfo &	pei,
		size_t	i,
		const action &	act
	)

◆ doubleType()

llvm::Type* hobbes::doubleType ( )

inline

◆ drop() [1/2]

template<typename K , typename V >

std::map<K, V> hobbes::drop	(	const std::map< K, V > &	m,
		const std::set< K > &	ks
	)

◆ drop() [2/2]

template<typename T >

std::vector<T> hobbes::drop	(	const std::vector< T > &	xs,
		size_t	n
	)

◆ dropUnusedColumns()

void hobbes::dropUnusedColumns	(	PatternRows *	out,
		const PatternRows &	in
	)

◆ dumpBytes()

void hobbes::dumpBytes	(	char *	d,
		long	len
	)

◆ either()

RegexPtr hobbes::either	(	const RegexPtr &	p0,
		const RegexPtr &	p1
	)

◆ elementOf()

ExprPtr hobbes::elementOf	(	const ExprPtr &	arr,
		const ExprPtr &	i,
		const LexicalAnnotation &	la
	)

◆ encode() [1/13]

void hobbes::encode	(	const std::string &	x,
		std::ostream &	out
	)

inline

◆ encode() [2/13]

template<typename T >

void hobbes::encode	(	const std::vector< T > &	xs,
		std::ostream &	out
	)

inline

◆ encode() [3/13]

template<typename U , typename V >

void hobbes::encode	(	const std::pair< U, V > &	p,
		std::ostream &	out
	)

inline

◆ encode() [4/13]

template<typename K , typename V >

void hobbes::encode	(	const std::map< K, V > &	m,
		std::ostream &	out
	)

inline

◆ encode() [5/13]

void hobbes::encode	(	const QualTypePtr &	qty,
		std::ostream &	out
	)

◆ encode() [6/13]

void hobbes::encode	(	const MonoTypePtr &	mty,
		std::ostream &	out
	)

◆ encode() [7/13]

void hobbes::encode	(	const QualTypePtr &	qty,
		std::vector< unsigned char > *	out
	)

◆ encode() [8/13]

void hobbes::encode	(	const MonoTypePtr &	mt,
		std::vector< unsigned char > *	out
	)

◆ encode() [9/13]

void hobbes::encode	(	const PrimitivePtr &	p,
		std::ostream &	out
	)

◆ encode() [10/13]

void hobbes::encode	(	const ExprPtr &	e,
		std::ostream &	out
	)

◆ encode() [11/13]

void hobbes::encode	(	const ExprPtr &	e,
		std::vector< uint8_t > *	d
	)

◆ encode() [12/13]

void hobbes::encode	(	const Case::Binding &	b,
		std::ostream &	out
	)

◆ encode() [13/13]

void hobbes::encode	(	const Switch::Binding &	b,
		std::ostream &	out
	)

◆ end() [1/4]

template<typename T >

const T* hobbes::end ( const array< T > * d )

◆ end() [2/4]

template<typename T >

T* hobbes::end ( array< T > * d )

◆ end() [3/4]

template<typename T >

const T* hobbes::end ( const array< T > & d )

◆ end() [4/4]

template<typename T >

T* hobbes::end ( array< T > & d )

◆ endHighlight()

void hobbes::endHighlight ( std::ostream & out )

◆ endingAt()

prefixes hobbes::endingAt	(	const parserdef &	p,
		const rule &	w,
		terminal *	a
	)

◆ ensureDirExists()

void hobbes::ensureDirExists ( const std::string & path )

◆ entuple()

static MonoTypePtr hobbes::entuple ( const MonoTypePtr & ty )

static

◆ epsilon()

RegexPtr hobbes::epsilon ( )

◆ epsState() [1/2]

const stateset& hobbes::epsState	(	const EpsClosure &	ec,
		state	s
	)

◆ epsState() [2/2]

stateset hobbes::epsState	(	const EpsClosure &	ec,
		const stateset &	ss
	)

◆ equivalent()

bool hobbes::equivalent	(	const TEnvPtr &	tenv,
		const Record::Member &	m0,
		const Record::Member &	m1
	)

◆ etaLift()

ExprPtr hobbes::etaLift	(	const std::string &	opname,
		const MonoTypePtr &	oty,
		const LexicalAnnotation &	la
	)

inline

◆ evalExpr()

ExprPtr hobbes::evalExpr	(	const ParserEvalInfo &	pei,
		terminal *	s,
		size_t	rule
	)

◆ evaluateNetREPLRequest()

void hobbes::evaluateNetREPLRequest	(	int	c,
		void *	d
	)

◆ evaluatePartialHTTPRequest()

void hobbes::evaluatePartialHTTPRequest	(	int	c,
		void *	ud
	)

◆ execProcess()

void hobbes::execProcess ( const std::string & cmd )

◆ expandHiddenTCs()

Constraints hobbes::expandHiddenTCs	(	const TEnvPtr &	tenv,
		const Constraints &	cs
	)

◆ exprs() [1/2]

Exprs hobbes::exprs ( const MkRecord::FieldDefs & ms )

inline

◆ exprs() [2/2]

Exprs hobbes::exprs ( const Case::Bindings & bs )

inline

◆ externDecl()

llvm::Function* hobbes::externDecl	(	llvm::Function *	remoteFn,
		llvm::Module *	thisModule
	)

inline

◆ extractGlobal()

llvm::GlobalVariable* hobbes::extractGlobal ( llvm::Value * e )

◆ extractGrammar()

grammar hobbes::extractGrammar ( const Parser & p )

◆ extractGrammarRule()

terminals hobbes::extractGrammarRule ( const ParseRule::Bindings & bs )

◆ failAppendRecordConstraint()

void hobbes::failAppendRecordConstraint	(	const std::string &	lhs,
		const std::string &	rhs,
		const std::string &	result
	)

◆ failvarmatch()

void hobbes::failvarmatch	(	const array< char > *	file,
		size_t	line,
		const array< char > *	txt,
		char *	addr
	)

◆ fdread() [1/9]

void hobbes::fdread	(	int	fd,
		char *	x,
		size_t	len
	)

inline

◆ fdread() [2/9]

void hobbes::fdread	(	int	fd,
		unsigned char *	x,
		size_t	len
	)

inline

◆ fdread() [3/9]

void hobbes::fdread	(	int	fd,
		char *	x
	)

inline

◆ fdread() [4/9]

void hobbes::fdread	(	int	fd,
		uint8_t *	x
	)

inline

◆ fdread() [5/9]

void hobbes::fdread	(	int	fd,
		int *	x
	)

inline

◆ fdread() [6/9]

void hobbes::fdread	(	int	fd,
		uint32_t *	x
	)

inline

◆ fdread() [7/9]

void hobbes::fdread	(	int	fd,
		size_t *	x
	)

inline

◆ fdread() [8/9]

void hobbes::fdread	(	int	fd,
		std::string *	x
	)

inline

◆ fdread() [9/9]

template<typename T >

void hobbes::fdread	(	int	fd,
		std::vector< T > *	xs
	)

inline

◆ fdRead()

template<typename T >

T hobbes::fdRead ( int fd )

◆ fdwrite() [1/9]

void hobbes::fdwrite	(	int	fd,
		const char *	x,
		size_t	len
	)

inline

◆ fdwrite() [2/9]

void hobbes::fdwrite	(	int	fd,
		const unsigned char *	x,
		size_t	len
	)

inline

◆ fdwrite() [3/9]

void hobbes::fdwrite	(	int	fd,
		char	x
	)

inline

◆ fdwrite() [4/9]

void hobbes::fdwrite	(	int	fd,
		uint8_t	x
	)

inline

◆ fdwrite() [5/9]

void hobbes::fdwrite	(	int	fd,
		int	x
	)

inline

◆ fdwrite() [6/9]

void hobbes::fdwrite	(	int	fd,
		uint32_t	x
	)

inline

◆ fdwrite() [7/9]

void hobbes::fdwrite	(	int	fd,
		size_t	x
	)

inline

◆ fdwrite() [8/9]

void hobbes::fdwrite	(	int	fd,
		const std::string &	x
	)

inline

◆ fdwrite() [9/9]

template<typename T >

void hobbes::fdwrite	(	int	fd,
		const std::vector< T > &	xs
	)

inline

◆ fdWrite()

template<typename T >

void hobbes::fdWrite	(	int	fd,
		T	x
	)

◆ fdWriteBytes()

void hobbes::fdWriteBytes	(	int	fd,
		const array< unsigned char > *	bs
	)

◆ fdWriteChars()

void hobbes::fdWriteChars	(	int	fd,
		const array< char > *	cs
	)

◆ field()

ExprPtr hobbes::field	(	MDFA *	dfa,
		const std::string &	vn,
		const std::string &	fn
	)

◆ fileExists()

bool hobbes::fileExists ( const std::string & fname )

◆ fileModeFlags()

static uint32_t hobbes::fileModeFlags ( const MonoTypePtr & t )

static

◆ filePosition()

static off_t hobbes::filePosition ( const imagefile * f )

static

◆ filerefTy()

static MonoTypePtr hobbes::filerefTy ( const MonoTypePtr & ty )

static

◆ filerefty()

MonoTypePtr hobbes::filerefty ( const MonoTypePtr & t )

inline

◆ fileType()

MonoTypePtr hobbes::fileType	(	bool	writeable,
		const MonoTypePtr &	stype
	)

◆ fileWatchData()

const array<FileWatchData>* hobbes::fileWatchData ( )

◆ findClass()

const TClass* hobbes::findClass	(	const TEnvPtr &	tenv,
		const std::string &	cname
	)

◆ findEpsClosure() [1/2]

void hobbes::findEpsClosure	(	const NFA &	nfa,
		state	s,
		statemarks *	sms,
		EpsClosure *	ec
	)

◆ findEpsClosure() [2/2]

void hobbes::findEpsClosure	(	const NFA &	nfa,
		EpsClosure *	ec
	)

◆ findEquivStates()

EqStates hobbes::findEquivStates ( const DFA & dfa )

◆ findHiddenMember()

int hobbes::findHiddenMember	(	int	i,
		const std::string &	lbl,
		const Variant::Members &	ms
	)

◆ findPageWithSpace()

static bool hobbes::findPageWithSpace	(	imagefile *	f,
		pagetype::code	pt,
		size_t	datalen,
		size_t	alignment,
		file_pageindex_t *	idx
	)

static

◆ findRowResults()

RowResults hobbes::findRowResults	(	MDFA *	dfa,
		stateidx_t	s
	)

◆ findSpace()

size_t hobbes::findSpace	(	imagefile *	f,
		pagetype::code	pt,
		size_t	datalen,
		size_t	alignment
	)

◆ findThreadRegion()

size_t hobbes::findThreadRegion ( const std::string & n )

◆ first()

template<typename L , typename R >

std::vector<L> hobbes::first ( const std::vector< std::pair< L, R > > & xs )

◆ floatType()

llvm::Type* hobbes::floatType ( )

inline

◆ fmtFoldConst()

ExprPtr hobbes::fmtFoldConst	(	const ExprPtr &	e,
		const std::string &	c
	)

◆ fmtFoldExpr()

ExprPtr hobbes::fmtFoldExpr	(	const ExprPtr &	e,
		const std::string &	expr
	)

◆ fn() [1/2]

ExprPtr hobbes::fn	(	const str::seq &	vns,
		const ExprPtr &	b,
		const LexicalAnnotation &	la
	)

inline

◆ fn() [2/2]

ExprPtr hobbes::fn	(	const std::string &	vn,
		const ExprPtr &	b,
		const LexicalAnnotation &	la
	)

inline

◆ fncall() [1/4]

llvm::Value* hobbes::fncall	(	llvm::IRBuilder<> *	b,
		llvm::Value *	vfn,
		const Values &	args
	)

inline

◆ fncall() [2/4]

llvm::Value* hobbes::fncall	(	llvm::IRBuilder<> *	b,
		llvm::Value *	fn,
		llvm::Value *	arg
	)

inline

◆ fncall() [3/4]

ExprPtr hobbes::fncall	(	const ExprPtr &	f,
		const Exprs &	args,
		const LexicalAnnotation &	la
	)

inline

◆ fncall() [4/4]

ExprPtr hobbes::fncall	(	const ExprPtr &	f,
		const ExprPtr &	a,
		const LexicalAnnotation &	la
	)

inline

◆ fnFrame()

TEnvPtr hobbes::fnFrame	(	const TEnvPtr &	p,
		const str::seq &	vs,
		const MonoTypes &	atys
	)

◆ fnresult()

MonoTypePtr hobbes::fnresult ( const MonoTypePtr & fty )

inline

◆ focusOnFundep()

MaybePathPoints hobbes::focusOnFundep	(	const VarIDs &	vs,
		const MonoTypes &	mts
	)

◆ follow() [1/7]

itemset hobbes::follow	(	const grammar &	g,
		const itemset &	is,
		terminal *	v
	)

◆ follow() [2/7]

itemsets hobbes::follow	(	const grammar &	g,
		const itemset &	is,
		const terminals &	vs
	)

◆ follow() [3/7]

state_transitions hobbes::follow	(	const grammar &	g,
		const itemset &	is,
		const terminalset &	vs,
		parserdef *	p
	)

◆ follow() [4/7]

nat hobbes::follow	(	const parserdef &	p,
		nat	q,
		terminal *	t
	)

◆ Follow()

transition_lookahead hobbes::Follow	(	const parserdef &	p,
		const transitionset &	ts
	)

◆ follow() [5/7]

nat hobbes::follow	(	const state_transitions &	st,
		terminal *	t
	)

◆ follow() [6/7]

nat hobbes::follow	(	const parserdef &	p,
		const transition &	x
	)

◆ follow() [7/7]

nat hobbes::follow	(	const parserdef &	p,
		nat	s,
		const terminals &	ts
	)

◆ follows() [1/2]

bool hobbes::follows	(	const state_transitions &	st,
		terminal *	t
	)

◆ follows() [2/2]

bool hobbes::follows	(	const parserdef &	p,
		nat	q,
		terminal *	t
	)

◆ forConvertibility()

bool hobbes::forConvertibility ( const PatternPtr & p )

◆ formatDateTime()

const array<char>* hobbes::formatDateTime	(	const array< char > *	fmt,
		datetimeT	x
	)

◆ formatTimeV()

const array<char>* hobbes::formatTimeV	(	const array< char > *	fmt,
		long	tus
	)

◆ freeParserData()

void hobbes::freeParserData ( )

◆ freeVars() [1/2]

VarSet hobbes::freeVars ( const ExprPtr & e )

◆ freeVars() [2/2]

VarSet hobbes::freeVars ( const Expr & e )

◆ frefType()

const MonoTypePtr & hobbes::frefType ( const MonoTypePtr & fref )

◆ freshen() [1/3]

MonoTypes hobbes::freshen ( const MonoTypes & ts )

◆ freshen() [2/3]

ConstraintPtr hobbes::freshen ( const ConstraintPtr & cst )

◆ freshen() [3/3]

Constraints hobbes::freshen ( const Constraints & cs )

◆ freshName()

TVName hobbes::freshName ( )

◆ freshNames()

Names hobbes::freshNames ( int vs )

◆ freshTypeVar()

MonoTypePtr hobbes::freshTypeVar ( )

◆ freshTypeVars()

MonoTypes hobbes::freshTypeVars ( int vs )

◆ fromSet()

template<typename CT >

CT hobbes::fromSet ( const std::set< typename CT::value_type > & xs )

inline

◆ functionType()

llvm::FunctionType* hobbes::functionType	(	const Types &	argTys,
		llvm::Type *	rty
	)

inline

◆ functy() [1/2]

MonoTypePtr hobbes::functy	(	const MonoTypePtr &	aty,
		const MonoTypePtr &	rty
	)

inline

◆ functy() [2/2]

MonoTypePtr hobbes::functy	(	const MonoTypes &	atys,
		const MonoTypePtr &	rty
	)

inline

◆ generalize()

PolyTypePtr hobbes::generalize ( const QualTypePtr & qt )

◆ get() [1/2]

template<typename T , typename ... Ctors>

T* hobbes::get ( variant< Ctors... > & v )

◆ get() [2/2]

template<typename T , typename ... Ctors>

const T* hobbes::get ( const variant< Ctors... > & v )

◆ getMemoryPool()

array<RegionState>* hobbes::getMemoryPool ( )

◆ gleb()

template<typename K , typename V >

std::map<K, V>::iterator hobbes::gleb	(	std::map< K, V > &	m,
		const K &	x
	)

◆ gmtoffset()

timespanT hobbes::gmtoffset ( datetimeT x )

◆ groupRecordPatterns()

NamedPatternGroups hobbes::groupRecordPatterns ( const Patterns & ps )

◆ groupVariantPatterns()

NamedPatternGroups hobbes::groupVariantPatterns ( const Patterns & ps )

◆ hasConstraint() [1/2]

bool hobbes::hasConstraint	(	const ConstraintPtr &	c,
		const Constraints &	cs
	)

◆ hasConstraint() [2/2]

bool hobbes::hasConstraint	(	const ConstraintPtr &	c,
		const QualTypePtr &	qt
	)

◆ hasFreeVariables() [1/5]

bool hobbes::hasFreeVariables ( const QualTypePtr & qt )

◆ hasFreeVariables() [2/5]

bool hobbes::hasFreeVariables ( const Constraints & cs )

◆ hasFreeVariables() [3/5]

bool hobbes::hasFreeVariables ( const ConstraintPtr & c )

◆ hasFreeVariables() [4/5]

bool hobbes::hasFreeVariables ( const MonoTypePtr & mt )

◆ hasFreeVariables() [5/5]

bool hobbes::hasFreeVariables ( const MonoTypes & mts )

◆ hash()

size_t hobbes::hash ( const PatternRow & pr )

◆ hashAppend()

template<typename T >

void hobbes::hashAppend	(	std::size_t &	seed,
		const T &	x
	)

inline

◆ hashTuple()

template<std::size_t i, typename ... Ts>

std::enable_if<i == sizeof...(Ts), void>::type hobbes::hashTuple	(	std::size_t *	,
		const std::tuple< Ts... > &
	)

inline

◆ hasPointerRep() [1/2]

bool hobbes::hasPointerRep ( const MonoTypePtr & t )

inline

◆ hasPointerRep() [2/2]

bool hobbes::hasPointerRep ( const PolyTypePtr & t )

inline

◆ hasRootBinding()

static bool hobbes::hasRootBinding	(	const std::string &	vn,
		const TEnvPtr &	tenv,
		const TEnvs	roots
	)

static

◆ hasRule()

bool hobbes::hasRule	(	const grammar &	g,
		terminal *	t
	)

◆ hasSingularType()

bool hobbes::hasSingularType ( const ExprPtr & e )

◆ hiddenCtor()

static bool hobbes::hiddenCtor ( const Variant::Member & m )

static

◆ HOBBES_LIFT_PRIMITIVE() [1/13]

hobbes::HOBBES_LIFT_PRIMITIVE	(	void	,
		unit
	)

◆ HOBBES_LIFT_PRIMITIVE() [2/13]

hobbes::HOBBES_LIFT_PRIMITIVE	(	unit	,
		unit
	)

◆ HOBBES_LIFT_PRIMITIVE() [3/13]

hobbes::HOBBES_LIFT_PRIMITIVE	(	bool	,
		bool
	)

◆ HOBBES_LIFT_PRIMITIVE() [4/13]

hobbes::HOBBES_LIFT_PRIMITIVE	(	char	,
		char
	)

◆ HOBBES_LIFT_PRIMITIVE() [5/13]

hobbes::HOBBES_LIFT_PRIMITIVE	(	unsigned	char,
		byte
	)

◆ HOBBES_LIFT_PRIMITIVE() [6/13]

hobbes::HOBBES_LIFT_PRIMITIVE	(	short	,
		short
	)

◆ HOBBES_LIFT_PRIMITIVE() [7/13]

hobbes::HOBBES_LIFT_PRIMITIVE	(	unsigned	short,
		short
	)

◆ HOBBES_LIFT_PRIMITIVE() [8/13]

hobbes::HOBBES_LIFT_PRIMITIVE	(	int	,
		int
	)

◆ HOBBES_LIFT_PRIMITIVE() [9/13]

hobbes::HOBBES_LIFT_PRIMITIVE	(	unsigned	int,
		int
	)

◆ HOBBES_LIFT_PRIMITIVE() [10/13]

hobbes::HOBBES_LIFT_PRIMITIVE	(	long	,
		long
	)

◆ HOBBES_LIFT_PRIMITIVE() [11/13]

hobbes::HOBBES_LIFT_PRIMITIVE	(	unsigned	long,
		long
	)

◆ HOBBES_LIFT_PRIMITIVE() [12/13]

hobbes::HOBBES_LIFT_PRIMITIVE	(	float	,
		float
	)

◆ HOBBES_LIFT_PRIMITIVE() [13/13]

hobbes::HOBBES_LIFT_PRIMITIVE	(	double	,
		double
	)

◆ impliedType() [1/3]

static MonoTypePtr hobbes::impliedType ( const std::string & fieldName )

static

◆ impliedType() [2/3]

static MonoTypePtr hobbes::impliedType ( const std::string & fieldName )

static

◆ impliedType() [3/3]

static MonoTypePtr hobbes::impliedType ( const MonoTypePtr & fieldName )

static

◆ impliedValue()

static ExprPtr hobbes::impliedValue	(	const std::string &	fieldName,
		const LexicalAnnotation &	la
	)

static

◆ import()

void hobbes::import	(	cc *	e,
		const std::string &	mname
	)

◆ importDefs()

void hobbes::importDefs	(	const Record::Members &	ms,
		Record::Members *	out
	)

◆ importObject()

bool hobbes::importObject	(	cc *	e,
		const std::string &	sopath
	)

◆ importScript()

bool hobbes::importScript	(	cc *	e,
		const std::string &	fname
	)

◆ in() [1/3]

template<typename T >

bool hobbes::in	(	T	x,
		const std::set< T > &	xs
	)

◆ in() [2/3]

template<typename T >

bool hobbes::in	(	T	x,
		const std::vector< T > &	xs
	)

◆ in() [3/3]

bool hobbes::in	(	const ConstraintPtr &	c,
		const Constraints &	cs
	)

inline

◆ includeFundep()

void hobbes::includeFundep	(	const Constraint &	c,
		const FunDep &	fd,
		FunDeps *	out
	)

◆ includes()

bool hobbes::includes	(	const parserdef &	p,
		const transition &	x,
		const transition &	y
	)

◆ index() [1/2]

template<typename T >

int hobbes::index	(	const std::vector< T > &	xs,
		T	x
	)

◆ index() [2/2]

template<typename T >

std::vector<int> hobbes::index	(	const std::vector< T > &	xs,
		const std::vector< T > &	lxs
	)

◆ inferFileType()

MonoTypePtr hobbes::inferFileType ( reader * r )

◆ inferFundeps()

FunDeps hobbes::inferFundeps	(	const TEnvPtr &	tenv,
		const Constraints &	cs
	)

◆ initDefOperators()

void hobbes::initDefOperators ( cc * c )

◆ initMacroEnvironment()

void hobbes::initMacroEnvironment ( const TEnvPtr & tenv )

◆ initNetworkDefs()

void hobbes::initNetworkDefs ( cc & c )

◆ initSignalsDefs()

void hobbes::initSignalsDefs	(	FieldVerifier *	fv,
		cc &	c
	)

◆ initStdFuncDefs()

void hobbes::initStdFuncDefs ( cc & ctx )

◆ initStorageFileDefs()

void hobbes::initStorageFileDefs	(	FieldVerifier *	fv,
		cc &	c
	)

◆ initStrPredicates()

void hobbes::initStrPredicates ( const TEnvPtr & tenv )

◆ injFileReferences()

MonoTypePtr hobbes::injFileReferences	(	const MonoTypePtr &	ty,
		const ExprPtr &	f
	)

◆ inLetExp()

ExprPtr hobbes::inLetExp	(	const str::seq &	vns,
		const Exprs &	es,
		const ExprPtr &	b,
		const LexicalAnnotation &	la
	)

◆ insert()

void hobbes::insert	(	stateset *	o,
		const stateset &	i
	)

◆ insertFieldDefs() [1/2]

void hobbes::insertFieldDefs	(	const MkRecord::FieldDefs &	ifds,
		MkRecord::FieldDefs *	out
	)

◆ insertFieldDefs() [2/2]

void hobbes::insertFieldDefs	(	const MkRecord::FieldDefs &	ifds,
		size_t	c,
		MkRecord::FieldDefs *	out
	)

◆ insertFieldDefsFromProj() [1/3]

void hobbes::insertFieldDefsFromProj	(	const ExprPtr &	rec,
		const Record *	rty,
		MkRecord::FieldDefs *	out
	)

◆ insertFieldDefsFromProj() [2/3]

void hobbes::insertFieldDefsFromProj	(	const ExprPtr &	rec,
		const MonoTypePtr &	rty,
		MkRecord::FieldDefs *	out
	)

◆ insertFieldDefsFromProj() [3/3]

void hobbes::insertFieldDefsFromProj	(	const ExprPtr &	rec,
		MkRecord::FieldDefs *	out
	)

◆ insertFieldDefsSfx()

void hobbes::insertFieldDefsSfx	(	const MkRecord::FieldDefs &	ifds,
		size_t	c,
		MkRecord::FieldDefs *	out
	)

◆ insertPageSizeIndex()

static void hobbes::insertPageSizeIndex	(	imagefile *	f,
		file_pageindex_t	page
	)

static

◆ installHTTPD()

int hobbes::installHTTPD	(	int	port,
		HTTPRequestHandler	f,
		void *	ud = `0`
	)

◆ installNetREPL() [1/4]

int hobbes::installNetREPL	(	int	port,
		Server *	svr
	)

◆ installNetREPL() [2/4]

int hobbes::installNetREPL	(	const std::string &	filepath,
		Server *	svr
	)

◆ installNetREPL() [3/4]

int hobbes::installNetREPL	(	int	port,
		cc *	c
	)

◆ installNetREPL() [4/4]

int hobbes::installNetREPL	(	const std::string &	filepath,
		cc *	c
	)

◆ instantiate() [1/15]

QualTypePtr hobbes::instantiate	(	int	vs,
		const QualTypePtr &	scheme
	)

◆ instantiate() [2/15]

Constraints hobbes::instantiate	(	int	vs,
		const Constraints &	cs
	)

◆ instantiate() [3/15]

ConstraintPtr hobbes::instantiate	(	int	vs,
		const ConstraintPtr &	c
	)

◆ instantiate() [4/15]

MonoTypePtr hobbes::instantiate	(	int	vs,
		const MonoTypePtr &	mt
	)

◆ instantiate() [5/15]

MonoTypes hobbes::instantiate	(	int	vs,
		const MonoTypes &	ts
	)

◆ instantiate() [6/15]

QualTypePtr hobbes::instantiate	(	const Names &	ns,
		const QualTypePtr &	scheme
	)

◆ instantiate() [7/15]

Constraints hobbes::instantiate	(	const Names &	ns,
		const Constraints &	cs
	)

◆ instantiate() [8/15]

ConstraintPtr hobbes::instantiate	(	const Names &	ns,
		const ConstraintPtr &	c
	)

◆ instantiate() [9/15]

MonoTypePtr hobbes::instantiate	(	const Names &	ns,
		const MonoTypePtr &	mt
	)

◆ instantiate() [10/15]

MonoTypes hobbes::instantiate	(	const Names &	ns,
		const MonoTypes &	ts
	)

◆ instantiate() [11/15]

QualTypePtr hobbes::instantiate	(	const MonoTypes &	ts,
		const QualTypePtr &	scheme
	)

◆ instantiate() [12/15]

Constraints hobbes::instantiate	(	const MonoTypes &	ts,
		const Constraints &	cs
	)

◆ instantiate() [13/15]

ConstraintPtr hobbes::instantiate	(	const MonoTypes &	ts,
		const ConstraintPtr &	c
	)

◆ instantiate() [14/15]

MonoTypePtr hobbes::instantiate	(	const MonoTypes &	ts,
		const MonoTypePtr &	mt
	)

◆ instantiate() [15/15]

MonoTypes hobbes::instantiate	(	const MonoTypes &	ts,
		const MonoTypes &	sts
	)

◆ intType()

llvm::Type* hobbes::intType ( )

inline

◆ invocationID()

int hobbes::invocationID	(	const proc &	p,
		const std::string &	fname,
		const MonoTypePtr &	hasty
	)

◆ IOP() [1/7]

hobbes::IOP	(	not	,
		CreateNot	,
		bool	,
		bool
	)

◆ IOP() [2/7]

hobbes::IOP	(	bnot	,
		CreateNot	,
		unsigned	char,
		unsigned	char
	)

◆ IOP() [3/7]

hobbes::IOP	(	sneg	,
		CreateNeg	,
		short	,
		short
	)

◆ IOP() [4/7]

hobbes::IOP	(	ineg	,
		CreateNeg	,
		int	,
		int
	)

◆ IOP() [5/7]

hobbes::IOP	(	lneg	,
		CreateNeg	,
		long	,
		long
	)

◆ IOP() [6/7]

hobbes::IOP	(	fneg	,
		CreateFNeg	,
		float	,
		float
	)

◆ IOP() [7/7]

hobbes::IOP	(	dneg	,
		CreateFNeg	,
		double	,
		double
	)

◆ is() [1/2]

template<typename T , typename S >

const T* hobbes::is ( const S * s )

◆ is() [2/2]

template<typename T , typename S >

T* hobbes::is ( const std::shared_ptr< S > & s )

◆ isAllocatedConnection()

bool hobbes::isAllocatedConnection ( Client * c )

◆ isClassMember()

bool hobbes::isClassMember	(	const TEnvPtr &	tenv,
		const std::string &	memberName
	)

◆ isClassSatisfiable()

bool hobbes::isClassSatisfiable	(	const TEnvPtr &	tenv,
		const std::string &	cname,
		const MonoTypes &	tys,
		Definitions *	ds
	)

◆ isClassSatisfied()

bool hobbes::isClassSatisfied	(	const TEnvPtr &	tenv,
		const std::string &	cname,
		const MonoTypes &	tys,
		Definitions *	ds
	)

◆ isConst()

bool hobbes::isConst ( const ExprPtr & e )

◆ isDBFile()

bool hobbes::isDBFile ( const std::string & fname )

◆ isFieldName()

static bool hobbes::isFieldName	(	const MonoTypePtr &	fn,
		std::string *	sfn
	)

static

◆ isFileMode()

static bool hobbes::isFileMode ( const MonoTypePtr & t )

static

◆ isFileRef()

bool hobbes::isFileRef ( const MonoTypePtr & mt )

◆ isFileType()

bool hobbes::isFileType ( const MonoTypePtr & fty )

◆ isFreeVarNameIn() [1/2]

bool hobbes::isFreeVarNameIn	(	const TVName &	n,
		const MonoTypePtr &	t
	)

◆ isFreeVarNameIn() [2/2]

bool hobbes::isFreeVarNameIn	(	const TVName &	n,
		const MonoTypes &	ts
	)

◆ isHiddenTCName()

bool hobbes::isHiddenTCName ( const std::string & n )

inline

◆ isLargeType()

bool hobbes::isLargeType ( const MonoTypePtr & mty )

inline

◆ isLiteralFnTerm()

bool hobbes::isLiteralFnTerm ( const ExprPtr & e )

◆ isM()

template<typename T , typename S >

T* hobbes::isM ( S * s )

◆ isMaybe()

MonoTypePtr hobbes::isMaybe ( const MonoTypePtr & t )

inline

◆ isMonoSingular() [1/4]

bool hobbes::isMonoSingular ( const MonoType & mt )

◆ isMonoSingular() [2/4]

bool hobbes::isMonoSingular ( const MonoType * mt )

◆ isMonoSingular() [3/4]

bool hobbes::isMonoSingular ( const MonoTypePtr & mt )

◆ isMonoSingular() [4/4]

bool hobbes::isMonoSingular ( const QualTypePtr & qt )

◆ isMonotype() [1/2]

bool hobbes::isMonotype ( const QualTypePtr & qt )

◆ isMonotype() [2/2]

bool hobbes::isMonotype ( const PolyTypePtr & pt )

◆ isNonTerminal()

bool hobbes::isNonTerminal	(	const ParserEvalInfo &	pei,
		terminal *	t
	)

◆ isPartialConnection()

bool hobbes::isPartialConnection ( const MonoTypePtr & t )

◆ isPrimName()

bool hobbes::isPrimName ( const std::string & tn )

◆ isPrimSelection()

bool hobbes::isPrimSelection	(	bool	alwaysLowerPrimMatchTables,
		const PatternRows &	ps
	)

◆ isRecordLike()

bool hobbes::isRecordLike ( const MonoTypePtr & mt )

◆ isSafeExistentialType()

bool hobbes::isSafeExistentialType ( const Exists * e )

◆ isTupleDesc()

bool hobbes::isTupleDesc ( const Record::Members & ms )

◆ isTupleLike() [1/3]

bool hobbes::isTupleLike ( const std::string & fname )

◆ isTupleLike() [2/3]

bool hobbes::isTupleLike ( const Record::Members & ms )

◆ isTupleLike() [3/3]

bool hobbes::isTupleLike ( const MkRecord::FieldDefs & fds )

◆ isUnit()

bool hobbes::isUnit ( const MonoTypePtr & t )

inline

◆ isUnitPat()

bool hobbes::isUnitPat ( const PatternPtr & p )

◆ isVoid()

bool hobbes::isVoid ( const MonoTypePtr & t )

inline

◆ isWriteable()

static bool hobbes::isWriteable ( uint32_t f )

static

◆ joinedRecord() [1/2]

MonoTypePtr hobbes::joinedRecord	(	const MonoTypePtr &	lhs,
		const MonoTypePtr &	rhs
	)

◆ joinedRecord() [2/2]

QualTypePtr hobbes::joinedRecord	(	const QualTypePtr &	lhs,
		const QualTypePtr &	rhs
	)

◆ justE()

ExprPtr hobbes::justE	(	const ExprPtr &	e,
		const LexicalAnnotation &	la
	)

inline

◆ keys()

template<typename K , typename V >

std::set<K> hobbes::keys ( const std::map< K, V > & m )

◆ lalr1parser()

parserdef hobbes::lalr1parser	(	const grammar &	g,
		terminal *	s
	)

◆ lalrTable() [1/2]

lrtable hobbes::lalrTable	(	const parserdef &	pd,
		const precedence &	p = `precedence()`
	)

◆ lalrTable() [2/2]

lrtable hobbes::lalrTable	(	const grammar &	g,
		terminal *	s,
		const precedence &	p = `precedence()`
	)

◆ lengthOf()

ExprPtr hobbes::lengthOf	(	const ExprPtr &	arr,
		const LexicalAnnotation &	la
	)

◆ let() [1/3]

ExprPtr hobbes::let	(	const std::string &	vn,
		const ExprPtr &	e,
		const ExprPtr &	b,
		const LexicalAnnotation &	la
	)

inline

◆ let() [2/3]

ExprPtr hobbes::let	(	const Definitions &	bs,
		const ExprPtr &	b,
		const LexicalAnnotation &	la
	)

inline

◆ let() [3/3]

ExprPtr hobbes::let	(	const Exprs &	es,
		const ExprPtr &	b,
		const LexicalAnnotation &	la
	)

inline

◆ liftArraysAsGlobals()

Constants hobbes::liftArraysAsGlobals	(	llvm::Module *	m,
		const Constants &	cs,
		const MonoTypes &	tys
	)

inline

◆ liftAsGlobalRef()

llvm::Constant* hobbes::liftAsGlobalRef	(	llvm::Module *	m,
		llvm::Constant *	c
	)

inline

◆ liftAsGlobalRefs()

Constants hobbes::liftAsGlobalRefs	(	llvm::Module *	m,
		const Constants &	cs
	)

inline

◆ liftConstraints()

Constraints hobbes::liftConstraints ( const Exprs & es )

inline

◆ liftDFAExpr() [1/2]

ExprPtr hobbes::liftDFAExpr	(	cc *	c,
		const PatternRows &	ps,
		const LexicalAnnotation &	rootLA
	)

◆ liftDFAExpr() [2/2]

ExprPtr hobbes::liftDFAExpr	(	MDFA *	dfa,
		stateidx_t	state
	)

◆ liftDFAExprWithSwitchCompression()

ExprPtr hobbes::liftDFAExprWithSwitchCompression	(	MDFA *	dfa,
		stateidx_t	state
	)

◆ liftPrimMatchExpr()

ExprPtr hobbes::liftPrimMatchExpr	(	MDFA *	dfa,
		stateidx_t	state
	)

◆ liftQualifiers()

QualLiftedMonoTypes hobbes::liftQualifiers ( const QualTypes & qts )

◆ liftTypesAsAssumptions()

ExprPtr hobbes::liftTypesAsAssumptions ( const ExprPtr & e )

◆ list() [1/2]

template<typename T >

std::vector<T> hobbes::list ( )

◆ list() [2/2]

template<typename T , typename ... Ts>

std::vector<T> hobbes::list	(	const T &	x,
		const Ts &...	xs
	)

◆ litValue()

PrimitivePtr hobbes::litValue ( const MatchLiteral & ml )

◆ llvmPrim()

llvm::Type* hobbes::llvmPrim	(	const std::string &	name,
		bool	asArg
	)

◆ llvmVarArrType()

llvm::Type * hobbes::llvmVarArrType	(	llvm::Type *	elemty,
		int	size = `1`
	)

◆ load()

ldblines hobbes::load	(	const linedb::ptr &	ldb,
		const linedb::LineCol &	i,
		const linedb::LineCol &	f
	)

◆ loadFileSize()

static bool hobbes::loadFileSize ( imagefile * f )

static

◆ localState()

size_t hobbes::localState	(	const GlobalToLocalState &	localstate,
		stateidx_t	state
	)

◆ longType()

llvm::Type* hobbes::longType ( )

inline

◆ lookback()

bool hobbes::lookback	(	const parserdef &	p,
		nat	q,
		terminal *	r,
		const rule &	w,
		const transition &	t
	)

◆ looksLikeSum()

bool hobbes::looksLikeSum ( const Variant::Members & ms )

◆ lookup()

template<typename K , typename T >

T hobbes::lookup	(	const std::map< K, T > &	tenv,
		const K &	n
	)

inline

◆ lookupFieldType() [1/2]

QualTypePtr hobbes::lookupFieldType	(	const QualTypePtr &	qt,
		const std::string &	fieldName
	)

◆ lookupFieldType() [2/2]

MonoTypePtr hobbes::lookupFieldType	(	const MonoTypePtr &	mt,
		const std::string &	fieldName
	)

◆ lookupPort()

int hobbes::lookupPort ( const std::string & x )

◆ lr0parser()

parserdef hobbes::lr0parser	(	const grammar &	g,
		terminal *	s
	)

◆ lrand()

long hobbes::lrand	(	long	low,
		long	high
	)

◆ macroExpand()

ExprPtr hobbes::macroExpand ( const ExprPtr & e )

◆ make()

template<typename T , typename ... Args>

T* hobbes::make ( const Args &... args )

◆ makeArray() [1/2]

template<typename T >

array<T>* hobbes::makeArray	(	region &	m,
		long	n
	)

◆ makeArray() [2/2]

template<typename T >

array<T>* hobbes::makeArray ( long n )

◆ makeArrayState()

MStatePtr hobbes::makeArrayState	(	MDFA *	dfa,
		const PatternRows &	ps,
		size_t	c
	)

◆ makeASAnyRow()

void hobbes::makeASAnyRow	(	size_t	len,
		PatternRows *	out,
		const PatternRow &	r,
		size_t	c
	)

◆ makeASplitRow()

void hobbes::makeASplitRow	(	const MatchArray &	ma,
		PatternRows *	out,
		const PatternRow &	r,
		size_t	c
	)

◆ makeASSuccState()

stateidx_t hobbes::makeASSuccState	(	const std::string &	arrayVar,
		size_t	len,
		MDFA *	dfa,
		const PatternRows &	nps
	)

◆ makeASSwitch()

MStatePtr hobbes::makeASSwitch	(	const std::string &	arrayVar,
		MDFA *	dfa,
		const std::vector< std::pair< size_t, stateidx_t > > &	lenjmps,
		stateidx_t	defState
	)

◆ makeCharArrayState()

MStatePtr hobbes::makeCharArrayState	(	MDFA *	dfa,
		const PatternRows &	ps,
		size_t	c
	)

◆ makeClosureOver()

ExprPtr hobbes::makeClosureOver	(	const Fn *	f,
		const VarSet &	vs
	)

◆ makeCompiledPrimMatchFunction()

void hobbes::makeCompiledPrimMatchFunction	(	const std::string &	fname,
		MDFA *	dfa,
		stateidx_t	state
	)

◆ makeConnection()

Client* hobbes::makeConnection ( const std::string & hp )

◆ makeConnType()

MonoTypePtr hobbes::makeConnType ( Client * c )

◆ makeDFA()

stateidx_t hobbes::makeDFA	(	MDFA *	dfa,
		const PatternRows &	ps,
		const LexicalAnnotation &	la
	)

◆ makeDFAFunc()

void hobbes::makeDFAFunc	(	cc *	c,
		const std::string &	fname,
		const DFA &	dfa,
		const LexicalAnnotation &	rootLA
	)

◆ makeDFAState()

stateidx_t hobbes::makeDFAState	(	MDFA *	dfa,
		const PatternRows &	ps
	)

◆ makeFileRef()

MonoTypePtr hobbes::makeFileRef	(	const MonoTypePtr &	ty,
		const MonoTypePtr &	f
	)

◆ makeInputParserState()

ExprPtr hobbes::makeInputParserState	(	const ParserEvalInfo &	pei,
		size_t	i
	)

◆ makeInterpretedPrimMatchFunction()

void hobbes::makeInterpretedPrimMatchFunction	(	const std::string &	fname,
		MDFA *	dfa,
		stateidx_t	state
	)

◆ makeLiteralState()

MStatePtr hobbes::makeLiteralState	(	MDFA *	dfa,
		const PatternRows &	ps,
		size_t	c
	)

◆ makeLitSplitRow()

void hobbes::makeLitSplitRow	(	const MatchLiteral &	,
		PatternRows *	out,
		const PatternRow &	r,
		size_t	c
	)

◆ makeLSAnyRow()

void hobbes::makeLSAnyRow	(	PrimitivePtr	,
		PatternRows *	out,
		const PatternRow &	r,
		size_t	c
	)

◆ makeLSCvtSwitch()

MStatePtr hobbes::makeLSCvtSwitch	(	const std::string &	switchVar,
		MDFA *	dfa,
		const SwitchVal::Jumps &	jmps,
		stateidx_t	defState
	)

◆ makeLSSuccState()

stateidx_t hobbes::makeLSSuccState	(	const std::string &	,
		PrimitivePtr	,
		MDFA *	dfa,
		const PatternRows &	nps
	)

◆ makeLSSwitch()

MStatePtr hobbes::makeLSSwitch	(	const std::string &	switchVar,
		MDFA *	dfa,
		const SwitchVal::Jumps &	jmps,
		stateidx_t	defState
	)

◆ makeMemRegion()

size_t hobbes::makeMemRegion ( const array< char > * n )

◆ makeOutputParserState()

ExprPtr hobbes::makeOutputParserState	(	const ParserEvalInfo &	pei,
		size_t	i
	)

◆ makeParser() [1/3]

ExprPtr hobbes::makeParser	(	cc *	c,
		const Parser &	p,
		const precedence &	prec,
		const LexicalAnnotation &	la
	)

◆ makeParser() [2/3]

ExprPtr hobbes::makeParser	(	cc *	c,
		const Parser &	p,
		terminal *	root,
		const precedence &	prec,
		const LexicalAnnotation &	la
	)

◆ makeParser() [3/3]

ExprPtr hobbes::makeParser	(	cc *	c,
		const Grammar &	g,
		const LexicalAnnotation &	la
	)

◆ makeParserStates()

LetRec::Bindings hobbes::makeParserStates ( const ParserEvalInfo & pei )

◆ makePrimFArgs()

PrimFArgs hobbes::makePrimFArgs ( const PatternRows & ps )

◆ makePrimMatchDFAFunc()

llvm::Function* hobbes::makePrimMatchDFAFunc	(	const std::string &	fname,
		MDFA *	dfa,
		stateidx_t	s,
		const PrimFArgs &	args
	)

◆ makeRecord()

ExprPtr hobbes::makeRecord	(	const MkRecord::FieldDefs &	fds,
		const LexicalAnnotation &	la
	)

◆ makeRecordMembers()

Record::Members hobbes::makeRecordMembers	(	const MkRecord::FieldDefs &	fds,
		const MonoTypes &	mts
	)

◆ makeRecordState()

MStatePtr hobbes::makeRecordState	(	MDFA *	dfa,
		const PatternRows &	ps,
		size_t	c
	)

◆ makeRecordType() [1/2]

MonoTypePtr hobbes::makeRecordType ( const Record::Members & ms )

◆ makeRecordType() [2/2]

template<typename ... Xs>

MonoTypePtr hobbes::makeRecordType ( Xs ... xs )

inline

◆ makeReduction()

ExprPtr hobbes::makeReduction	(	const ParserEvalInfo &	pei,
		size_t	i,
		terminal *	sym,
		size_t	rule
	)

◆ makeRegexCaptureBuffer()

ExprPtr hobbes::makeRegexCaptureBuffer	(	const Regexes &	regexes,
		const LexicalAnnotation &	rootLA
	)

◆ makeRegexFn()

CRegexes hobbes::makeRegexFn	(	cc *	c,
		const Regexes &	regexes,
		const LexicalAnnotation &	rootLA
	)

◆ makeRegexState()

MStatePtr hobbes::makeRegexState	(	MDFA *	dfa,
		const PatternRows &	ps,
		size_t	c
	)

◆ makeSplitState()

template<typename MType , typename SValue , SValue(*)(const MType &) svalueF, void(*)(const MType &, PatternRows *, const PatternRow &, size_t) makeMatchRow, void(*)(SValue, PatternRows *, const PatternRow &, size_t) makeMatchAnyRow, stateidx_t(*)(const std::string &, SValue, MDFA *, const PatternRows &) makeNextState, MStatePtr(*)(const std::string &, MDFA *, const std::vector< std::pair< SValue, stateidx_t > > &, stateidx_t) makeSwitchState, typename SVLT = std::less<SValue>>

MStatePtr hobbes::makeSplitState	(	MDFA *	dfa,
		const PatternRows &	ps,
		size_t	c
	)

◆ makeStdString()

std::string hobbes::makeStdString ( const array< char > * x )

◆ makeString() [1/5]

const array< char > * hobbes::makeString ( const std::string & x )

◆ makeString() [2/5]

const array< char > * hobbes::makeString	(	region &	m,
		const char *	s
	)

◆ makeString() [3/5]

const array< char > * hobbes::makeString	(	region &	m,
		const std::string &	s
	)

◆ makeString() [4/5]

const array< char > * hobbes::makeString	(	region &	m,
		const char *	s,
		size_t	len
	)

◆ makeString() [5/5]

const array< char > * hobbes::makeString	(	const char *	s,
		size_t	len
	)

◆ makeSuccState()

MStatePtr hobbes::makeSuccState	(	MDFA *	dfa,
		const PatternRows &	ps,
		size_t	c
	)

◆ makeSwitch()

MStatePtr hobbes::makeSwitch	(	const MDFA *	dfa,
		const std::string &	switchVar,
		const SwitchVal::Jumps &	jmps,
		stateidx_t	defState
	)

◆ makeTuple()

ExprPtr hobbes::makeTuple	(	const Exprs &	exprs,
		const LexicalAnnotation &	la
	)

◆ makeVariantSplitRow()

void hobbes::makeVariantSplitRow	(	const MatchVariant &	mv,
		PatternRows *	out,
		const PatternRow &	r,
		size_t	c
	)

◆ makeVariantState()

MStatePtr hobbes::makeVariantState	(	MDFA *	dfa,
		const PatternRows &	ps,
		size_t	c
	)

◆ makeVSAnyRow()

void hobbes::makeVSAnyRow	(	std::string	,
		PatternRows *	out,
		const PatternRow &	r,
		size_t	c
	)

◆ makeVSSuccState()

stateidx_t hobbes::makeVSSuccState	(	const std::string &	,
		std::string	,
		MDFA *	dfa,
		const PatternRows &	nps
	)

◆ makeVSSwitch()

MStatePtr hobbes::makeVSSwitch	(	const std::string &	switchVar,
		MDFA *	dfa,
		const SwitchVariant::CtorJumps &	jmps,
		stateidx_t	defState
	)

◆ mapFileData()

static char* hobbes::mapFileData	(	imagefile *	f,
		size_t	fpos,
		size_t	sz
	)

static

◆ mapLookup()

template<typename K , typename V >

V hobbes::mapLookup	(	const std::map< K, V > &	m,
		const K &	k
	)

◆ mappedFileRegion()

fregion& hobbes::mappedFileRegion	(	imagefile *	f,
		file_pageindex_t	page,
		size_t	pages
	)

◆ mapStatesFrom()

void hobbes::mapStatesFrom	(	MDFA *	dfa,
		stateidx_t	state,
		GlobalToLocalState *	localstate
	)

◆ markBadFD()

void hobbes::markBadFD ( int fd )

◆ maSize()

size_t hobbes::maSize ( const MatchArray & ma )

◆ matchRowType()

MonoTypes hobbes::matchRowType	(	const TEnvPtr &	tenv,
		const PatternRows &	ps
	)

◆ maxFieldAlignmentF()

unsigned int hobbes::maxFieldAlignmentF ( const Record::Members & ms )

◆ maxStringLen()

size_t hobbes::maxStringLen	(	const PatternRows &	ps,
		size_t	c
	)

◆ maybety()

MonoTypePtr hobbes::maybety ( const MonoTypePtr & t )

inline

◆ memalloc()

char * hobbes::memalloc ( long n )

◆ memallocz()

char* hobbes::memallocz ( long n )

◆ mergeCharRangesAndEqResults()

void hobbes::mergeCharRangesAndEqResults	(	DFA *	dfa,
		const RStates &	fstates,
		RStates *	rstates
	)

◆ mergeConstraints() [1/2]

Constraints hobbes::mergeConstraints	(	const Constraints &	lhs,
		const Constraints &	rhs
	)

◆ mergeConstraints() [2/2]

void hobbes::mergeConstraints	(	const Constraints &	fcs,
		Constraints *	tcs
	)

◆ mergeFundeps()

FunDeps hobbes::mergeFundeps	(	const FunDeps &	lhs,
		const FunDeps &	rhs
	)

◆ mergePadding()

Constants hobbes::mergePadding	(	const Constants &	cs,
		const Record::Members &	ms
	)

inline

◆ mgu() [1/7]

void hobbes::mgu	(	const ExprPtr &	e0,
		const ExprPtr &	e1,
		MonoTypeUnifier *	u
	)

◆ mgu() [2/7]

void hobbes::mgu	(	const ExprPtr &	e,
		const QualTypePtr &	t,
		MonoTypeUnifier *	u
	)

◆ mgu() [3/7]

void hobbes::mgu	(	const ExprPtr &	e,
		const MonoTypePtr &	t,
		MonoTypeUnifier *	u
	)

◆ mgu() [4/7]

void hobbes::mgu	(	const QualTypePtr &	t0,
		const QualTypePtr &	t1,
		MonoTypeUnifier *	u
	)

◆ mgu() [5/7]

void hobbes::mgu	(	const MonoTypePtr &	t0,
		const MonoTypePtr &	t1,
		MonoTypeUnifier *	u
	)

◆ mgu() [6/7]

void hobbes::mgu	(	const MonoTypes &	ts0,
		const MonoTypes &	ts1,
		MonoTypeUnifier *	u
	)

◆ mgu() [7/7]

void hobbes::mgu	(	const ConstraintPtr &	c0,
		const ConstraintPtr &	c1,
		MonoTypeUnifier *	u
	)

◆ mightRewriteToLookup()

static bool hobbes::mightRewriteToLookup	(	const TEnvPtr &	tenv,
		const MonoTypePtr &	rty,
		const std::string &	fieldName,
		const MonoTypePtr &	fty,
		Definitions *	ds
	)

static

◆ mightRewriteToSLookup()

bool hobbes::mightRewriteToSLookup	(	const TEnvPtr &	tenv,
		const MonoTypePtr &	rty,
		const MonoTypePtr &	fieldName,
		const MonoTypePtr &	fty,
		Definitions *	ds
	)

◆ mkarray() [1/2]

Expr* hobbes::mkarray	(	const std::vector< unsigned char > &	v,
		const LexicalAnnotation &	la
	)

inline

◆ mkarray() [2/2]

Expr* hobbes::mkarray	(	const std::string &	v,
		const LexicalAnnotation &	la
	)

inline

◆ mkDateTime()

long hobbes::mkDateTime	(	int	y,
		int	mon,
		int	d,
		int	h,
		int	min,
		int	s,
		int	u
	)

inline

◆ mkDateTimeExpr()

ExprPtr hobbes::mkDateTimeExpr	(	const std::string &	x,
		const LexicalAnnotation &	la
	)

◆ mkDateTimePrim()

PrimitivePtr hobbes::mkDateTimePrim	(	const std::string &	x,
		const LexicalAnnotation &	la
	)

◆ mkFormatExpr()

ExprPtr hobbes::mkFormatExpr	(	const std::string &	fmt,
		const LexicalAnnotation &	la
	)

◆ mkFR()

MonoTypePtr hobbes::mkFR ( const MonoTypePtr & t )

◆ mkpatarray() [1/2]

MatchArray* hobbes::mkpatarray	(	const std::vector< unsigned char > &	bs,
		const LexicalAnnotation &	la
	)

inline

◆ mkpatarray() [2/2]

MatchArray* hobbes::mkpatarray	(	const std::string &	cs,
		const LexicalAnnotation &	la
	)

inline

◆ mkPidTy()

MonoTypePtr hobbes::mkPidTy ( long pid )

◆ mkrecord()

ExprPtr hobbes::mkrecord	(	const MkRecord::FieldDefs &	fds,
		const LexicalAnnotation &	la
	)

inline

◆ mkTime()

long hobbes::mkTime	(	int	h,
		int	m,
		int	s,
		int	u
	)

inline

◆ mkTimeExpr()

ExprPtr hobbes::mkTimeExpr	(	const std::string &	x,
		const LexicalAnnotation &	la
	)

◆ mkTimePrim()

PrimitivePtr hobbes::mkTimePrim	(	const std::string &	x,
		const LexicalAnnotation &	la
	)

◆ mkTimespanExpr()

ExprPtr hobbes::mkTimespanExpr	(	const str::seq &	x,
		const LexicalAnnotation &	la
	)

◆ mkTimespanPrim()

PrimitivePtr hobbes::mkTimespanPrim	(	const str::seq &	x,
		const LexicalAnnotation &	la
	)

◆ mktunit()

ExprPtr hobbes::mktunit ( const LexicalAnnotation & la )

inline

◆ mktuple()

ExprPtr hobbes::mktuple	(	const ExprPtr &	e,
		const LexicalAnnotation &	la
	)

inline

◆ modulePaths()

static ModulePaths& hobbes::modulePaths ( )

static

◆ moveToUniqueFilename()

std::string hobbes::moveToUniqueFilename	(	const std::string &	oldpath,
		const std::string &	fprefix,
		const std::string &	fsuffix
	)

◆ nadd()

nat hobbes::nadd	(	nat	lhs,
		nat	rhs
	)

◆ nameBlanks()

str::seq hobbes::nameBlanks ( const str::seq & xs )

◆ nameIndex() [1/2]

int hobbes::nameIndex	(	const NameIndexing &	ns,
		const std::string &	vn
	)

◆ nameIndex() [2/2]

std::vector<int> hobbes::nameIndex	(	const NameIndexing &	ns,
		const str::seq &	vns
	)

◆ nameIndexing() [1/2]

NameIndexing hobbes::nameIndexing ( const str::seq & ns )

◆ nameIndexing() [2/2]

NameIndexing hobbes::nameIndexing ( const std::set< std::string > & ns )

◆ needsOutputFunction()

bool hobbes::needsOutputFunction	(	const ParserEvalInfo &	pei,
		size_t	i
	)

◆ newThread()

long hobbes::newThread ( char * clos )

◆ next() [1/2]

terminal * hobbes::next	(	const grammar &	g,
		const item &	i
	)

◆ next() [2/2]

terminalset hobbes::next	(	const grammar &	g,
		const itemset &	is
	)

◆ nextPrim()

terminalset hobbes::nextPrim	(	const grammar &	g,
		const itemset &	is
	)

◆ nextVisibleMember() [1/2]

size_t hobbes::nextVisibleMember	(	size_t	i,
		const Variant::Members &	ms
	)

◆ nextVisibleMember() [2/2]

unsigned int hobbes::nextVisibleMember	(	unsigned int	i,
		const Record::Members &	ms
	)

◆ nfaTransition()

stateset hobbes::nfaTransition	(	const NFA &	nfa,
		const EpsClosure &	ec,
		const stateset &	ss,
		const CharRange &	cr
	)

◆ nmax()

nat hobbes::nmax	(	nat	lhs,
		nat	rhs
	)

◆ normalizeCtorIDs() [1/2]

Variant::Members hobbes::normalizeCtorIDs ( const Variant::Members & ms )

◆ normalizeCtorIDs() [2/2]

MonoTypePtr hobbes::normalizeCtorIDs ( const MonoTypePtr & t )

◆ normalizeRecAccess() [1/2]

void hobbes::normalizeRecAccess ( const Patterns & ps )

◆ normalizeRecAccess() [2/2]

void hobbes::normalizeRecAccess ( const PatternRows & prs )

◆ normalizeRecPatterns() [1/2]

void hobbes::normalizeRecPatterns	(	MatchRecord *	r,
		const std::set< std::string > &	fnames
	)

◆ normalizeRecPatterns() [2/2]

void hobbes::normalizeRecPatterns	(	const Patterns &	ps,
		const std::set< std::string > &	fnames
	)

◆ normalizeSumFields()

static void hobbes::normalizeSumFields ( Variant::Members * ms )

static

◆ normalizeTupleFields()

static void hobbes::normalizeTupleFields ( Record::Members * ms )

static

◆ normIfOpaquePtr()

MonoTypePtr hobbes::normIfOpaquePtr ( const MonoTypePtr & ty )

◆ nothingE() [1/2]

ExprPtr hobbes::nothingE ( const LexicalAnnotation & la )

inline

◆ nothingE() [2/2]

ExprPtr hobbes::nothingE	(	const MonoTypePtr &	jt,
		const LexicalAnnotation &	la
	)

inline

◆ now()

datetimeT hobbes::now ( )

◆ nthRule()

const rule& hobbes::nthRule	(	const rules *	rs,
		nat	n
	)

◆ objViewToFlatView()

MonoTypePtr hobbes::objViewToFlatView	(	const MonoTypePtr &	obj,
		const Func *	fty
	)

◆ offset() [1/4]

llvm::Value* hobbes::offset	(	llvm::IRBuilder<> *	b,
		llvm::Value *	p,
		llvm::Value *	o0
	)

inline

◆ offset() [2/4]

llvm::Value* hobbes::offset	(	llvm::IRBuilder<> *	b,
		llvm::Value *	p,
		int	o0
	)

inline

◆ offset() [3/4]

llvm::Value* hobbes::offset	(	llvm::IRBuilder<> *	b,
		llvm::Value *	p,
		int	o0,
		int	o1
	)

inline

◆ offset() [4/4]

llvm::Value* hobbes::offset	(	llvm::IRBuilder<> *	b,
		llvm::Value *	p,
		int	o0,
		llvm::Value *	o1
	)

inline

◆ opaqueptr()

template<typename T >

MonoTypePtr hobbes::opaqueptr ( bool insertcontig )

◆ openArray()

ExprPtr hobbes::openArray	(	MDFA *	dfa,
		const std::string &	vn
	)

◆ openFile()

static imagefile* hobbes::openFile	(	const std::string &	fname,
		bool	readonly
	)

static

◆ operator<<() [1/7]

std::ostream& hobbes::operator<<	(	std::ostream &	out,
		const array< char > *	x
	)

inline

◆ operator<<() [2/7]

std::ostream& hobbes::operator<<	(	std::ostream &	out,
		const MonoTypePtr &	t
	)

inline

◆ operator<<() [3/7]

std::ostream& hobbes::operator<<	(	std::ostream &	out,
		const PolyTypePtr &	t
	)

inline

◆ operator<<() [4/7]

std::ostream& hobbes::operator<<	(	std::ostream &	out,
		const QualTypePtr &	t
	)

inline

◆ operator<<() [5/7]

std::ostream& hobbes::operator<<	(	std::ostream &	out,
		const ConstraintPtr &	t
	)

inline

◆ operator<<() [6/7]

std::ostream & hobbes::operator<<	(	std::ostream &	out,
		const action &	act
	)

◆ operator<<() [7/7]

std::ostream& hobbes::operator<<	(	std::ostream &	out,
		const bit_table &	bt
	)

inline

◆ operator==()

bool hobbes::operator==	(	const PatternRow &	pr0,
		const PatternRow &	pr1
	)

◆ overridePatVarCtor()

void hobbes::overridePatVarCtor ( PatVarCtorFn f )

◆ overrideVarCtor()

void hobbes::overrideVarCtor ( VarCtorFn f )

◆ packedRecordType()

llvm::StructType* hobbes::packedRecordType ( const Types & tys )

inline

◆ packedSValues()

size_t hobbes::packedSValues ( size_t cs )

◆ padding()

llvm::Constant* hobbes::padding ( unsigned int len )

inline

◆ pageCount()

size_t hobbes::pageCount	(	const imagefile *	f,
		size_t	sz
	)

◆ pageEntries()

reader::PageEntries* hobbes::pageEntries ( reader * r )

◆ pageIndex()

file_pageindex_t hobbes::pageIndex	(	const imagefile *	f,
		uint64_t	fpos
	)

inline

◆ pageOffset()

size_t hobbes::pageOffset	(	const imagefile *	f,
		file_pageindex_t	page
	)

inline

◆ pageTOCPosition()

static size_t hobbes::pageTOCPosition	(	const imagefile *	f,
		file_pageindex_t	page
	)

static

◆ parseDepth()

size_t hobbes::parseDepth	(	const ParserEvalInfo &	pei,
		size_t	i
	)

◆ parseFailure()

ExprPtr hobbes::parseFailure	(	const ParserEvalInfo &	pei,
		size_t	i
	)

◆ parseRegex()

RegexPtr hobbes::parseRegex ( const std::string & x )

◆ parseResultType()

MonoTypePtr hobbes::parseResultType ( const ParserEvalInfo & pei )

◆ parserState()

nat hobbes::parserState	(	const itemset &	s,
		parserdef *	p
	)

◆ parserStateDef()

const itemset& hobbes::parserStateDef	(	const parserdef &	p,
		nat	n
	)

◆ parseVariant()

MonoTypePtr hobbes::parseVariant ( const ParserEvalInfo & pei )

◆ pidTy()

const TLong * hobbes::pidTy ( const MonoTypePtr & mty )

◆ polytype() [1/5]

PolyTypePtr hobbes::polytype	(	int	tvs,
		const QualTypePtr &	qt
	)

inline

◆ polytype() [2/5]

PolyTypePtr hobbes::polytype ( const QualTypePtr & qt )

inline

◆ polytype() [3/5]

PolyTypePtr hobbes::polytype ( const MonoTypePtr & p )

inline

◆ polytype() [4/5]

PolyTypePtr hobbes::polytype ( MonoType * mt )

inline

◆ polytype() [5/5]

PolyTypePtr hobbes::polytype ( const char * x )

inline

◆ popModuleDir()

void hobbes::popModuleDir ( )

◆ position()

static size_t hobbes::position	(	const imagefile *	f,
		file_pageindex_t	page,
		uint16_t	offset
	)

static

◆ prepareEvalInfo()

void hobbes::prepareEvalInfo	(	cc *	c,
		const Parser &	p,
		terminal *	root,
		const precedence &	prec,
		ParserEvalInfo *	pei,
		const LexicalAnnotation &	la
	)

◆ prepareStrExpr()

void hobbes::prepareStrExpr	(	Server *	s,
		int	c,
		exprid	eid,
		const std::string &	expr,
		const MonoTypes &	intys,
		const MonoTypePtr &	outty
	)

◆ prependPatterns()

void hobbes::prependPatterns	(	PatternRow *	row,
		const Patterns &	ps
	)

◆ prepgv()

llvm::GlobalVariable* hobbes::prepgv	(	llvm::GlobalVariable *	gv,
		unsigned int	align = `sizeof(void*)`
	)

inline

◆ prim()

template<typename T >

MonoTypePtr hobbes::prim ( )

inline

◆ PRIM_CODEC() [1/9]

hobbes::PRIM_CODEC ( bool )

◆ PRIM_CODEC() [2/9]

hobbes::PRIM_CODEC ( unsigned char )

◆ PRIM_CODEC() [3/9]

hobbes::PRIM_CODEC ( char )

◆ PRIM_CODEC() [4/9]

hobbes::PRIM_CODEC ( short )

◆ PRIM_CODEC() [5/9]

hobbes::PRIM_CODEC ( int )

◆ PRIM_CODEC() [6/9]

hobbes::PRIM_CODEC ( long )

◆ PRIM_CODEC() [7/9]

hobbes::PRIM_CODEC ( size_t )

◆ PRIM_CODEC() [8/9]

hobbes::PRIM_CODEC ( float )

◆ PRIM_CODEC() [9/9]

hobbes::PRIM_CODEC ( double )

◆ primty() [1/2]

MonoTypePtr hobbes::primty ( const char * x )

inline

◆ primty() [2/2]

MonoTypePtr hobbes::primty	(	const char *	x,
		const MonoTypePtr &	aty
	)

inline

◆ print() [1/3]

void hobbes::print	(	std::ostream &	out,
		const NFA &	nfa
	)

◆ print() [2/3]

void hobbes::print	(	std::ostream &	out,
		const EpsClosure &	ec
	)

◆ print() [3/3]

void hobbes::print	(	std::ostream &	out,
		const DFA &	dfa
	)

◆ printConnectionUF()

void hobbes::printConnectionUF ( long x )

◆ printFileUF()

void hobbes::printFileUF ( long x )

◆ printMatchExp()

void hobbes::printMatchExp	(	std::ostream &	out,
		const ExprPtr &	e
	)

◆ printMatchResult() [1/2]

void hobbes::printMatchResult	(	std::ostream &	out,
		const ExprPtr &	e
	)

◆ printMatchResult() [2/2]

void hobbes::printMatchResult	(	const std::string &	indent,
		std::ostream &	out,
		const ExprPtr &	e
	)

◆ printMatchTable()

void hobbes::printMatchTable	(	std::ostream &	out,
		const PatternRows &	prs
	)

◆ printMemoryPool()

void hobbes::printMemoryPool ( )

◆ procDefine()

void hobbes::procDefine	(	proc *	p,
		const std::string &	vname,
		const std::string &	x
	)

◆ procEval()

void hobbes::procEval	(	proc *	p,
		const std::string &	x
	)

◆ procPrepareExpr()

PrepProcExpr hobbes::procPrepareExpr	(	const proc &	p,
		const ExprPtr &	e
	)

◆ procRead()

void hobbes::procRead	(	proc *	p,
		std::ostream *	o,
		uint64_t	waitUS = `0`
	)

◆ procTypeEnv()

void hobbes::procTypeEnv ( proc * p )

◆ procTypeof()

void hobbes::procTypeof	(	proc *	p,
		const std::string &	x
	)

◆ proj() [1/3]

ExprPtr hobbes::proj	(	const ExprPtr &	rec,
		const Record *	rty,
		const std::string &	field,
		const LexicalAnnotation &	la
	)

inline

◆ proj() [2/3]

ExprPtr hobbes::proj	(	const ExprPtr &	rec,
		const std::string &	field,
		const LexicalAnnotation &	la
	)

inline

◆ proj() [3/3]

ExprPtr hobbes::proj	(	const ExprPtr &	rec,
		const str::seq &	fields,
		const LexicalAnnotation &	la
	)

inline

◆ ptrType()

llvm::PointerType* hobbes::ptrType ( llvm::Type * ty )

inline

◆ pullTypeArg()

bool hobbes::pullTypeArg	(	const std::string &	fname,
		size_t	idx,
		MonoTypePtr *	p,
		const MonoTypePtr &	ty
	)

◆ pushModuleDir()

void hobbes::pushModuleDir ( const std::string & d )

◆ putStr()

void hobbes::putStr ( array< char > * x )

◆ qualtype() [1/5]

QualTypePtr hobbes::qualtype	(	const Constraints &	cs,
		const MonoTypePtr &	p
	)

inline

◆ qualtype() [2/5]

QualTypePtr hobbes::qualtype	(	const Constraints &	cs,
		MonoType *	mt
	)

inline

◆ qualtype() [3/5]

QualTypePtr hobbes::qualtype ( const MonoTypePtr & p )

inline

◆ qualtype() [4/5]

QualTypePtr hobbes::qualtype ( MonoType * mt )

inline

◆ qualtype() [5/5]

QualTypePtr hobbes::qualtype ( const char * x )

inline

◆ raiseSysError()

static void hobbes::raiseSysError	(	const std::string &	msg,
		const std::string &	fname
	)

static

◆ random()

double hobbes::random	(	double	low,
		double	high
	)

◆ range()

template<typename T >

std::vector<T> hobbes::range	(	const T &	i,
		const T &	e
	)

◆ read() [1/4]

template<typename T >

void hobbes::read	(	const imagefile *	f,
		T *	x
	)

◆ read() [2/4]

void hobbes::read	(	imagefile *	f,
		std::string *	x
	)

◆ read() [3/4]

void hobbes::read	(	imagefile *	f,
		std::vector< unsigned char > *	xs
	)

◆ read() [4/4]

template<typename T >

T hobbes::read	(	const bytes &	in,
		unsigned int *	n
	)

◆ readByte()

const maybe<unsigned char>::ty* hobbes::readByte ( const array< char > * x )

◆ readChar()

const maybe<char>::ty* hobbes::readChar ( const array< char > * x )

◆ readCharset()

DCharset hobbes::readCharset	(	const std::string &	x,
		size_t	i
	)

◆ readDateTime()

long hobbes::readDateTime ( const std::string & x )

inline

◆ readDouble()

const maybe<double>::ty* hobbes::readDouble ( const array< char > * x )

◆ readEnvironmentPage()

static size_t hobbes::readEnvironmentPage	(	imagefile *	f,
		file_pageindex_t	p
	)

static

◆ readEnvironmentRecord()

static void hobbes::readEnvironmentRecord ( imagefile * f )

static

◆ readFile()

static void hobbes::readFile ( imagefile * f )

static

◆ readFileRT()

long hobbes::readFileRT	(	const array< char > *	fname,
		long	tydef
	)

◆ readFloat()

const maybe<float>::ty* hobbes::readFloat ( const array< char > * x )

◆ readInt()

const maybe<int>::ty* hobbes::readInt ( const array< char > * x )

◆ readISV()

template<typename T >

const maybe<T>::ty* hobbes::readISV ( const array< char > * x )

◆ readLong()

const maybe<long>::ty* hobbes::readLong ( const array< char > * x )

◆ readOrMark()

void hobbes::readOrMark	(	int	fd,
		char *	b,
		size_t	sz
	)

◆ readPageData()

void hobbes::readPageData ( imagefile * f )

◆ reads() [1/3]

bool hobbes::reads	(	const parserdef &	p,
		const transition &	x,
		const transition &	y
	)

◆ reads() [2/3]

template<typename T >

void hobbes::reads	(	const imagefile *	f,
		size_t	sz,
		T *	x
	)

◆ Reads()

transition_lookahead hobbes::Reads	(	const parserdef &	p,
		const transitionset &	ts
	)

◆ reads() [3/3]

size_t hobbes::reads	(	const ArgPos &	argpos,
		const std::string &	a
	)

◆ readShort()

const maybe<short>::ty* hobbes::readShort ( const array< char > * x )

◆ readTime()

long hobbes::readTime ( const std::string & x )

inline

◆ readTimespan() [1/2]

long hobbes::readTimespan ( std::string s )

inline

◆ readTimespan() [2/2]

long hobbes::readTimespan ( const str::seq & ss )

inline

◆ recordAppendExpr() [1/4]

ExprPtr hobbes::recordAppendExpr	(	const MkRecord *	lhs,
		const MkRecord *	rhs
	)

◆ recordAppendExpr() [2/4]

ExprPtr hobbes::recordAppendExpr	(	const MkRecord *	lhs,
		const ExprPtr &	rhs
	)

◆ recordAppendExpr() [3/4]

ExprPtr hobbes::recordAppendExpr	(	const ExprPtr &	lhs,
		const MkRecord *	rhs
	)

◆ recordAppendExpr() [4/4]

ExprPtr hobbes::recordAppendExpr	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs
	)

◆ recordAppendFunction()

ExprPtr hobbes::recordAppendFunction	(	const MonoTypePtr &	lty,
		const MonoTypePtr &	rty,
		const MonoTypePtr &	resty,
		const LexicalAnnotation &	la
	)

◆ recordFieldPatterns()

Patterns hobbes::recordFieldPatterns ( const MatchRecord & mr )

◆ recordMembers()

const Record::Members& hobbes::recordMembers ( const MonoTypePtr & mt )

◆ recordPrefix() [1/2]

MonoTypePtr hobbes::recordPrefix	(	const TEnvPtr &	tenv,
		const MonoTypePtr &	rhs,
		const MonoTypePtr &	result
	)

◆ recordPrefix() [2/2]

ExprPtr hobbes::recordPrefix	(	const ExprPtr &	rec,
		const MonoTypePtr &	resty
	)

◆ recordPrefixFunction()

ExprPtr hobbes::recordPrefixFunction	(	const MonoTypePtr &	recty,
		const MonoTypePtr &	resty,
		const LexicalAnnotation &	la
	)

◆ recordSuffix() [1/2]

MonoTypePtr hobbes::recordSuffix	(	const TEnvPtr &	tenv,
		const MonoTypePtr &	lhs,
		const MonoTypePtr &	result
	)

◆ recordSuffix() [2/2]

ExprPtr hobbes::recordSuffix	(	const ExprPtr &	rec,
		const MonoTypePtr &	resty
	)

◆ recordSuffixFunction()

ExprPtr hobbes::recordSuffixFunction	(	const MonoTypePtr &	recty,
		const MonoTypePtr &	resty,
		const LexicalAnnotation &	la
	)

◆ recordType() [1/8]

llvm::StructType* hobbes::recordType ( const Types & tys )

inline

◆ recordType() [2/8]

llvm::StructType* hobbes::recordType ( llvm::Type * t0 )

inline

◆ recordType() [3/8]

llvm::StructType* hobbes::recordType	(	llvm::Type *	t0,
		llvm::Type *	t1
	)

inline

◆ recordType() [4/8]

llvm::StructType* hobbes::recordType	(	llvm::Type *	t0,
		llvm::Type *	t1,
		llvm::Type *	t2
	)

inline

◆ recordType() [5/8]

llvm::StructType* hobbes::recordType	(	llvm::Type *	t0,
		llvm::Type *	t1,
		llvm::Type *	t2,
		llvm::Type *	t3
	)

inline

◆ recordType() [6/8]

llvm::StructType* hobbes::recordType	(	llvm::Type *	t0,
		llvm::Type *	t1,
		llvm::Type *	t2,
		llvm::Type *	t3,
		llvm::Type *	t4
	)

inline

◆ recordType() [7/8]

llvm::StructType* hobbes::recordType	(	llvm::Type *	t0,
		llvm::Type *	t1,
		llvm::Type *	t2,
		llvm::Type *	t3,
		llvm::Type *	t4,
		llvm::Type *	t5
	)

inline

◆ recordType() [8/8]

llvm::StructType* hobbes::recordType	(	llvm::Type *	t0,
		llvm::Type *	t1,
		llvm::Type *	t2,
		llvm::Type *	t3,
		llvm::Type *	t4,
		llvm::Type *	t5,
		llvm::Type *	t6
	)

inline

◆ recordUZConstants()

Constants hobbes::recordUZConstants	(	const UnzRecValues &	rps,
		const Record *	rty
	)

inline

◆ reduceOpTerminal()

terminal* hobbes::reduceOpTerminal	(	const parserdef &	pd,
		const action &	a
	)

◆ referencesSym()

bool hobbes::referencesSym	(	const grammar &	g,
		const item &	i,
		terminal *	t
	)

inline

◆ refine() [1/4]

bool hobbes::refine	(	const TEnvPtr &	tenv,
		const ConstraintPtr &	c,
		MonoTypeUnifier *	s,
		Definitions *	ds
	)

◆ refine() [2/4]

bool hobbes::refine	(	const TEnvPtr &	tenv,
		const Constraints &	cs,
		MonoTypeUnifier *	s,
		Definitions *	ds
	)

◆ refine() [3/4]

bool hobbes::refine	(	const TEnvPtr &	tenv,
		const QualTypePtr &	qty,
		MonoTypeUnifier *	s,
		Definitions *	ds
	)

◆ refine() [4/4]

bool hobbes::refine	(	const TEnvPtr &	tenv,
		const ExprPtr &	e,
		MonoTypeUnifier *	s,
		Definitions *	ds
	)

◆ refinedType()

MonoTypePtr hobbes::refinedType	(	const proc &	p,
		const std::string &	fname,
		const MonoTypePtr &	hasty
	)

◆ refutable()

bool hobbes::refutable ( const PatternPtr & p )

◆ regexBefore()

state hobbes::regexBefore	(	const RegexPtr &	p,
		state	cont,
		result	x,
		NFA *	nfa
	)

◆ regexCaptureBufferType()

MonoTypePtr hobbes::regexCaptureBufferType ( const Regexes & regexes )

◆ registerEventHandler() [1/2]

void hobbes::registerEventHandler	(	int	fd,
		const std::function< void(int)> &	fn,
		bool	vn = `false`
	)

◆ registerEventHandler() [2/2]

void hobbes::registerEventHandler	(	int	fd,
		eventhandler	f,
		void *	ud,
		bool	vn = `false`
	)

◆ registerNetREPL()

void hobbes::registerNetREPL	(	int	s,
		Server *	svr
	)

◆ releaseFileRegionMap()

void hobbes::releaseFileRegionMap	(	imagefile *	f,
		const fregion &	fr
	)

◆ releaseStdout()

const array<char>* hobbes::releaseStdout ( )

◆ remoteHostname()

std::string hobbes::remoteHostname ( int socket )

◆ removeConstraint() [1/2]

Constraints hobbes::removeConstraint	(	const ConstraintPtr &	c,
		const Constraints &	cs
	)

◆ removeConstraint() [2/2]

QualTypePtr hobbes::removeConstraint	(	const ConstraintPtr &	c,
		const QualTypePtr &	qt
	)

◆ removeEquivStates()

DFA hobbes::removeEquivStates	(	const DFA &	dfa,
		const EqStates &	eqs
	)

◆ removeRuleDefs() [1/2]

void hobbes::removeRuleDefs	(	terminal *	s,
		grammar *	g
	)

◆ removeRuleDefs() [2/2]

grammar hobbes::removeRuleDefs	(	terminal *	s,
		const grammar &	g
	)

◆ removeRuleRefs() [1/2]

void hobbes::removeRuleRefs	(	terminal *	s,
		grammar *	g
	)

◆ removeRuleRefs() [2/2]

grammar hobbes::removeRuleRefs	(	terminal *	s,
		const grammar &	g
	)

◆ removeThreadRegion()

void hobbes::removeThreadRegion ( size_t n )

◆ removeUnit() [1/3]

Values hobbes::removeUnit	(	const Values &	vs,
		const MonoTypes &	mts
	)

◆ removeUnit() [2/3]

MonoTypes hobbes::removeUnit ( const MonoTypes & mts )

◆ removeUnit() [3/3]

Record::Members hobbes::removeUnit ( const Record::Members & ms )

◆ requireMonotype() [1/5]

MonoTypePtr hobbes::requireMonotype ( const QualTypePtr & qt )

◆ requireMonotype() [2/5]

MonoTypePtr hobbes::requireMonotype ( const PolyTypePtr & pt )

◆ requireMonotype() [3/5]

MonoTypes hobbes::requireMonotype ( const PolyTypes & pts )

◆ requireMonotype() [4/5]

const MonoTypePtr & hobbes::requireMonotype ( const ExprPtr & e )

◆ requireMonotype() [5/5]

MonoTypes hobbes::requireMonotype ( const Exprs & es )

◆ resetCtorIDs()

static void hobbes::resetCtorIDs ( Variant::Members * ms )

static

◆ resetFieldOffsets()

static void hobbes::resetFieldOffsets ( Record::Members * ms )

static

◆ resetMemoryPool()

void hobbes::resetMemoryPool ( )

◆ resolveMembers()

TClass::Members hobbes::resolveMembers	(	const MonoTypeSubst &	s,
		const MVarTypeDefs &	mvtds
	)

◆ resolveNames() [1/2]

void hobbes::resolveNames	(	const NameIndexing &	ns,
		const CFunDepDef &	nfdep,
		FunDeps *	out
	)

◆ resolveNames() [2/2]

FunDeps hobbes::resolveNames	(	const NameIndexing &	ns,
		const CFunDepDefs &	nfdeps
	)

◆ restInPage()

uint16_t hobbes::restInPage	(	const imagefile *	f,
		size_t	idx
	)

◆ resultType()

static MonoTypePtr hobbes::resultType ( const MonoTypePtr & ftype )

static

◆ returnR()

DRegex hobbes::returnR	(	const std::string &	x,
		size_t	k,
		const RegexPtr &	r
	)

◆ rewriteLookup()

static ExprPtr hobbes::rewriteLookup	(	const TEnvPtr &	tenv,
		const ExprPtr &	r,
		const std::string &	fieldName,
		const MonoTypePtr &	rty,
		const MonoTypePtr &	fty,
		Definitions *	ds,
		const LexicalAnnotation &	la
	)

static

◆ rewriteSLookup()

ExprPtr hobbes::rewriteSLookup	(	const TEnvPtr &	tenv,
		const ExprPtr &	r,
		const std::string &	fieldName,
		const MonoTypePtr &	rty,
		const MonoTypePtr &	fty,
		Definitions *	ds,
		const LexicalAnnotation &	la
	)

◆ rewritesToLookup()

static MonoTypePtr hobbes::rewritesToLookup	(	const TEnvPtr &	tenv,
		const MonoTypePtr &	rty,
		const std::string &	fieldName,
		const MonoTypePtr &	fty,
		Definitions *	ds
	)

static

◆ rewritesToSLookup()

MonoTypePtr hobbes::rewritesToSLookup	(	const TEnvPtr &	tenv,
		const MonoTypePtr &	rty,
		const MonoTypePtr &	fieldName,
		const MonoTypePtr &	fty,
		Definitions *	ds
	)

◆ ruleElement()

terminal* hobbes::ruleElement	(	const rule &	r,
		nat	i
	)

◆ ruleItems() [1/2]

bool hobbes::ruleItems	(	const grammar &	g,
		terminal *	t,
		itemset *	is
	)

◆ ruleItems() [2/2]

itemset hobbes::ruleItems	(	const grammar &	g,
		terminal *	t
	)

◆ runClosThread()

void* hobbes::runClosThread ( void * clos )

◆ runEventLoop() [1/2]

void hobbes::runEventLoop ( )

◆ runEventLoop() [2/2]

void hobbes::runEventLoop ( int microsecondDuration )

◆ runEvery()

void hobbes::runEvery	(	timespanT	dt,
		bool(*)()	pf
	)

◆ runMachineREPL()

void hobbes::runMachineREPL ( cc * c )

◆ runMachineREPLStep()

void hobbes::runMachineREPLStep ( cc * c )

◆ runParserOnBuffer()

void hobbes::runParserOnBuffer	(	cc *	c,
		int	initTok,
		YY_BUFFER_STATE	bs
	)

◆ runParserOnFile()

void hobbes::runParserOnFile	(	cc *	c,
		int	initTok,
		const std::string &	fname
	)

◆ runParserOnString()

void hobbes::runParserOnString	(	cc *	c,
		int	initTok,
		const char *	s
	)

◆ sarrayPatterns()

Patterns hobbes::sarrayPatterns	(	const std::string &	svarName,
		size_t	cs,
		const MatchArray &	ma
	)

◆ satisfiable() [1/6]

bool hobbes::satisfiable	(	const UnqualifierPtr &	,
		const TEnvPtr &	,
		const ConstraintPtr &	,
		std::vector< std::pair< std::string, std::shared_ptr< Expr > > > *
	)

◆ satisfiable() [2/6]

bool hobbes::satisfiable	(	const TEnvPtr &	tenv,
		const ConstraintPtr &	c,
		std::vector< std::pair< std::string, std::shared_ptr< Expr > > > *
	)

◆ satisfiable() [3/6]

bool hobbes::satisfiable	(	const TEnvPtr &	tenv,
		const Constraints &	cs,
		std::vector< std::pair< std::string, std::shared_ptr< Expr > > > *
	)

◆ satisfiable() [4/6]

bool hobbes::satisfiable	(	const UnqualifierPtr &	uq,
		const TEnvPtr &	tenv,
		const ConstraintPtr &	c,
		Definitions *	ds
	)

◆ satisfiable() [5/6]

bool hobbes::satisfiable	(	const TEnvPtr &	tenv,
		const ConstraintPtr &	c,
		Definitions *	ds
	)

◆ satisfiable() [6/6]

bool hobbes::satisfiable	(	const TEnvPtr &	tenv,
		const Constraints &	cs,
		Definitions *	ds
	)

◆ satisfied() [1/6]

bool hobbes::satisfied	(	const UnqualifierPtr &	,
		const TEnvPtr &	,
		const ConstraintPtr &	,
		std::vector< std::pair< std::string, std::shared_ptr< Expr > > > *
	)

◆ satisfied() [2/6]

bool hobbes::satisfied	(	const TEnvPtr &	tenv,
		const ConstraintPtr &	c,
		std::vector< std::pair< std::string, std::shared_ptr< Expr > > > *
	)

◆ satisfied() [3/6]

bool hobbes::satisfied	(	const TEnvPtr &	tenv,
		const Constraints &	cs,
		std::vector< std::pair< std::string, std::shared_ptr< Expr > > > *
	)

◆ satisfied() [4/6]

bool hobbes::satisfied	(	const UnqualifierPtr &	uq,
		const TEnvPtr &	tenv,
		const ConstraintPtr &	c,
		Definitions *	ds
	)

◆ satisfied() [5/6]

bool hobbes::satisfied	(	const TEnvPtr &	tenv,
		const ConstraintPtr &	c,
		Definitions *	ds
	)

◆ satisfied() [6/6]

bool hobbes::satisfied	(	const TEnvPtr &	tenv,
		const Constraints &	cs,
		Definitions *	ds
	)

◆ second()

template<typename L , typename R >

std::vector<R> hobbes::second ( const std::vector< std::pair< L, R > > & xs )

◆ seekAbs()

static void hobbes::seekAbs	(	const imagefile *	f,
		size_t	pos
	)

static

◆ select() [1/5]

template<typename T , typename I >

T hobbes::select	(	const std::vector< T > &	xs,
		I	i
	)

◆ select() [2/5]

template<typename T , typename I >

std::vector<T> hobbes::select	(	const std::vector< T > &	xs,
		I	b,
		I	e
	)

◆ select() [3/5]

template<typename T , typename I >

std::vector<T> hobbes::select	(	const std::vector< T > &	xs,
		const std::vector< I > &	is
	)

◆ select() [4/5]

template<typename K , typename V >

std::pair<K, V> hobbes::select	(	const std::map< K, V > &	m,
		K	k
	)

◆ select() [5/5]

template<typename K , typename V >

std::vector< std::pair<K, V> > hobbes::select	(	const std::map< K, V > &	m,
		const std::vector< K > &	ks
	)

◆ selectNames()

str::seq hobbes::selectNames ( const Variant::Members & ms )

inline

◆ selectTypes()

MonoTypes hobbes::selectTypes ( const Variant::Members & ms )

inline

◆ seqR()

DRegex hobbes::seqR	(	const RegexPtr &	lhs,
		const RegexPtr &	c,
		const std::string &	x,
		size_t	k
	)

◆ sequence()

RegexPtr hobbes::sequence	(	const RegexPtr &	p0,
		const RegexPtr &	p1
	)

◆ serializeGroundClasses() [1/2]

void hobbes::serializeGroundClasses	(	const TEnvPtr &	tenv,
		std::ostream &	out
	)

◆ serializeGroundClasses() [2/2]

void hobbes::serializeGroundClasses	(	const TEnvPtr &	tenv,
		const Classes &	cs,
		std::ostream &	out
	)

◆ serializeGroundInstance()

void hobbes::serializeGroundInstance	(	const TEnvPtr &	tenv,
		const TClass *	c,
		const TCInstancePtr &	inst,
		std::ostream &	out
	)

◆ serializeGroundInstances()

void hobbes::serializeGroundInstances	(	const TEnvPtr &	tenv,
		const TClass *	c,
		const TCInstances &	insts,
		std::ostream &	out
	)

◆ set() [1/2]

template<typename T >

std::set<T> hobbes::set ( )

◆ set() [2/2]

template<typename T , typename ... Ts>

std::set<T> hobbes::set	(	const T &	x,
		const Ts &...	xs
	)

◆ setDifference() [1/2]

template<typename T >

std::set<T> hobbes::setDifference	(	const std::set< T > &	lhs,
		const std::set< T > &	rhs
	)

◆ setDifference() [2/2]

template<typename T >

std::set<T> hobbes::setDifference	(	const std::set< T > &	lhs,
		const T &	x
	)

◆ setThreadRegion()

size_t hobbes::setThreadRegion ( size_t n )

◆ setUnion() [1/2]

template<typename T >

std::set<T> hobbes::setUnion	(	const std::set< T > &	lhs,
		const std::set< T > &	rhs
	)

◆ setUnion() [2/2]

template<typename T >

std::set<T> hobbes::setUnion ( const std::vector< std::set< T > > & ss )

◆ shiftInstead()

bool hobbes::shiftInstead	(	const parserdef &	pd,
		const precedence &	px,
		nat	shs,
		terminal *	t,
		const action &	a
	)

◆ shiftVarNames()

str::seq hobbes::shiftVarNames	(	const ParserEvalInfo &	pei,
		size_t	fromS,
		size_t	toS
	)

◆ shortType()

llvm::Type* hobbes::shortType ( )

inline

◆ shouldInlineState()

bool hobbes::shouldInlineState	(	const MDFA *	dfa,
		stateidx_t	state
	)

◆ show() [1/44]

template<typename T >

std::string hobbes::show ( const T * t )

◆ show() [2/44]

template<typename T >

std::string hobbes::show ( const std::vector< T *> & ts )

◆ show() [3/44]

template<typename T >

std::string hobbes::show ( const std::set< T > & ts )

◆ show() [4/44]

std::string hobbes::show ( const PtrAdjustmentPath & p )

◆ show() [5/44]

void hobbes::show	(	std::ostream &	out,
		const Parser &	p
	)

◆ show() [6/44]

std::string hobbes::show ( const Expr & e )

◆ show() [7/44]

std::string hobbes::show ( const Expr * e )

◆ show() [8/44]

std::string hobbes::show ( const ExprPtr & e )

◆ show() [9/44]

std::string hobbes::show ( const Definition & d )

◆ show() [10/44]

std::string hobbes::show ( const PatternPtr & p )

◆ show() [11/44]

std::string hobbes::show ( const Patterns & ps )

◆ show() [12/44]

std::string hobbes::show ( const PatternRow & pr )

◆ show() [13/44]

std::string hobbes::show ( const Module & m )

◆ show() [14/44]

std::string hobbes::show ( const Module * m )

◆ show() [15/44]

std::string hobbes::show ( const ModulePtr & m )

◆ show() [16/44]

std::string hobbes::show ( const MTypeDef * td )

◆ show() [17/44]

std::string hobbes::show ( const ClassDef & cd )

◆ show() [18/44]

std::string hobbes::show ( const ClassDef * cd )

◆ show() [19/44]

std::string hobbes::show ( const InstanceDef & id )

◆ show() [20/44]

std::string hobbes::show ( const InstanceDef * id )

◆ show() [21/44]

std::string hobbes::show ( const ModuleDefPtr & md )

◆ show() [22/44]

std::string hobbes::show ( const CFunDepDef & fundep )

◆ show() [23/44]

std::string hobbes::show ( const CFunDepDefs & fundeps )

◆ show() [24/44]

std::string hobbes::show ( const TClassPtr & x )

◆ show() [25/44]

std::string hobbes::show ( const TCInstancePtr & x )

◆ show() [26/44]

std::string hobbes::show ( const TCInstanceFnPtr & x )

◆ show() [27/44]

void hobbes::show	(	std::ostream &	out,
		const grammar &	g,
		const item &	i
	)

◆ show() [28/44]

void hobbes::show	(	std::ostream &	out,
		const grammar &	g,
		const itemset &	is
	)

◆ show() [29/44]

template<typename T >

std::vector<std::string> hobbes::show ( const std::vector< T > & xs )

◆ show() [30/44]

void hobbes::show	(	std::ostream &	out,
		const lrtable &	tbl
	)

◆ show() [31/44]

std::string hobbes::show ( const PolyType & e )

◆ show() [32/44]

std::string hobbes::show ( const PolyType * e )

◆ show() [33/44]

std::string hobbes::show ( const PolyTypePtr & e )

◆ show() [34/44]

std::string hobbes::show ( const QualType & e )

◆ show() [35/44]

std::string hobbes::show ( const QualType * e )

◆ show() [36/44]

std::string hobbes::show ( const QualTypePtr & e )

◆ show() [37/44]

std::string hobbes::show ( const Constraint & e )

◆ show() [38/44]

std::string hobbes::show ( const Constraint * e )

◆ show() [39/44]

std::string hobbes::show ( const ConstraintPtr & e )

◆ show() [40/44]

std::string hobbes::show ( const MonoType & e )

◆ show() [41/44]

std::string hobbes::show ( const MonoType * e )

◆ show() [42/44]

std::string hobbes::show ( const MonoTypePtr & e )

◆ show() [43/44]

void hobbes::show	(	const MonoTypeSubst &	s,
		std::ostream &	out
	)

◆ show() [44/44]

std::string hobbes::show ( const MonoTypeSubst & s )

◆ showAnnotated() [1/4]

std::string hobbes::showAnnotated ( const Expr & e )

◆ showAnnotated() [2/4]

std::string hobbes::showAnnotated ( const Expr * e )

◆ showAnnotated() [3/4]

std::string hobbes::showAnnotated ( const ExprPtr & e )

◆ showAnnotated() [4/4]

std::string hobbes::showAnnotated ( const Definition & d )

◆ showAsRecord()

void hobbes::showAsRecord	(	std::ostream &	out,
		const Record::Members &	ms
	)

◆ showAsTuple()

void hobbes::showAsTuple	(	std::ostream &	out,
		const Record::Members &	ms
	)

◆ showByte()

const array<char>* hobbes::showByte ( unsigned char b )

◆ showByteV()

const array<char>* hobbes::showByteV ( unsigned char b )

◆ showChar()

const array<char>* hobbes::showChar ( char c )

◆ showDateTime()

std::string hobbes::showDateTime ( long x )

inline

◆ showDateTimeV()

const array<char>* hobbes::showDateTimeV ( datetimeT x )

◆ showDouble()

const array<char>* hobbes::showDouble	(	double	x,
		int	p
	)

◆ showFileRef()

bool hobbes::showFileRef	(	const MonoTypePtr &	f,
		const MonoTypes &	targs,
		std::ostream &	out
	)

◆ showFloat()

const array<char>* hobbes::showFloat	(	float	x,
		int	p
	)

◆ showFull()

void hobbes::showFull	(	const Variant::Members &	ms,
		std::ostream &	out
	)

◆ showFullVarPayloadSuffix()

void hobbes::showFullVarPayloadSuffix	(	const MonoTypePtr &	t,
		std::ostream &	out
	)

◆ showFundep()

void hobbes::showFundep	(	const FunDep &	fd,
		std::ostream &	out
	)

◆ showHLTerm()

void hobbes::showHLTerm	(	std::ostream &	out,
		terminal *	x,
		terminal *	hx
	)

inline

◆ showInt()

const array<char>* hobbes::showInt ( int x )

◆ showLong()

const array<char>* hobbes::showLong ( long x )

◆ showMemoryPool()

std::string hobbes::showMemoryPool ( )

◆ showNoSimpl() [1/14]

str::seq hobbes::showNoSimpl ( const MonoTypes & ts )

◆ showNoSimpl() [2/14]

str::seq hobbes::showNoSimpl ( const Constraints & cs )

◆ showNoSimpl() [3/14]

std::string hobbes::showNoSimpl ( const PolyType & e )

◆ showNoSimpl() [4/14]

std::string hobbes::showNoSimpl ( const PolyType * e )

◆ showNoSimpl() [5/14]

std::string hobbes::showNoSimpl ( const PolyTypePtr & e )

◆ showNoSimpl() [6/14]

std::string hobbes::showNoSimpl ( const QualType & e )

◆ showNoSimpl() [7/14]

std::string hobbes::showNoSimpl ( const QualType * e )

◆ showNoSimpl() [8/14]

std::string hobbes::showNoSimpl ( const QualTypePtr & e )

◆ showNoSimpl() [9/14]

std::string hobbes::showNoSimpl ( const Constraint & e )

◆ showNoSimpl() [10/14]

std::string hobbes::showNoSimpl ( const Constraint * e )

◆ showNoSimpl() [11/14]

std::string hobbes::showNoSimpl ( const ConstraintPtr & e )

◆ showNoSimpl() [12/14]

std::string hobbes::showNoSimpl ( const MonoType & e )

◆ showNoSimpl() [13/14]

std::string hobbes::showNoSimpl ( const MonoType * e )

◆ showNoSimpl() [14/14]

std::string hobbes::showNoSimpl ( const MonoTypePtr & e )

◆ showPage()

std::string hobbes::showPage ( mempage * p )

◆ showPageDesc()

std::string hobbes::showPageDesc ( const pagedata & pd )

◆ showPages()

std::string hobbes::showPages ( mempage * ps )

◆ showShort()

const array<char>* hobbes::showShort ( short s )

◆ showString()

const array<char>* hobbes::showString ( std::string * x )

◆ showSum()

void hobbes::showSum	(	const Variant::Members &	ms,
		std::ostream &	out
	)

◆ showT()

template<typename T >

std::string hobbes::showT ( const T & t )

◆ showTime()

std::string hobbes::showTime ( long x )

inline

◆ showTimespan()

std::string hobbes::showTimespan ( long ts )

inline

◆ showTimespanV()

const array<char>* hobbes::showTimespanV ( timespanT x )

◆ showTimeV()

const array<char>* hobbes::showTimeV ( timeT x )

◆ showTy()

void hobbes::showTy	(	std::ostream &	out,
		const QualTypePtr &	qty
	)

inline

◆ showUS()

std::string hobbes::showUS ( int64_t us )

inline

◆ sigFileExpr()

ExprPtr hobbes::sigFileExpr ( const ExprPtr & e )

◆ sigFnType()

MonoTypePtr hobbes::sigFnType	(	const std::string &	fn,
		const ExprPtr &	db
	)

◆ signalRecord()

const Record* hobbes::signalRecord ( const MonoTypePtr & r )

◆ simplifyVarNames() [1/9]

QualTypePtr hobbes::simplifyVarNames ( const PolyType & t )

◆ simplifyVarNames() [2/9]

QualTypePtr hobbes::simplifyVarNames ( const PolyTypePtr & t )

◆ simplifyVarNames() [3/9]

ConstraintPtr hobbes::simplifyVarNames ( const Constraint & c )

◆ simplifyVarNames() [4/9]

ConstraintPtr hobbes::simplifyVarNames ( const ConstraintPtr & c )

◆ simplifyVarNames() [5/9]

QualTypePtr hobbes::simplifyVarNames ( const QualType & t )

◆ simplifyVarNames() [6/9]

QualTypePtr hobbes::simplifyVarNames ( const QualTypePtr & t )

◆ simplifyVarNames() [7/9]

MonoTypePtr hobbes::simplifyVarNames ( const MonoType & t )

◆ simplifyVarNames() [8/9]

MonoTypePtr hobbes::simplifyVarNames ( const MonoTypePtr & t )

◆ simplifyVarNames() [9/9]

MonoTypes hobbes::simplifyVarNames ( const MonoTypes & mts )

◆ sizeOf()

unsigned int hobbes::sizeOf ( const MonoTypePtr & mt )

◆ slurpLines()

str::seq hobbes::slurpLines	(	std::istream &	in,
		size_t	i,
		size_t	f
	)

◆ spatChar()

unsigned char hobbes::spatChar	(	const MatchArray &	ma,
		size_t	i
	)

inline

◆ spawn()

void hobbes::spawn	(	const std::string &	cmd,
		proc *	p
	)

◆ stateCount()

size_t hobbes::stateCount ( const ParserEvalInfo & pei )

◆ stdoutBuffer()

std::ostringstream& hobbes::stdoutBuffer ( )

◆ stdoutBufferSwap()

void hobbes::stdoutBufferSwap ( std::ostream * os )

◆ stdstrelem()

char hobbes::stdstrelem	(	const std::string &	x,
		size_t	i
	)

◆ stdstringAssign()

void hobbes::stdstringAssign	(	std::string *	lhs,
		array< char > *	rhs
	)

◆ stdstrsize()

size_t hobbes::stdstrsize ( const std::string & x )

◆ stepEventLoop()

bool hobbes::stepEventLoop ( )

◆ storageFunction()

static void* hobbes::storageFunction	(	cc *	c,
		const MonoTypePtr &	ty,
		const MonoTypePtr &	storageType,
		const LexicalAnnotation &	la
	)

static

◆ storageSizeOf()

size_t hobbes::storageSizeOf ( const MonoTypePtr & mty )

◆ storeAs()

static MonoTypePtr hobbes::storeAs	(	cc *	c,
		const MonoTypePtr &	ty
	)

static

◆ storedAsArray()

bool hobbes::storedAsArray ( const MonoTypePtr & ty )

◆ storedListOf()

static MonoTypePtr hobbes::storedListOf ( const MonoTypePtr & ty )

static

◆ storedOffset() [1/4]

unsigned int hobbes::storedOffset	(	const Record *	rty,
		const std::string &	lbl
	)

◆ storedOffset() [2/4]

unsigned int hobbes::storedOffset	(	const FileConfig &	fcfg,
		const std::string &	lbl
	)

◆ storedOffset() [3/4]

unsigned int hobbes::storedOffset	(	const MonoTypePtr &	ty,
		const std::string &	lbl
	)

◆ storedOffset() [4/4]

unsigned int hobbes::storedOffset	(	const ExprPtr &	e,
		const std::string &	lbl
	)

◆ storedStreamOf()

static MonoTypePtr hobbes::storedStreamOf ( const MonoTypePtr & ty )

static

◆ strelem()

char hobbes::strelem	(	std::string *	s,
		long	i
	)

◆ stripAssumpHead()

const ExprPtr & hobbes::stripAssumpHead ( const ExprPtr & e )

◆ stripAssumps()

ExprPtr hobbes::stripAssumps ( const ExprPtr & e )

◆ stripExplicitAssumptions()

ExprPtr hobbes::stripExplicitAssumptions ( const ExprPtr & e )

◆ stripHiddenFields() [1/2]

Record::Members hobbes::stripHiddenFields ( const Record * rty )

◆ stripHiddenFields() [2/2]

MonoTypePtr hobbes::stripHiddenFields ( const MonoTypePtr & ty )

◆ strsize()

long hobbes::strsize ( std::string * s )

◆ structOffset()

llvm::Value* hobbes::structOffset	(	llvm::IRBuilder<> *	b,
		llvm::Value *	p,
		unsigned int	fieldOffset
	)

inline

◆ substitute() [1/15]

MonoTypePtr hobbes::substitute	(	MonoTypeUnifier *	u,
		const MonoTypePtr &	ty
	)

◆ substitute() [2/15]

MonoTypes hobbes::substitute	(	MonoTypeUnifier *	u,
		const MonoTypes &	tys
	)

◆ substitute() [3/15]

ConstraintPtr hobbes::substitute	(	MonoTypeUnifier *	u,
		const ConstraintPtr &	cst
	)

◆ substitute() [4/15]

Constraints hobbes::substitute	(	MonoTypeUnifier *	u,
		const Constraints &	cs
	)

◆ substitute() [5/15]

QualTypePtr hobbes::substitute	(	MonoTypeUnifier *	u,
		const QualTypePtr &	qty
	)

◆ substitute() [6/15]

ExprPtr hobbes::substitute	(	MonoTypeUnifier *	u,
		const ExprPtr &	e
	)

◆ substitute() [7/15]

MVarDefs hobbes::substitute	(	const MonoTypeSubst &	s,
		const MVarDefs &	vds
	)

◆ substitute() [8/15]

QualTypePtr hobbes::substitute	(	const MonoTypeSubst &	s,
		const QualTypePtr &	qt
	)

◆ substitute() [9/15]

Constraints hobbes::substitute	(	const MonoTypeSubst &	s,
		const Constraints &	cs
	)

◆ substitute() [10/15]

ConstraintPtr hobbes::substitute	(	const MonoTypeSubst &	s,
		const ConstraintPtr &	p
	)

◆ substitute() [11/15]

MonoTypePtr hobbes::substitute	(	const MonoTypeSubst &	s,
		const MonoType &	mt
	)

◆ substitute() [12/15]

MonoTypePtr hobbes::substitute	(	const MonoTypeSubst &	s,
		const MonoTypePtr &	mt
	)

◆ substitute() [13/15]

MonoTypes hobbes::substitute	(	const MonoTypeSubst &	s,
		const MonoTypes &	ts
	)

◆ substitute() [14/15]

ExprPtr hobbes::substitute	(	const VarMapping &	vm,
		const ExprPtr &	e,
		bool *	mapped = `0`
	)

◆ substitute() [15/15]

ExprPtr hobbes::substitute	(	const MonoTypeSubst &	s,
		const ExprPtr &	e
	)

◆ substituteStep()

MonoTypePtr hobbes::substituteStep	(	const MonoTypeSubst &	s,
		const MonoTypePtr &	mt
	)

◆ substitution() [1/2]

MonoTypeSubst hobbes::substitution ( const NameIndexing & ns )

◆ substitution() [2/2]

MonoTypeSubst hobbes::substitution	(	const str::seq &	ns,
		const MonoTypes &	ts
	)

inline

◆ succ()

item hobbes::succ ( const item & i )

◆ sumAttr()

size_t hobbes::sumAttr	(	const mempage *	p,
		pattr::E	a
	)

◆ sumtype()

MonoTypePtr hobbes::sumtype	(	const MonoTypePtr &	t0,
		const MonoTypePtr &	t1
	)

inline

◆ sweepFileWatch()

void hobbes::sweepFileWatch ( FileWatch & fw )

◆ switchE()

ExprPtr hobbes::switchE	(	const ExprPtr &	e,
		const Switch::Bindings &	bs,
		const ExprPtr &	def,
		const LexicalAnnotation &	la
	)

inline

◆ switchOf() [1/23]

template<typename T >

T hobbes::switchOf	(	const GrammarValuePtr &	p,
		const switchGrammarValue< T > &	f
	)

◆ switchOf() [2/23]

template<typename T >

T hobbes::switchOf	(	const RegexPtr &	p,
		const switchRegex< T > &	f
	)

◆ switchOf() [3/23]

template<typename T >

T hobbes::switchOf	(	const MState &	s,
		const switchMState< T > &	f
	)

◆ switchOf() [4/23]

template<typename T >

T hobbes::switchOf	(	const MStatePtr &	s,
		const switchMState< T > &	f
	)

◆ switchOf() [5/23]

template<typename T >

T hobbes::switchOf	(	const PatternPtr &	p,
		const switchPattern< T > &	f
	)

◆ switchOf() [6/23]

template<typename T >

std::vector<T> hobbes::switchOf	(	const Patterns &	ps,
		const switchPattern< T > &	f
	)

◆ switchOf() [7/23]

template<typename T >

T hobbes::switchOf	(	const MonoType &	ty,
		const switchType< T > &	f
	)

◆ switchOf() [8/23]

template<typename T >

T hobbes::switchOf	(	const MonoTypePtr &	ty,
		const switchType< T > &	f
	)

◆ switchOf() [9/23]

template<typename T >

std::vector<T> hobbes::switchOf	(	const MonoTypes &	ts,
		const switchType< T > &	f
	)

◆ switchOf() [10/23]

template<typename T >

T hobbes::switchOf	(	const MonoTypes &	ts,
		T	s,
		T(*)(T, T)	appendF,
		const switchType< T > &	f
	)

◆ switchOf() [11/23]

template<typename K , typename T >

std::vector< std::pair<K, T> > hobbes::switchOf	(	const std::vector< std::pair< K, MonoTypePtr > > &	kts,
		const switchType< T > &	f
	)

◆ switchOf() [12/23]

template<typename T >

Variant::Members hobbes::switchOf	(	const Variant::Members &	ms,
		const switchType< T > &	f
	)

◆ switchOf() [13/23]

template<typename T >

Record::Members hobbes::switchOf	(	const Record::Members &	ms,
		const switchType< T > &	f
	)

◆ switchOf() [14/23]

template<typename T >

T hobbes::switchOf	(	const PrimitivePtr &	p,
		const switchConst< T > &	f
	)

◆ switchOf() [15/23]

UnitV hobbes::switchOf	(	const Case::Bindings &	bs,
		const switchExprTyFnM &	f
	)

◆ switchOf() [16/23]

template<typename T >

T hobbes::switchOf	(	const Expr &	e,
		const switchExpr< T > &	f
	)

◆ switchOf() [17/23]

template<typename T >

T hobbes::switchOf	(	const ExprPtr &	e,
		const switchExpr< T > &	f
	)

◆ switchOf() [18/23]

template<typename T >

T hobbes::switchOf	(	const ExprPtr &	e,
		const switchExprM< T > &	f
	)

◆ switchOf() [19/23]

template<typename T >

std::vector<T> hobbes::switchOf	(	const Exprs &	es,
		const switchExpr< T > &	f
	)

◆ switchOf() [20/23]

template<typename T >

std::vector<T> hobbes::switchOf	(	const Exprs &	es,
		const switchExprM< T > &	f
	)

◆ switchOf() [21/23]

template<typename K , typename T >

std::vector< std::pair<K, T> > hobbes::switchOf	(	const std::vector< std::pair< K, ExprPtr > > &	kes,
		const switchExpr< T > &	f
	)

◆ switchOf() [22/23]

template<typename K , typename T >

std::vector< std::pair<K, T> > hobbes::switchOf	(	const std::vector< std::pair< K, ExprPtr > > &	kes,
		const switchExprM< T > &	f
	)

◆ switchOf() [23/23]

Switch::Bindings hobbes::switchOf	(	const Case::Bindings &	bs,
		const switchExpr< ExprPtr > &	f
	)

◆ switchOfF() [1/2]

template<typename T , typename Ptr , typename PtrC , typename F >

T hobbes::switchOfF	(	Ptr	ty,
		F	f
	)

◆ switchOfF() [2/2]

template<typename T , typename F >

T hobbes::switchOfF	(	const Expr &	e,
		F	f
	)

◆ sym()

terminal* hobbes::sym	(	symbols *	ss,
		const std::string &	x
	)

◆ symbolsDerivingNull()

terminalset hobbes::symbolsDerivingNull ( const grammar & g )

◆ symbolsUsed() [1/4]

void hobbes::symbolsUsed	(	const grammar &	g,
		const rule &	r,
		terminalset *	ss
	)

◆ symbolsUsed() [2/4]

void hobbes::symbolsUsed	(	const grammar &	g,
		const rules &	rs,
		terminalset *	ss
	)

◆ symbolsUsed() [3/4]

void hobbes::symbolsUsed	(	const grammar &	g,
		terminal *	s,
		terminalset *	ss
	)

◆ symbolsUsed() [4/4]

terminalset hobbes::symbolsUsed	(	const grammar &	g,
		terminal *	s
	)

◆ symbolsUsing()

terminalset hobbes::symbolsUsing	(	const grammar &	g,
		terminal *	s
	)

◆ tableTail()

void hobbes::tableTail	(	PatternRows *	out,
		const PatternRows &	in
	)

◆ tabs()

MonoTypePtr hobbes::tabs	(	const str::seq &	tns,
		const MonoTypePtr &	body
	)

inline

◆ tailMembers() [1/2]

Variant::Members hobbes::tailMembers ( const Variant::Members & ms )

◆ tailMembers() [2/2]

Record::Members hobbes::tailMembers	(	bool	tup,
		const Record::Members &	ms
	)

◆ take()

template<typename T >

std::vector<T> hobbes::take	(	const std::vector< T > &	xs,
		size_t	n
	)

◆ tapp()

MonoTypePtr hobbes::tapp	(	const MonoTypePtr &	f,
		const MonoTypes &	args
	)

inline

◆ tctorMaps()

MTypeCtorMaps* hobbes::tctorMaps ( )

◆ texpr()

MonoTypePtr hobbes::texpr ( const ExprPtr & x )

inline

◆ tgen()

MonoTypePtr hobbes::tgen ( int i )

inline

◆ tgens()

MonoTypes hobbes::tgens ( int vs )

◆ tgenSize() [1/6]

int hobbes::tgenSize ( const MonoTypePtr & mt )

◆ tgenSize() [2/6]

int hobbes::tgenSize ( const MonoTypes & mts )

◆ tgenSize() [3/6]

int hobbes::tgenSize ( const Constraints & cs )

◆ tgenSize() [4/6]

int hobbes::tgenSize ( const ConstraintPtr & c )

◆ tgenSize() [5/6]

int hobbes::tgenSize ( const QualTypePtr & qt )

◆ tgenSize() [6/6]

int hobbes::tgenSize ( const ExprPtr & e )

◆ tgenVars()

TGenVarSet hobbes::tgenVars ( const MonoTypePtr & mt )

◆ threadRegion()

region& hobbes::threadRegion ( )

◆ threadRegions()

static Regions& hobbes::threadRegions ( )

static

◆ threadSleep()

void hobbes::threadSleep ( timespanT dt )

◆ threadWait()

void hobbes::threadWait ( long x )

◆ throwBufferError()

void hobbes::throwBufferError	(	const char *	buffer,
		const YYLTYPE &	errPos,
		const std::string &	emsg
	)

◆ throwFileError()

void hobbes::throwFileError	(	const std::string &	fname,
		const YYLTYPE &	errPos,
		const std::string &	emsg
	)

◆ tick()

long hobbes::tick ( )

inline

◆ time()

long hobbes::time ( )

inline

◆ timeFromDateTime()

long hobbes::timeFromDateTime ( long x )

inline

◆ tlong()

MonoTypePtr hobbes::tlong ( long x )

inline

◆ tocPageToFilePage()

file_pageindex_t hobbes::tocPageToFilePage	(	const imagefile *	f,
		uint64_t	tpage
	)

◆ tocPosToFilePos()

static uint64_t hobbes::tocPosToFilePos	(	const imagefile *	f,
		uint64_t	spos
	)

static

◆ toLLVM() [1/4]

llvm::Value * hobbes::toLLVM	(	jitcc *	c,
		const ExprPtr &	exp
	)

◆ toLLVM() [2/4]

llvm::Type * hobbes::toLLVM	(	const MonoTypePtr &	ty,
		bool	asArg = `false`
	)

◆ toLLVM() [3/4]

llvm::Value * hobbes::toLLVM	(	jitcc *	e,
		const std::string &	vname,
		const ExprPtr &	exp
	)

◆ toLLVM() [4/4]

Types hobbes::toLLVM	(	const MonoTypes &	tys,
		bool	asArg = `false`
	)

◆ toLLVMConstant()

llvm::Constant * hobbes::toLLVMConstant	(	jitcc *	c,
		const std::string &	vname,
		const ExprPtr &	e
	)

◆ toLLVMConstantInt()

llvm::ConstantInt * hobbes::toLLVMConstantInt ( const PrimitivePtr & p )

◆ toParseRuleBindings()

ParseRule::Bindings hobbes::toParseRuleBindings	(	symbols *	ss,
		chars *	cs,
		const BoundGrammarValues &	gvs
	)

◆ topLevelSymbols()

terminalset hobbes::topLevelSymbols ( const grammar & g )

◆ toRanges()

CharRanges hobbes::toRanges ( const std::set< rchar_t > & cs )

◆ toSet()

template<typename CT >

std::set<typename CT::value_type> hobbes::toSet ( const CT & xs )

◆ toVector()

template<typename T >

std::vector<T> hobbes::toVector ( const std::set< T > & xs )

◆ transitionAsCharSwitch()

static ExprPtr hobbes::transitionAsCharSwitch	(	const std::string &	fname,
		const DFAState &	s,
		const ExprPtr &	charExpr,
		const ExprPtr &	defaultResult,
		const LexicalAnnotation &	rootLA
	)

static

◆ transitionAsRangeChecks()

static ExprPtr hobbes::transitionAsRangeChecks	(	const std::string &	fname,
		const std::vector< std::pair< std::pair< rchar_t, rchar_t >, state >> &	ranges,
		const ExprPtr &	charExpr,
		const ExprPtr &	defaultResult,
		const LexicalAnnotation &	rootLA
	)

static

◆ transitionDef()

IDFATransition hobbes::transitionDef	(	const ArgPos &	argpos,
		MDFA *	dfa,
		stateidx_t	s,
		const GlobalToLocalState &	localstate,
		std::set< stateidx_t > *	dones,
		array< IDFAState > *	dfaStates
	)

◆ transitionMapping()

static ExprPtr hobbes::transitionMapping	(	const std::string &	fname,
		const DFAState &	s,
		const ExprPtr &	charExpr,
		const ExprPtr &	defaultResult,
		const LexicalAnnotation &	rootLA
	)

static

◆ transitions() [1/3]

transitionset hobbes::transitions ( const parserdef & p )

◆ transitions() [2/3]

const state_transitions& hobbes::transitions	(	const parserdef &	p,
		nat	q
	)

◆ transitions() [3/3]

IDFATransitions * hobbes::transitions	(	const ArgPos &	argpos,
		MDFA *	dfa,
		const SwitchVal::Jumps &	jmps,
		const GlobalToLocalState &	localstate,
		std::set< stateidx_t > *	dones,
		array< IDFAState > *	dfaStates
	)

◆ transitionToState()

static ExprPtr hobbes::transitionToState	(	const std::string &	fname,
		int	s,
		const LexicalAnnotation &	rootLA
	)

static

◆ translatep()

template<typename T >

T hobbes::translatep	(	const MatchArray &	ma,
		size_t	i
	)

◆ trCons() [1/2]

MonoTypes hobbes::trCons	(	const MonoTypePtr &	hty,
		const MonoTypes &	ttys
	)

◆ trCons() [2/2]

Exprs hobbes::trCons	(	const ExprPtr &	hexp,
		const Exprs &	texps
	)

◆ truncd()

long hobbes::truncd ( double x )

◆ truncDate()

datetimeT hobbes::truncDate ( datetimeT t )

◆ truncTime()

timeT hobbes::truncTime ( datetimeT t )

◆ tryMkConstRecord()

llvm::Value* hobbes::tryMkConstRecord	(	llvm::IRBuilder<> *	,
		llvm::Module *	m,
		const RecordValue &	rv,
		const Record *	rty
	)

inline

◆ tryMkConstVarArray()

llvm::Value* hobbes::tryMkConstVarArray	(	llvm::IRBuilder<> *	b,
		llvm::Module *	m,
		llvm::Type *	elemTy,
		const Values &	vs,
		bool	globalPtrRefs
	)

inline

◆ tryRefine()

void hobbes::tryRefine	(	const TEnvPtr &	tenv,
		const MonoTypePtr &	lhs,
		const MonoTypePtr &	rhs,
		const MonoTypePtr &	result,
		MonoTypeUnifier *	s
	)

◆ tstring()

MonoTypePtr hobbes::tstring ( const std::string & x )

inline

◆ tstrings()

MonoTypePtr hobbes::tstrings ( const std::vector< std::string > & xs )

inline

◆ tuple()

MonoTypePtr hobbes::tuple ( const MonoTypes & mtys = MonoTypes() )

inline

◆ tupleNormalize() [1/2]

Record::Members hobbes::tupleNormalize ( const Record::Members & ms )

◆ tupleNormalize() [2/2]

MkRecord::FieldDefs hobbes::tupleNormalize ( const MkRecord::FieldDefs & fds )

◆ tvar()

MonoTypePtr hobbes::tvar ( const std::string & vn )

inline

◆ tvarNames() [1/13]

NameSet hobbes::tvarNames ( const QualTypePtr & qt )

◆ tvarNames() [2/13]

NameSet hobbes::tvarNames ( const Constraints & cs )

◆ tvarNames() [3/13]

NameSet hobbes::tvarNames ( const ConstraintPtr & c )

◆ tvarNames() [4/13]

NameSet hobbes::tvarNames ( const MonoTypePtr & mt )

◆ tvarNames() [5/13]

NameSet hobbes::tvarNames ( const MonoType & mt )

◆ tvarNames() [6/13]

NameSet hobbes::tvarNames ( const MonoTypes & mts )

◆ tvarNames() [7/13]

void hobbes::tvarNames	(	const QualTypePtr &	qt,
		NameSet *	out
	)

◆ tvarNames() [8/13]

void hobbes::tvarNames	(	const Constraints &	cs,
		NameSet *	out
	)

◆ tvarNames() [9/13]

void hobbes::tvarNames	(	const ConstraintPtr &	c,
		NameSet *	out
	)

◆ tvarNames() [10/13]

void hobbes::tvarNames	(	const MonoTypePtr &	mt,
		NameSet *	out
	)

◆ tvarNames() [11/13]

void hobbes::tvarNames	(	const MonoType &	mt,
		NameSet *	out
	)

◆ tvarNames() [12/13]

void hobbes::tvarNames	(	const MonoTypes &	mts,
		NameSet *	out
	)

◆ tvarNames() [13/13]

NameSet hobbes::tvarNames ( const ExprPtr & e )

◆ typeCtorForm()

void hobbes::typeCtorForm	(	const MonoTypePtr &	ty,
		std::string *	cname,
		MonoTypes *	targs,
		str::seq *	ignvs
	)

◆ types()

Types hobbes::types ( const Constants & cs )

inline

◆ typeSeqForm()

void hobbes::typeSeqForm	(	const ConstraintPtr &	c,
		MonoTypes *	mts
	)

◆ typeVars()

MonoTypes hobbes::typeVars ( const Names & ns )

◆ uidCtr()

static std::atomic<std::size_t> hobbes::uidCtr ( 0 )

static

◆ unalias()

MonoTypePtr hobbes::unalias ( const MonoTypePtr & ty )

◆ uncompressBytes()

const array<uint8_t>* hobbes::uncompressBytes ( const array< uint8_t > * bs )

◆ uncompressLength()

uint8_t hobbes::uncompressLength	(	const uint8_t *	data,
		size_t *	len
	)

◆ undefineSymbol() [1/2]

void hobbes::undefineSymbol	(	terminal *	s,
		grammar *	g
	)

◆ undefineSymbol() [2/2]

grammar hobbes::undefineSymbol	(	terminal *	s,
		const grammar &	g
	)

◆ underlyingFnType() [1/2]

QualTypePtr hobbes::underlyingFnType	(	const TEnvPtr &	tenv,
		const MonoTypePtr &	rty,
		const std::string &	fieldName,
		const MonoTypePtr &	fty,
		MonoTypeUnifier *	s
	)

◆ underlyingFnType() [2/2]

QualTypePtr hobbes::underlyingFnType	(	const TEnvPtr &	tenv,
		const ConstraintPtr &	c
	)

◆ unescapeInto()

void hobbes::unescapeInto	(	rchar_t	e,
		std::set< rchar_t > *	out
	)

◆ unescapePatChar()

RegexPtr hobbes::unescapePatChar ( rchar_t x )

◆ unifiable() [1/3]

bool hobbes::unifiable	(	const TEnvPtr &	tenv,
		const MonoTypePtr &	t0,
		const MonoTypePtr &	t1
	)

◆ unifiable() [2/3]

bool hobbes::unifiable	(	const TEnvPtr &	tenv,
		const MonoTypes &	ts0,
		const MonoTypes &	ts1
	)

◆ unifiable() [3/3]

bool hobbes::unifiable	(	const TEnvPtr &	tenv,
		const ConstraintPtr &	c0,
		const ConstraintPtr &	c1
	)

◆ uniqueFilename()

std::string hobbes::uniqueFilename	(	const std::string &	prefix,
		const std::string &	suffix
	)

◆ unmapFileData()

static void hobbes::unmapFileData	(	imagefile *	f,
		void *	p,
		size_t	sz
	)

static

◆ unmarkBadFD()

bool hobbes::unmarkBadFD ( int fd )

◆ unpackCaptureVars()

CVarDefs hobbes::unpackCaptureVars	(	const std::string &	strVar,
		const std::string &	bufferVar,
		const CRegexes &	crgxs,
		size_t	state,
		const LexicalAnnotation &	rootLA
	)

◆ unpackedType() [1/3]

MonoTypePtr hobbes::unpackedType ( const Exists * e )

◆ unpackedType() [2/3]

MonoTypePtr hobbes::unpackedType ( const MonoTypePtr & mty )

◆ unpackedType() [3/3]

QualTypePtr hobbes::unpackedType ( const QualTypePtr & qty )

◆ unpackFileType() [1/2]

bool hobbes::unpackFileType	(	const MonoTypePtr &	fty,
		UTFileConfig *	fcfg
	)

◆ unpackFileType() [2/2]

bool hobbes::unpackFileType	(	const MonoTypePtr &	fty,
		FileConfig *	fcfg
	)

◆ unqualifyClass()

ExprPtr hobbes::unqualifyClass	(	const TEnvPtr &	tenv,
		const std::string &	cname,
		const MonoTypes &	tys,
		const ExprPtr &	e,
		Definitions *	ds
	)

◆ unqualifyTypes()

ExprPtr hobbes::unqualifyTypes	(	const TEnvPtr &	tenv,
		const ExprPtr &	e,
		Definitions *	ds
	)

◆ unregisterEventHandler()

void hobbes::unregisterEventHandler ( int fd )

◆ unroll()

MonoTypePtr hobbes::unroll ( const MonoTypePtr & rty )

◆ unsafeWriteToSeries()

static void hobbes::unsafeWriteToSeries	(	long	ss,
		char *	rec
	)

static

◆ unsafeWriteUnitToSeries()

static void hobbes::unsafeWriteUnitToSeries ( long ss )

static

◆ unzip()

template<typename L , typename R >

std::pair< std::vector<L>, std::vector<R> > hobbes::unzip ( const std::vector< std::pair< L, R > > & ps )

◆ upd() [1/2]

void hobbes::upd	(	const ConstraintPtr &	c,
		const HasField &	hf
	)

◆ upd() [2/2]

static void hobbes::upd	(	const ConstraintPtr &	c,
		const PacksTo &	pt
	)

static

◆ updatePageSizeIndex()

static void hobbes::updatePageSizeIndex	(	imagefile *	f,
		file_pageindex_t	page
	)

static

◆ updateTOCData()

static void hobbes::updateTOCData	(	imagefile *	f,
		file_pageindex_t	page,
		const pagedata &	pd
	)

static

◆ usedCharRanges()

CharRanges hobbes::usedCharRanges	(	const NFA &	nfa,
		const stateset &	ss
	)

◆ usedChars() [1/2]

std::set<rchar_t> hobbes::usedChars ( const NFA & nfa )

◆ usedChars() [2/2]

std::set<rchar_t> hobbes::usedChars ( const DFA & dfa )

◆ uvarSubstitution()

MonoTypeSubst hobbes::uvarSubstitution ( const NameIndexing & ns )

◆ validate()

void hobbes::validate	(	const TEnvPtr &	tenv,
		size_t	c,
		const PatternRows &	ps,
		const LexicalAnnotation &	la
	)

◆ validateDimensions()

void hobbes::validateDimensions	(	size_t	c,
		const PatternRows &	ps,
		const LexicalAnnotation &	la
	)

◆ validateType() [1/2]

ExprPtr hobbes::validateType	(	const TEnvPtr &	tenv,
		const ExprPtr &	e,
		Definitions *	ds
	)

◆ validateType() [2/2]

ExprPtr hobbes::validateType	(	const TEnvPtr &	tenv,
		const std::string &	vname,
		const ExprPtr &	e,
		Definitions *	ds
	)

◆ values()

template<typename K , typename V >

std::vector<V> hobbes::values ( const std::map< K, V > & m )

◆ var() [1/3]

ExprPtr hobbes::var	(	const std::string &	vn,
		const LexicalAnnotation &	la
	)

inline

◆ var() [2/3]

ExprPtr hobbes::var	(	const std::string &	vn,
		const QualTypePtr &	ty,
		const LexicalAnnotation &	la
	)

inline

◆ var() [3/3]

ExprPtr hobbes::var	(	const std::string &	vn,
		const MonoTypePtr &	ty,
		const LexicalAnnotation &	la
	)

inline

◆ varArrayConstants()

Constants hobbes::varArrayConstants	(	const Values &	vs,
		bool	globalPtrRefs
	)

inline

◆ varArrayType()

llvm::StructType* hobbes::varArrayType	(	llvm::Type *	elemty,
		size_t	sz = `1`
	)

inline

◆ varCtor()

std::string hobbes::varCtor ( const MatchVariant & mv )

◆ varMapping()

VarMapping hobbes::varMapping ( const Patterns & ps )

◆ varName()

ExprPtr hobbes::varName	(	MDFA *	dfa,
		const std::string &	vn
	)

◆ varNames() [1/2]

str::seq hobbes::varNames ( size_t n )

◆ varNames() [2/2]

str::seq hobbes::varNames ( unsigned int n )

◆ vars()

Exprs hobbes::vars	(	const std::vector< std::string > &	vns,
		const LexicalAnnotation &	la
	)

inline

◆ voidType()

llvm::Type* hobbes::voidType ( )

inline

◆ withUniqueFilenameBy()

std::string hobbes::withUniqueFilenameBy	(	const std::string &	fprefix,
		const std::string &	fsuffix,
		const std::function< bool(const std::string &)> &	fileOp
	)

◆ write() [1/12]

template<typename T >

void hobbes::write	(	imagefile *	f,
		const T &	x
	)

◆ write() [2/12]

void hobbes::write	(	imagefile *	f,
		const std::string &	x
	)

◆ write() [3/12]

void hobbes::write	(	imagefile *	f,
		const std::vector< unsigned char > &	xs
	)

◆ write() [4/12]

void hobbes::write	(	bool	b,
		bytes *	out
	)

◆ write() [5/12]

void hobbes::write	(	char	c,
		bytes *	out
	)

◆ write() [6/12]

void hobbes::write	(	unsigned char	c,
		bytes *	out
	)

◆ write() [7/12]

void hobbes::write	(	int	x,
		bytes *	out
	)

◆ write() [8/12]

void hobbes::write	(	long	x,
		bytes *	out
	)

◆ write() [9/12]

void hobbes::write	(	size_t	x,
		bytes *	out
	)

◆ write() [10/12]

void hobbes::write	(	unsigned int	x,
		bytes *	out
	)

◆ write() [11/12]

void hobbes::write	(	const std::string &	s,
		bytes *	out
	)

◆ write() [12/12]

template<typename T >

void hobbes::write	(	const std::vector< T > &	xs,
		bytes *	out
	)

◆ writeFileRT()

long hobbes::writeFileRT	(	const array< char > *	fname,
		long	tydef
	)

◆ writeOrMark()

void hobbes::writeOrMark	(	int	fd,
		const char *	b,
		size_t	sz
	)

◆ writes()

template<typename TIter >

void hobbes::writes	(	imagefile *	f,
		TIter	begin,
		TIter	end
	)

◆ zeroOrMore()

RegexPtr hobbes::zeroOrMore ( const RegexPtr & p )

◆ zip()

template<typename L , typename R >

std::vector< std::pair<L, R> > hobbes::zip	(	const std::vector< L > &	left,
		const std::vector< R > &	right
	)

Variable Documentation

◆ activeParseBuffers

std::stack<YY_BUFFER_STATE> hobbes::activeParseBuffers

◆ chararrty

MonoTypePtr hobbes::chararrty = arrayty(primty("char"))

static

◆ connections

Connections hobbes::connections

static

◆ currentRegion

__thread size_t hobbes::currentRegion = 0

static

◆ datetimeTNV

const char hobbes::datetimeTNV = "datetime"

◆ else

template<template< class > class SzP, typename T0 , typename T1 , typename ... Ts>

hobbes::else

Initial value:

{

DtorAt0<Ctors...>::invoke(t-1, p)

◆ filePrefixBytes

const uint32_t hobbes::filePrefixBytes = 0x10a1db0d

static

◆ FUNCTION_SIZE_THRESHOLD

const size_t hobbes::FUNCTION_SIZE_THRESHOLD = 64

◆ machineREPLLogFD

int hobbes::machineREPLLogFD = -1

static

◆ maxPageSize

const size_t hobbes::maxPageSize = ((1 << 14) - 1)

static

◆ minPageSize

const size_t hobbes::minPageSize = 256

static

◆ nullResult

const result hobbes::nullResult = (result)-1

static

◆ nullState

static const state hobbes::nullState = (stateidx_t)-1

◆ nulltdb

nulltypedb hobbes::nulltdb

◆ pageDataOffset

const size_t hobbes::pageDataOffset = sizeof(filehead)

static

◆ patVarCtorFn

PatVarCtorFn hobbes::patVarCtorFn = &defPatVarCtor

◆ refcMaps

template<size_t i, typename ... UniqueRefcMaps>

std::enable_if<i < sizeof...(UniqueRefcMaps), size_t>::type compactAll(std::tuple<UniqueRefcMaps...>& ms) { return std::get<i>ms).compact() + compactAll<i+1, UniqueRefcMaps...>ms); }template <size_t i, typename T, typename ... Ts> struct TypeIndex { static const size_t value = i; };template <size_t i, typename T, typename ... Ts> struct TypeIndex<i, T, T, Ts...> { static const size_t value = i; };template <size_t i, typename T, typename U, typename ... Ts> struct TypeIndex<i, T, U, Ts...> { static const size_t value = TypeIndex<i+1, T, Ts...>::value; };template <typename ... UniqueRefcMaps> class unique_refc_maps { private: typedef std::tuple<UniqueRefcMaps...> RefcMaps; RefcMaps refcMaps; public: template <typename T> typename std::tuple_element<TypeIndex<0, T, UniqueRefcMaps...>::value, RefcMaps>::type& at() { return std::get<TypeIndex<0, T, UniqueRefcMaps...>::value>this-> hobbes::refcMaps

inline

◆ rsignames

Signames hobbes::rsignames

static

◆ stdstrty

MonoTypePtr hobbes::stdstrty = OpaquePtr::make("std::string", 0, false)

static

◆ threadRegionp

__thread region* hobbes::threadRegionp = 0

static

◆ threadRegionsp

__thread Regions* hobbes::threadRegionsp = 0

static

◆ timespanTNV

const char hobbes::timespanTNV = "timespan"

◆ timeTNV

const char hobbes::timeTNV = "time"

◆ unit

const bool hobbes::unit = true

◆ unitty

MonoTypePtr hobbes::unitty = primty("unit")

static

◆ unitv

const UnitV hobbes::unitv = 0x00

static

◆ varCtorFn

VarCtorFn hobbes::varCtorFn = &defVarCtor

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ AnnContextStack

◆ annmsg

◆ annmsgs

◆ ArgPos

◆ Args

◆ ArrayElem

◆ ArrayMem

◆ bindingset

◆ BoundGrammarValues

◆ BuffOrFilename

◆ BuffOrFilenamePtr

◆ ByteRangeWatches

◆ bytes

◆ CaptureVarsAt

◆ CFunDepDef

◆ CFunDepDefs

◆ ChangeSignal

◆ ChangeSignals

◆ CharRange

◆ CharRanges

◆ chars

◆ ClassDefPtr

◆ ClassDefs

◆ Classes

◆ ComprehensionDefs

◆ Connections

◆ Constants

◆ ConstFieldValue

◆ ConstraintPtr

◆ Constraints

◆ ConstRecordValue

◆ CVarDef

◆ CVarDefs

◆ datetimeT

◆ DCharset

◆ Definition

◆ Definitions

◆ DFA

◆ DRegex

◆ DRT

◆ dtransitions

◆ EpsClosure

◆ EqStates

◆ EventClosures

◆ eventhandler

◆ ExistsMem

◆ ExprCheck

◆ ExprChecks

◆ ExprDefn

◆ exprid

◆ ExprIdxs

◆ ExprParser

◆ ExprPtr

◆ Exprs

◆ fallocs

◆ FieldValue

◆ file_pageindex_t

◆ FileConfig

◆ FileWatchData

◆ FileWatches

◆ FixedArrayMem

◆ fmappings

◆ FoldedState

◆ FoldedStateCalls

◆ FoldedStates

◆ FRefT

◆ FuncMem

◆ FunDep

◆ FunDeps

◆ GlobalToLocalState

◆ grammar

◆ Grammar

◆ GrammarRules

◆ GrammarSymDef