The COMPILE signature

Synopsis

signature COMPILE
structure Compiler.Compile : COMPILE


Interface

exception Compile of string
type lvar = Lambda.lvar
type absyn
type compInfo
type lambda = Lambda.lexp
type pid = PersStamps.persstamp
type obj = Unsafe.Object.object
type csegments = {c0 : Word8Vector.vector, cn : Word8Vector.vector list, name : string option ref}
val debugging : bool ref
val mkCompInfo : (Source.inputSource * StaticEnv.staticEnv * (Absyn.dec -> Absyn.dec)) -> compInfo
val anyErrors : compInfo -> bool
val parse : Source.inputSource -> Ast.dec
val parseOne : Source.inputSource -> unit -> Ast.dec option
structure SCS : sig
    type staticEnv
    val SC : StaticEnv.staticEnv -> staticEnv
    val unSC : staticEnv -> StaticEnv.staticEnv
  end
type pickle
type hash
val elaborate : {ast : Ast.dec, compenv : SCS.staticEnv, compInfo : compInfo} -> {absyn : Absyn.dec, newenv : SCS.staticEnv, exportLvars : lvar list, exportPid : pid option, staticPid : hash, pickle : pickle}
val makePid : (SCStaticEnv.staticEnv * SCStaticEnv.staticEnv) -> PersStamps.persstamp
val instrument : {source : Source.inputSource, compenv : SCS.staticEnv, compInfo : compInfo} -> Absyn.dec -> Absyn.dec
val translate : {absyn : Absyn.dec, exportLvars : lvar list, exportPid : pid option, newstatenv : SCS.staticEnv, oldstatenv : SCS.staticEnv, compInfo : compInfo} -> {genLambda : lambda option list -> lambda, imports : pid list}
val symDelta : (pid option * lambda option) -> SymbolicEnv.symenv
val architecture : string
val inline : {genLambda : lambda option list -> lambda, imports : pid list, symenv : SymbolicEnv.symenv} -> lambda
val split : {lambda : lambda, enable : bool} -> {lambda_e : lambda, lambda_i : lambda option}
val codegen : {lambda : lambda, compInfo : compInfo} -> csegments
val applyCode : csegments -> obj vector -> obj
exception TopLevelException of exn
exception SilentException
exception TopLevelCallcc
val isolate : ('a -> 'b) -> 'a -> 'b
val execute : {executable : obj vector -> obj, imports : pid list, exportPid : pid option, dynenv : DynamicEnv.dynenv} -> DynamicEnv.dynenv


Description

exception Compile

type lvar

type absyn

type compInfo

type lambda

type pid

type obj

type csegments

debugging

mkCompInfo (in, st, f)

anyErrors co

Have any compile errors been reported in co?

parse in

parseOne in ()

structure SCS

type staticEnv

SC st

unSC st

type pickle

type hash

elaborate {ast, compenv, compInfo}

makePid (st, st2)

instrument {source, compenv, compInfo} de

translate {absyn, exportLvars, exportPid, newstatenv, oldstatenv, compInfo}

symDelta (opt, opt2)

architecture

inline {genLambda, imports, symenv}

split {lambda, enable}

codegen {lambda, compInfo}

applyCode cs vec

exception TopLevelException

exception SilentException

exception TopLevelCallcc

isolate f a

execute {executable, imports, exportPid, dynenv}