## To makePeState (e: Map of Text to CVal) and (f: Map of Text to CFunc) and (d: Int) -> PEState:
Return a new PEStateR with env e and funcs f and depth d and staticEnv (a new Map of Text to CExpr) and memoCache (a new Map of Text to CExpr) and callGuard (a new Seq of Text).
## To peEnvB (st: PEState) -> Map of Text to CVal:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return e.
## To peFuncsB (st: PEState) -> Map of Text to CFunc:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return f.
## To peDepthB (st: PEState) -> Int:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return d.
## To peStateWithDepthB (st: PEState) and (d: Int) -> PEState:
Inspect st:
When PEStateR (e, f, oldD, se, sr, os):
Return a new PEStateR with env e and funcs f and depth d and staticEnv se and memoCache sr and callGuard os.
## To peMemoCache (st: PEState) -> Map of Text to CExpr:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return sr.
## To peCallGuard (st: PEState) -> Seq of Text:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return os.
## To peStateWithEnvDepthB (st: PEState) and (newEnv: Map of Text to CVal) and (d: Int) -> PEState:
Inspect st:
When PEStateR (e, f, oldD, se, sr, os):
Return a new PEStateR with env newEnv and funcs f and depth d and staticEnv (a new Map of Text to CExpr) and memoCache sr and callGuard (copy of os).
## To peStaticEnvB (st: PEState) -> Map of Text to CExpr:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Return se.
## To peStateWithStaticBindingB (st: PEState) and (name: Text) and (val: CExpr) -> PEState:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Set item name of se to val.
Return a new PEStateR with env e and funcs f and depth d and staticEnv se and memoCache sr and callGuard os.
## To peStateRemoveStaticB (st: PEState) and (name: Text) -> PEState:
Inspect st:
When PEStateR (e, f, d, se, sr, os):
Remove name from se.
Return a new PEStateR with env e and funcs f and depth d and staticEnv se and memoCache sr and callGuard os.
## To peStateWithEnvDepthStaticB (st: PEState) and (newEnv: Map of Text to CVal) and (d: Int) and (newSe: Map of Text to CExpr) -> PEState:
Inspect st:
When PEStateR (e, f, oldD, se, sr, os):
Return a new PEStateR with env newEnv and funcs f and depth d and staticEnv newSe and memoCache sr and callGuard (copy of os).
## To checkVNothing (v: CVal) -> Bool:
Inspect v:
When VNothing:
Return true.
Otherwise:
Return false.
## To checkLiteral (e: CExpr) -> Bool:
Inspect e:
When CInt (v):
Return true.
When CBool (v):
Return true.
When CText (v):
Return true.
Otherwise:
Return false.
## To exprToValB (e: CExpr) -> CVal:
Inspect e:
When CInt (v):
Return a new VInt with value v.
When CBool (v):
Return a new VBool with value v.
When CText (v):
Return a new VText with value v.
When CFloat (v):
Return a new VFloat with value v.
When CList (items):
Let vals be a new Seq of CVal.
Repeat for elem in items:
Push exprToValB(elem) to vals.
Return a new VSeq with items vals.
When CNewVariant (tag, names, vals):
Let vvals be a new Seq of CVal.
Repeat for v in vals:
Push exprToValB(v) to vvals.
Return a new VVariant with typeName tag and variantName tag and fields vvals.
When CNew (typeName, fieldNames, fieldExprs):
If typeName equals "Map":
Return a new VMap with entries a new Map of Text to CVal.
Let vvals be a new Seq of CVal.
Repeat for fe in fieldExprs:
Push exprToValB(fe) to vvals.
Return a new VVariant with typeName typeName and variantName typeName and fields vvals.
When CTuple (items):
Let vals be a new Seq of CVal.
Repeat for elem in items:
Push exprToValB(elem) to vals.
Return a new VTuple with items vals.
When CCopy (target):
Return exprToValB(target).
Otherwise:
Return a new VNothing.
## To valToExprB (v: CVal) -> CExpr:
Inspect v:
When VInt (n):
Return a new CInt with value n.
When VBool (b):
Return a new CBool with value b.
When VText (s):
Return a new CText with value s.
When VFloat (f):
Return a new CFloat with value f.
When VSeq (items):
Let exprs be a new Seq of CExpr.
Repeat for elem in items:
Push valToExprB(elem) to exprs.
Return a new CList with items exprs.
When VVariant (vTypeName, vVarName, vFields):
Let exprs be a new Seq of CExpr.
Repeat for v in vFields:
Push valToExprB(v) to exprs.
Return a new CNewVariant with tag vVarName and fnames (a new Seq of Text) and fvals exprs.
When VTuple (items):
Let exprs be a new Seq of CExpr.
Repeat for elem in items:
Push valToExprB(elem) to exprs.
Return a new CTuple with items exprs.
When VOption (inner, present):
If present:
Return a new COptionSome with inner (valToExprB(inner)).
Return a new COptionNone.
When VMap (entries):
Return a new CNew with typeName "Map" and fieldNames (a new Seq of Text) and fields (a new Seq of CExpr).
Otherwise:
Return a new CVar with name "__unresolvable".
## To evalBinOpB (binOp: Text) and (lv: CVal) and (rv: CVal) -> CVal:
Inspect lv:
When VInt (a):
Inspect rv:
When VInt (b):
If binOp equals "+":
Return a new VInt with value (a + b).
If binOp equals "-":
Return a new VInt with value (a - b).
If binOp equals "*":
Return a new VInt with value (a * b).
If binOp equals "/":
If b equals 0:
Return a new VNothing.
Return a new VInt with value (a / b).
If binOp equals "%":
If b equals 0:
Return a new VNothing.
Return a new VInt with value (a % b).
If binOp equals "<":
Return a new VBool with value (a is less than b).
If binOp equals ">":
Return a new VBool with value (a is greater than b).
If binOp equals "<=":
Return a new VBool with value (a is at most b).
If binOp equals ">=":
Return a new VBool with value (a is at least b).
If binOp equals "==":
Return a new VBool with value (a equals b).
If binOp equals "!=":
Return a new VBool with value (a is not b).
Return a new VNothing.
Otherwise:
Return a new VNothing.
When VBool (a):
Inspect rv:
When VBool (b):
If binOp equals "&&":
Return a new VBool with value (a and b).
If binOp equals "||":
Return a new VBool with value (a or b).
If binOp equals "==":
Return a new VBool with value (a equals b).
If binOp equals "!=":
Return a new VBool with value (a is not b).
Return a new VNothing.
Otherwise:
Return a new VNothing.
When VText (a):
Inspect rv:
When VText (b):
If binOp equals "+":
Let joined be "{a}{b}".
Return a new VText with value joined.
If binOp equals "==":
Return a new VBool with value (a equals b).
If binOp equals "!=":
Return a new VBool with value (a is not b).
Return a new VNothing.
Otherwise:
Return a new VNothing.
Otherwise:
Return a new VNothing.
## To checkStatic (e: CExpr) -> Bool:
Inspect e:
When CInt (v):
Return true.
When CBool (v):
Return true.
When CText (v):
Return true.
When CFloat (v):
Return true.
When CList (items):
Repeat for elem in items:
Let s be checkStatic(elem).
If not s:
Return false.
Return true.
When CNewVariant (tag, names, vals):
Repeat for v in vals:
Let s be checkStatic(v).
If not s:
Return false.
Return true.
When CTuple (items):
Repeat for elem in items:
Let s be checkStatic(elem).
If not s:
Return false.
Return true.
When COptionSome (inner):
Return checkStatic(inner).
When COptionNone:
Return true.
When CNewSeq:
Return true.
When CNewSet:
Return true.
When CNew (typeName, fieldNames, fieldExprs):
Repeat for fe in fieldExprs:
Let s be checkStatic(fe).
If not s:
Return false.
Return true.
When CRange (start, end):
Let s1 be checkStatic(start).
Let s2 be checkStatic(end).
Return (s1 and s2).
When CCopy (target):
Return checkStatic(target).
Otherwise:
Return false.
## To checkCopyPropSafe (e: CExpr) -> Bool:
Inspect e:
When CNewSeq:
Return false.
When CNewSet:
Return false.
Otherwise:
Return true.
## To checkAllStatic (args: Seq of CExpr) -> Bool:
Repeat for a in args:
Let s be checkStatic(a).
If not s:
Return false.
Return true.
## To hasReturnB (stmts: Seq of CStmt) -> Bool:
Repeat for s in stmts:
Inspect s:
When CReturn (retExpr):
Return true.
Otherwise:
Let skip be true.
Return false.
## To exprToKeyPartB (e: CExpr) -> Text:
Inspect e:
When CInt (v):
Return "i{v}".
When CBool (v):
If v:
Return "btrue".
Return "bfalse".
When CText (v):
Return "t{v}".
When CFloat (v):
Return "f{v}".
When CList (items):
Let mutable parts be "l".
Repeat for elem in items:
Let ep be exprToKeyPartB(elem).
Set parts to "{parts}_{ep}".
Return parts.
When CNewVariant (tag, names, vals):
Let mutable parts be "v{tag}".
Repeat for fv in vals:
Let vp be exprToKeyPartB(fv).
Set parts to "{parts}_{vp}".
Return parts.
When CTuple (items):
Let mutable parts be "tp".
Repeat for elem in items:
Let ep be exprToKeyPartB(elem).
Set parts to "{parts}_{ep}".
Return parts.
When COptionSome (inner):
Let ip be exprToKeyPartB(inner).
Return "s{ip}".
When COptionNone:
Return "none".
When CNewSeq:
Return "seq".
When CNewSet:
Return "set".
When CVar (varName):
Return "var{varName}".
When CBinOp (op, left, right):
Let lp be exprToKeyPartB(left).
Let rp be exprToKeyPartB(right).
Return "op{op}_{lp}_{rp}".
When CNot (inner):
Let ip be exprToKeyPartB(inner).
Return "not_{ip}".
When CCall (fnName, args):
Let mutable parts be "call{fnName}".
Repeat for a in args:
Let ap be exprToKeyPartB(a).
Set parts to "{parts}_{ap}".
Return parts.
When CIndex (coll, idx):
Let cp be exprToKeyPartB(coll).
Let ip be exprToKeyPartB(idx).
Return "idx_{cp}_{ip}".
When CLen (target):
Let tp be exprToKeyPartB(target).
Return "len_{tp}".
When CMapGet (mapExpr, key):
Let mp be exprToKeyPartB(mapExpr).
Let kp be exprToKeyPartB(key).
Return "mg_{mp}_{kp}".
When CFieldAccess (target, field):
Let tp be exprToKeyPartB(target).
Return "fa{field}_{tp}".
When CNew (typeName, fieldNames, fieldExprs):
Let mutable parts be "new{typeName}".
Repeat for fv in fieldExprs:
Let vp be exprToKeyPartB(fv).
Set parts to "{parts}_{vp}".
Return parts.
When CRange (start, end):
Let sp be exprToKeyPartB(start).
Let ep be exprToKeyPartB(end).
Return "r_{sp}_{ep}".
When CSlice (coll, startIdx, endIdx):
Let cp be exprToKeyPartB(coll).
Let sp be exprToKeyPartB(startIdx).
Let ep be exprToKeyPartB(endIdx).
Return "sl_{cp}_{sp}_{ep}".
When CCopy (target):
Let tp be exprToKeyPartB(target).
Return "cp_{tp}".
When CContains (coll, elem):
Let cp be exprToKeyPartB(coll).
Let ep be exprToKeyPartB(elem).
Return "ct_{cp}_{ep}".
When CUnion (left, right):
Let lp be exprToKeyPartB(left).
Let rp be exprToKeyPartB(right).
Return "un_{lp}_{rp}".
When CIntersection (left, right):
Let lp be exprToKeyPartB(left).
Let rp be exprToKeyPartB(right).
Return "ix_{lp}_{rp}".
When CClosure (params, body, captured):
Return "cl".
When CCallExpr (target, args):
Let tp be exprToKeyPartB(target).
Return "ce_{tp}".
When CInterpolatedString (parts):
Let mutable ps be "is".
Repeat for p in parts:
Inspect p:
When CLiteralPart (litVal):
Set ps to "{ps}_lt{litVal}".
When CExprPart (epExpr):
Let pp be exprToKeyPartB(epExpr).
Set ps to "{ps}_{pp}".
Return ps.
When CDuration (amount, unit):
Let ap be exprToKeyPartB(amount).
Return "dur_{ap}_{unit}".
When CTimeNow:
Return "tnow".
When CDateToday:
Return "today".
When CEscExpr (code):
Return "esc".
Otherwise:
Return "unk".
## To makeKeyB (fnName: Text) and (args: Seq of CExpr) -> Text:
Let key be fnName.
Repeat for a in args:
Let part be exprToKeyPartB(a).
Set key to "{key}_{part}".
Return key.
## To exprEmbedsB (prevExpr: CExpr) and (nextExpr: CExpr) -> Bool:
Inspect prevExpr:
When CInt (a):
Inspect nextExpr:
When CInt (b):
Let mutable absA be a.
If a is less than 0:
Set absA to 0 - a.
Let mutable absB be b.
If b is less than 0:
Set absB to 0 - b.
Return (absA is at most absB).
Otherwise:
Return false.
When CBool (a):
Inspect nextExpr:
When CBool (b):
Return true.
Otherwise:
Return false.
When CText (a):
Inspect nextExpr:
When CText (b):
Return (length of a is at most length of b).
Otherwise:
Return false.
When CFloat (a):
Inspect nextExpr:
When CFloat (b):
Return true.
Otherwise:
Return false.
When CVar (a):
Inspect nextExpr:
When CVar (b):
Return true.
Otherwise:
Return false.
When CBinOp (op1, l1, r1):
Inspect nextExpr:
When CBinOp (op2, l2, r2):
If op1 equals op2:
Return (exprEmbedsB(l1, l2) and exprEmbedsB(r1, r2)).
Return false.
Otherwise:
Return false.
When CCall (fn1, args1):
Inspect nextExpr:
When CCall (fn2, args2):
If fn1 equals fn2:
Let len1 be length of args1.
Let len2 be length of args2.
If len1 equals len2:
Let mutable allEmbed be true.
Let mutable eidx be 1.
Repeat for a1 in args1:
If eidx is at most len2:
Let a2 be item eidx of args2.
If not exprEmbedsB(a1, a2):
Set allEmbed to false.
Set eidx to eidx + 1.
Return allEmbed.
Return false.
Otherwise:
Return false.
When CList (items1):
Inspect nextExpr:
When CList (items2):
Let li1 be length of items1.
Let li2 be length of items2.
If li1 is at most li2:
Return true.
Return false.
Otherwise:
Return false.
Otherwise:
Return false.
## To argsStrictlyEmbedB (prevExpr: Seq of CExpr) and (nextExpr: Seq of CExpr) -> Bool:
Let lenE be length of prevExpr.
Let lenL be length of nextExpr.
If not (lenE equals lenL):
Return false.
Let mutable allEmbed be true.
Let mutable someStrict be false.
Let mutable aidx be 1.
Repeat for ea in prevExpr:
If aidx is at most lenL:
Let la be item aidx of nextExpr.
If not exprEmbedsB(ea, la):
Set allEmbed to false.
If not exprEmbedsB(la, ea):
Set someStrict to true.
Set aidx to aidx + 1.
Return (allEmbed and someStrict).
## To makeCycleKeyB (fnName: Text) and (args: Seq of CExpr) -> Text:
Let key be fnName.
Repeat for a in args:
If checkStatic(a):
Let part be exprToKeyPartB(a).
Set key to "{key}_{part}".
Otherwise:
Set key to "{key}_d".
Return key.
## To peExprB (e: CExpr) and (state: PEState) -> CExpr:
Let env be peEnvB(state).
Let funcs be peFuncsB(state).
Let depth be peDepthB(state).
Inspect e:
When CInt (v):
Return a new CInt with value v.
When CBool (v):
Return a new CBool with value v.
When CText (v):
Return a new CText with value v.
When CVar (varName):
Let sEnv be peStaticEnvB(state).
Let svn be "{varName}".
If sEnv contains svn:
Let staticVal be item svn of sEnv.
Return staticVal.
Let vn be "{varName}".
If env contains vn:
Let val be item vn of env.
Let dyn be checkVNothing(val).
If dyn:
Return a new CVar with name varName.
Return valToExprB(val).
Return a new CVar with name varName.
When CBinOp (binOp, left, right):
Let peLeft be peExprB(left, state).
Let peRight be peExprB(right, state).
Let leftLit be checkLiteral(peLeft).
Let rightLit be checkLiteral(peRight).
If leftLit and rightLit:
Let lv be exprToValB(peLeft).
Let rv be exprToValB(peRight).
Let computed be evalBinOpB(binOp, lv, rv).
Return valToExprB(computed).
Return a new CBinOp with op binOp and left peLeft and right peRight.
When CNot (inner):
Let peInner be peExprB(inner, state).
Let innerLit be checkLiteral(peInner).
If innerLit:
Inspect peInner:
When CBool (b):
Return a new CBool with value (not b).
Otherwise:
Return a new CNot with inner peInner.
Return a new CNot with inner peInner.
When CCall (fnName, argExprs):
If depth equals 0:
Let residArgs be a new Seq of CExpr.
Repeat for a in argExprs:
Push peExprB(a, peStateWithDepthB(state, 0)) to residArgs.
Return a new CCall with name fnName and args residArgs.
Let fn1 be "{fnName}".
Let peArgs be a new Seq of CExpr.
Repeat for a in argExprs:
Push peExprB(a, state) to peArgs.
Let allStat be checkAllStatic(peArgs).
If allStat:
Let memoKey be makeKeyB(fn1, peArgs).
Let memoKeyStr be "{memoKey}".
Let specRes be peMemoCache(state).
Let mk0 be "{memoKeyStr}".
If specRes contains mk0:
Let cached be item mk0 of specRes.
Return cached.
Let memoCache be peCallGuard(state).
Let mk1 be "{memoKeyStr}".
If memoCache contains mk1:
Return a new CCall with name fn1 and args peArgs.
Let embedKey be "__embed_{fn1}".
Let embedKeyStr be "{embedKey}".
If specRes contains embedKeyStr:
Let prevArgsList be item embedKeyStr of specRes.
Inspect prevArgsList:
When CList (prevSnapshots):
Repeat for prevSnapshot in prevSnapshots:
Inspect prevSnapshot:
When CList (prevArgs):
If argsStrictlyEmbedB(prevArgs, peArgs):
Return a new CCall with name fn1 and args peArgs.
Otherwise:
Let skipSnap be true.
Otherwise:
Let skipPrev be true.
Let embedKeyStr2 be "{embedKey}".
Let mutable newSnapshots be a new Seq of CExpr.
If specRes contains embedKeyStr2:
Let existingList be item embedKeyStr2 of specRes.
Inspect existingList:
When CList (existingSnaps):
Repeat for es in existingSnaps:
Push es to newSnapshots.
Otherwise:
Let skipExist be true.
Let peArgsCopy be copy of peArgs.
Push (a new CList with items peArgsCopy) to newSnapshots.
Let embedKeyStr3 be "{embedKey}".
Set item embedKeyStr3 of specRes to (a new CList with items newSnapshots).
Let fn2 be "{fn1}".
Let func be item fn2 of funcs.
Inspect func:
When CFuncDef (fname, params, fnParamTypes, fnReturnType, body):
Let callEnv be a new Map of Text to CVal.
Let childSEnv be a new Map of Text to CExpr.
Let mutable pidx be 1.
Repeat for p in params:
Let argExpr be item pidx of peArgs.
Let argVal be exprToValB(argExpr).
Let pk1 be "{p}".
Set item pk1 of callEnv to argVal.
Let cpSafeArg be checkCopyPropSafe(argExpr).
If cpSafeArg:
Let pk2 be "{p}".
Set item pk2 of childSEnv to (copy of argExpr).
Set pidx to pidx + 1.
Let childState be peStateWithEnvDepthStaticB(state, callEnv, depth - 1, childSEnv).
Let mk2 be "{memoKeyStr}".
Let childStack be peCallGuard(childState).
Push mk2 to childStack.
Let peBody be peBlockB(body, childState).
Let rawResultB be extractReturnB(peBody).
Let bodyResult be validateExtractReturnB(rawResultB, peBody).
Inspect bodyResult:
When CVar (brName2):
If brName2 equals "__no_return__":
Return a new CCall with name fn1 and args peArgs.
Otherwise:
Let skip be true.
Let mk3 be "{memoKeyStr}".
Let bodyResultCopy be copy of bodyResult.
Set item mk3 of specRes to bodyResultCopy.
Return bodyResult.
Otherwise:
Let fn3 be "{fn1}".
Return a new CCall with name fn3 and args peArgs.
Let mutable hasSomeStatic be false.
Let mutable hasSomeDynamic be false.
Repeat for pa in peArgs:
If checkStatic(pa):
Set hasSomeStatic to true.
Otherwise:
Set hasSomeDynamic to true.
If hasSomeStatic and hasSomeDynamic:
Let specKey be makeCycleKeyB(fn1, peArgs).
Let specKeyStr be "{specKey}".
Let specCache be peCallGuard(state).
Let sk1 be "{specKeyStr}".
If specCache contains sk1:
Let dynArgs be a new Seq of CExpr.
Repeat for pa in peArgs:
If not checkStatic(pa):
Push pa to dynArgs.
Let sk2 be "{specKeyStr}".
Return a new CCall with name sk2 and args dynArgs.
Let fn4 be "{fn1}".
Let func2 be item fn4 of funcs.
Inspect func2:
When CFuncDef (fname, params, fnParamTypes, fnReturnType, body):
Let callEnv be a new Map of Text to CVal.
Let childSEnv be a new Map of Text to CExpr.
Let dynParams be a new Seq of Text.
Let mutable pidx be 1.
Repeat for p in params:
Let argExpr be item pidx of peArgs.
If checkStatic(argExpr):
Let argVal be exprToValB(argExpr).
Let pk1 be "{p}".
Set item pk1 of callEnv to argVal.
Let pk2 be "{p}".
Let argExprCopy be copy of argExpr.
Set item pk2 of childSEnv to argExprCopy.
Otherwise:
Let pk3 be "{p}".
Push pk3 to dynParams.
Let pk4 be "{p}".
Set item pk4 of callEnv to a new VNothing.
Set pidx to pidx + 1.
Let sk3 be "{specKeyStr}".
Push sk3 to specCache.
Let placeholderBody be a new Seq of CStmt.
Let sk4 be "{specKeyStr}".
Let phDynParams be a new Seq of Text.
Repeat for dp in dynParams:
Let dpCopy be "{dp}".
Push dpCopy to phDynParams.
Let phPT be a new Seq of Text.
Let placeholderFunc be a new CFuncDef with name sk4 and params phDynParams and paramTypes phPT and returnType "Any" and body placeholderBody.
Let sk5 be "{specKeyStr}".
Set item sk5 of funcs to placeholderFunc.
Let childState be peStateWithEnvDepthStaticB(state, callEnv, depth - 1, childSEnv).
Let peBody be peBlockB(body, childState).
Let rawResultB2 be extractReturnB(peBody).
Let bodyResult be validateExtractReturnB(rawResultB2, peBody).
Let sk6 be "{specKeyStr}".
Let spDynParams be a new Seq of Text.
Repeat for dp in dynParams:
Let dpCopy be "{dp}".
Push dpCopy to spDynParams.
Let spPT be a new Seq of Text.
Let specFunc be a new CFuncDef with name sk6 and params spDynParams and paramTypes spPT and returnType "Any" and body peBody.
Let sk7 be "{specKeyStr}".
Set item sk7 of funcs to specFunc.
Inspect bodyResult:
When CVar (brName):
If brName equals "__no_return__":
Let fallbackDynArgs be a new Seq of CExpr.
Repeat for pa in peArgs:
If not checkStatic(pa):
Push pa to fallbackDynArgs.
Let sk8 be "{specKeyStr}".
Return a new CCall with name sk8 and args fallbackDynArgs.
Otherwise:
Let skip be true.
Return bodyResult.
Otherwise:
Let fn5 be "{fn1}".
Return a new CCall with name fn5 and args peArgs.
Return a new CCall with name fn1 and args peArgs.
When CIndex (collExpr, idxExpr):
Let peColl be peExprB(collExpr, state).
Let peIdx be peExprB(idxExpr, state).
Inspect peColl:
When CList (listItems):
Inspect peIdx:
When CInt (idxVal):
If idxVal is greater than 0:
If idxVal is at most length of listItems:
Return item idxVal of listItems.
Otherwise:
Let skip be true.
Otherwise:
Let skip be true.
Return a new CIndex with coll peColl and idx peIdx.
When CLen (lenTarget):
Let peTarget be peExprB(lenTarget, state).
Inspect peTarget:
When CList (listItems):
Return a new CInt with value (length of listItems).
When CTuple (tupleItems):
Return a new CInt with value (length of tupleItems).
Otherwise:
Let skip be true.
Return a new CLen with target peTarget.
When CMapGet (mapTarget, mapKey):
Let peTarget be peExprB(mapTarget, state).
Let peKey be peExprB(mapKey, state).
Inspect peTarget:
When CNewVariant (nvTag, nvNames, nvVals):
Inspect peKey:
When CText (keyStr):
If keyStr equals "__tag":
Return a new CText with value nvTag.
Let mutable fidx be 1.
Repeat for fname in nvNames:
If fname equals keyStr:
Return item fidx of nvVals.
Set fidx to fidx + 1.
Otherwise:
Let skip be true.
When CNew (cnTypeName, cnFieldNames, cnFieldVals):
Inspect peKey:
When CText (keyStr):
If keyStr equals "__tag":
Return a new CText with value cnTypeName.
Let mutable fidx2 be 1.
Repeat for fn2 in cnFieldNames:
If fn2 equals keyStr:
Return item fidx2 of cnFieldVals.
Set fidx2 to fidx2 + 1.
Otherwise:
Let skip be true.
Otherwise:
Let skip be true.
Return a new CMapGet with target peTarget and key peKey.
When CNewSeq:
Return a new CNewSeq.
When CNewVariant (nvTag, nvNames, nvVals):
Let peVals be a new Seq of CExpr.
Repeat for v in nvVals:
Push peExprB(v, state) to peVals.
Return a new CNewVariant with tag nvTag and fnames nvNames and fvals peVals.
When CFloat (fv):
Return a new CFloat with value fv.
When CList (listItems):
Let peItems be a new Seq of CExpr.
Repeat for li in listItems:
Push peExprB(li, state) to peItems.
Return a new CList with items peItems.
When CRange (rangeStart, rangeEnd):
Let peStart be peExprB(rangeStart, state).
Let peEnd be peExprB(rangeEnd, state).
Return a new CRange with start peStart and end peEnd.
When CSlice (sliceColl, sliceStart, sliceEnd):
Let peColl be peExprB(sliceColl, state).
Let peStart be peExprB(sliceStart, state).
Let peEnd be peExprB(sliceEnd, state).
Return a new CSlice with coll peColl and startIdx peStart and endIdx peEnd.
When CCopy (copyTarget):
Let peTarget be peExprB(copyTarget, state).
Return a new CCopy with target peTarget.
When CNewSet:
Return a new CNewSet.
When CContains (containsColl, containsElem):
Let peColl be peExprB(containsColl, state).
Let peElem be peExprB(containsElem, state).
Inspect peColl:
When CNew (cnTypeName, cnFieldNames, cnFields):
If length of cnFields equals 0:
Return a new CBool with value false.
When CNewSeq:
Return a new CBool with value false.
When CNewSet:
Return a new CBool with value false.
When CList (litems):
If length of litems equals 0:
Return a new CBool with value false.
Otherwise:
Let skipContains be true.
Return a new CContains with coll peColl and elem peElem.
When CUnion (unionLeft, unionRight):
Let peLeft be peExprB(unionLeft, state).
Let peRight be peExprB(unionRight, state).
Return a new CUnion with left peLeft and right peRight.
When CIntersection (interLeft, interRight):
Let peLeft be peExprB(interLeft, state).
Let peRight be peExprB(interRight, state).
Return a new CIntersection with left peLeft and right peRight.
When COptionSome (optInner):
Let peInner be peExprB(optInner, state).
Return a new COptionSome with inner peInner.
When COptionNone:
Return a new COptionNone.
When CTuple (tupleItems):
Let peItems be a new Seq of CExpr.
Repeat for ti in tupleItems:
Push peExprB(ti, state) to peItems.
Return a new CTuple with items peItems.
When CNew (newTypeName, newFieldNames, newFieldExprs):
Let peNewFields be a new Seq of CExpr.
Repeat for nfe in newFieldExprs:
Push peExprB(nfe, state) to peNewFields.
Return a new CNew with typeName newTypeName and fieldNames newFieldNames and fields peNewFields.
When CFieldAccess (faTarget, faField):
Let peFaTarget be peExprB(faTarget, state).
Inspect peFaTarget:
When CNewVariant (nvTag, nvNames, nvVals):
Let mutable fidx be 1.
Repeat for fname in nvNames:
If fname equals faField:
Return item fidx of nvVals.
Set fidx to fidx + 1.
When CNew (nType, nNames, nVals):
Let mutable fidx be 1.
Repeat for fname in nNames:
If fname equals faField:
Return item fidx of nVals.
Set fidx to fidx + 1.
Otherwise:
Let skip be true.
Return a new CFieldAccess with target peFaTarget and field faField.
When CClosure (clParams, clBody, clCaptured):
Let peClBody be peBlockB(clBody, state).
Return a new CClosure with params clParams and body peClBody and captured clCaptured.
When CCallExpr (ceTarget, ceArgs):
Let peCeTarget be peExprB(ceTarget, state).
Let peCeArgs be a new Seq of CExpr.
Repeat for ceArg in ceArgs:
Push peExprB(ceArg, state) to peCeArgs.
Return a new CCallExpr with target peCeTarget and args peCeArgs.
When CInterpolatedString (isParts):
Let peIsParts be a new Seq of CStringPart.
Repeat for isPart in isParts:
Inspect isPart:
When CLiteralPart (litVal):
Push a new CLiteralPart with value litVal to peIsParts.
When CExprPart (epExpr):
Let peEpExpr be peExprB(epExpr, state).
Push a new CExprPart with expr peEpExpr to peIsParts.
Return a new CInterpolatedString with parts peIsParts.
When CDuration (durAmount, durUnit):
Let peDurAmount be peExprB(durAmount, state).
Return a new CDuration with amount peDurAmount and unit durUnit.
When CTimeNow:
Return a new CTimeNow.
When CDateToday:
Return a new CDateToday.
When CEscExpr (escCode):
Return a new CEscExpr with code escCode.
## To collectSetVarsB (stmts: Seq of CStmt) -> Seq of Text:
Let result be a new Seq of Text.
Repeat for s in stmts:
Inspect s:
When CSet (setName, setExpr):
Push setName to result.
When CIf (ifCond, ifThen, ifElse):
Let thenVars be collectSetVarsB(ifThen).
Repeat for tv in thenVars:
Push tv to result.
Let elseVars be collectSetVarsB(ifElse).
Repeat for ev in elseVars:
Push ev to result.
When CWhile (wCond, wBody):
Let wVars be collectSetVarsB(wBody).
Repeat for wv in wVars:
Push wv to result.
When CRepeat (rVar, rColl, rBody):
Let rVars be collectSetVarsB(rBody).
Repeat for rv in rVars:
Push rv to result.
Otherwise:
Let skip be true.
Return result.
## To isDeadTargetB (targetName: Text) and (env: Map of Text to CVal) -> Bool:
Let tk be "{targetName}".
If env contains tk:
Let tv be item tk of env.
Let tvn be checkVNothing(tv).
If tvn:
Return false.
Return true.
Return false.
## To peBlockB (stmts: Seq of CStmt) and (state: PEState) -> Seq of CStmt:
Let env be peEnvB(state).
Let funcs be peFuncsB(state).
Let depth be peDepthB(state).
Let blockResult be a new Seq of CStmt.
Repeat for s in stmts:
Let alreadyReturned be hasReturnB(blockResult).
If alreadyReturned:
Return blockResult.
Inspect s:
When CLet (letName, letExpr):
Let peVal be peExprB(letExpr, state).
Let valLit be checkLiteral(peVal).
Let cpSafe be checkCopyPropSafe(peVal).
If cpSafe:
Let letNameS be "{letName}".
Let peValS be copy of peVal.
Let sEnvL be peStaticEnvB(state).
Set item letNameS of sEnvL to peValS.
Otherwise:
Let sEnvL2 be peStaticEnvB(state).
Let letNameR be "{letName}".
If sEnvL2 contains letNameR:
Remove letNameR from sEnvL2.
If valLit:
Set item letName of env to exprToValB(peVal).
Otherwise:
Let letKey be "{letName}".
Set item letKey of env to a new VNothing.
Push (a new CLet with name letName and expr peVal) to blockResult.
When CSet (setName, setExpr):
Let peVal be peExprB(setExpr, state).
Let valLit be checkLiteral(peVal).
Let cpSafeS be checkCopyPropSafe(peVal).
If cpSafeS:
Let setNameS be "{setName}".
Let peValS be copy of peVal.
Let sEnvS be peStaticEnvB(state).
Set item setNameS of sEnvS to peValS.
Otherwise:
Let sEnvS2 be peStaticEnvB(state).
Let setNameR be "{setName}".
If sEnvS2 contains setNameR:
Remove setNameR from sEnvS2.
If valLit:
Set item setName of env to exprToValB(peVal).
Otherwise:
Let setKey be "{setName}".
Set item setKey of env to a new VNothing.
Push (a new CSet with name setName and expr peVal) to blockResult.
When CIf (ifCond, thenBlock, elseBlock):
Let peCond be peExprB(ifCond, state).
Let condLit be checkLiteral(peCond).
If condLit:
Inspect peCond:
When CBool (b):
If b:
Let thenRes be peBlockB(thenBlock, state).
Repeat for ts in thenRes:
Push ts to blockResult.
Otherwise:
Let elseRes be peBlockB(elseBlock, state).
Repeat for es in elseRes:
Push es to blockResult.
Otherwise:
Let thenRes2 be peBlockB(thenBlock, state).
Let elseRes2 be peBlockB(elseBlock, state).
Push (a new CIf with cond peCond and thenBlock thenRes2 and elseBlock elseRes2) to blockResult.
Otherwise:
Let thenRes3 be peBlockB(thenBlock, state).
Let elseRes3 be peBlockB(elseBlock, state).
Push (a new CIf with cond peCond and thenBlock thenRes3 and elseBlock elseRes3) to blockResult.
When CWhile (whileCond, whileBody):
Let modVars be collectSetVarsB(whileBody).
Let sEnvW be peStaticEnvB(state).
Repeat for mv in modVars:
Let mvK1 be "{mv}".
If sEnvW contains mvK1:
Let mvK2 be "{mv}".
Let prevVal be item mvK2 of sEnvW.
Let mvK3 be "{mv}".
Push (a new CLet with name mvK3 and expr prevVal) to blockResult.
Let mvK4 be "{mv}".
Remove mvK4 from sEnvW.
Let mvK5 be "{mv}".
Set item mvK5 of env to a new VNothing.
Let peCond be peExprB(whileCond, state).
Let condLit be checkLiteral(peCond).
If condLit:
Inspect peCond:
When CBool (b):
If not b:
Let skip be true.
Otherwise:
Let peBody be peBlockB(whileBody, state).
Let sEnvPost1 be peStaticEnvB(state).
Repeat for mv1 in modVars:
Let mv1K be "{mv1}".
If sEnvPost1 contains mv1K:
Let mv1K2 be "{mv1}".
Remove mv1K2 from sEnvPost1.
Let mv1K3 be "{mv1}".
Set item mv1K3 of env to a new VNothing.
Push (a new CWhile with cond peCond and body peBody) to blockResult.
Otherwise:
Let peBody2 be peBlockB(whileBody, state).
Let sEnvPost2 be peStaticEnvB(state).
Repeat for mv2 in modVars:
Let mv2K be "{mv2}".
If sEnvPost2 contains mv2K:
Let mv2K2 be "{mv2}".
Remove mv2K2 from sEnvPost2.
Let mv2K3 be "{mv2}".
Set item mv2K3 of env to a new VNothing.
Push (a new CWhile with cond peCond and body peBody2) to blockResult.
Otherwise:
Let peBody3 be peBlockB(whileBody, state).
Let sEnvPost3 be peStaticEnvB(state).
Repeat for mv3 in modVars:
Let mv3K be "{mv3}".
If sEnvPost3 contains mv3K:
Let mv3K2 be "{mv3}".
Remove mv3K2 from sEnvPost3.
Let mv3K3 be "{mv3}".
Set item mv3K3 of env to a new VNothing.
Push (a new CWhile with cond peCond and body peBody3) to blockResult.
When CReturn (retExpr):
Let peVal be peExprB(retExpr, state).
Push (a new CReturn with expr peVal) to blockResult.
When CShow (showExpr):
Let peVal be peExprB(showExpr, state).
Push (a new CShow with expr peVal) to blockResult.
When CCallS (callName, callArgs):
Let peArgs be a new Seq of CExpr.
Repeat for a in callArgs:
Push peExprB(a, state) to peArgs.
Push (a new CCallS with name callName and args peArgs) to blockResult.
When CPush (pushExpr, pushTarget):
Let sEnvPush be peStaticEnvB(state).
Let ptk1 be "{pushTarget}".
If sEnvPush contains ptk1:
Let ptk2 be "{pushTarget}".
Let ptPrev be item ptk2 of sEnvPush.
Let ptk3 be "{pushTarget}".
Push (a new CLet with name ptk3 and expr ptPrev) to blockResult.
Let ptk4 be "{pushTarget}".
Remove ptk4 from sEnvPush.
Let ptk5 be "{pushTarget}".
Set item ptk5 of env to a new VNothing.
Let peVal be peExprB(pushExpr, state).
Push (a new CPush with expr peVal and target pushTarget) to blockResult.
When CSetIdx (siTarget, siIdx, siVal):
Let sEnvSI be peStaticEnvB(state).
Let sik1 be "{siTarget}".
If sEnvSI contains sik1:
Let sik2 be "{siTarget}".
Let siPrev be item sik2 of sEnvSI.
Let sik3 be "{siTarget}".
Push (a new CLet with name sik3 and expr siPrev) to blockResult.
Let sik4 be "{siTarget}".
Remove sik4 from sEnvSI.
Let sik5 be "{siTarget}".
Set item sik5 of env to a new VNothing.
Let peIdx be peExprB(siIdx, state).
Let peVal be peExprB(siVal, state).
Push (a new CSetIdx with target siTarget and idx peIdx and val peVal) to blockResult.
When CMapSet (msTarget, msKey, msVal):
Let sEnvMS be peStaticEnvB(state).
Let msk1 be "{msTarget}".
If sEnvMS contains msk1:
Let msk2 be "{msTarget}".
Let msPrev be item msk2 of sEnvMS.
Let msk3 be "{msTarget}".
Push (a new CLet with name msk3 and expr msPrev) to blockResult.
Let msk4 be "{msTarget}".
Remove msk4 from sEnvMS.
Let msk5 be "{msTarget}".
Set item msk5 of env to a new VNothing.
Let peKey be peExprB(msKey, state).
Let peVal be peExprB(msVal, state).
Push (a new CMapSet with target msTarget and key peKey and val peVal) to blockResult.
When CPop (popTarget):
Let sEnvPop be peStaticEnvB(state).
Let ppk1 be "{popTarget}".
If sEnvPop contains ppk1:
Let ppk2 be "{popTarget}".
Let ppPrev be item ppk2 of sEnvPop.
Let ppk3 be "{popTarget}".
Push (a new CLet with name ppk3 and expr ppPrev) to blockResult.
Let ppk4 be "{popTarget}".
Remove ppk4 from sEnvPop.
Let ppk5 be "{popTarget}".
Set item ppk5 of env to a new VNothing.
Push (a new CPop with target popTarget) to blockResult.
When CRepeat (repVar, repColl, repBody):
Let peColl be peExprB(repColl, state).
Let collStatic be checkStatic(peColl).
Let mutable didUnroll be false.
If collStatic:
Inspect peColl:
When CList (listItems):
Set didUnroll to true.
Repeat for listItem in listItems:
Let rv be "{repVar}".
Set item rv of env to exprToValB(listItem).
Let rv2 be "{repVar}".
Let sEnvR be peStaticEnvB(state).
Set item rv2 of sEnvR to listItem.
Let unrolledBody be peBlockB(repBody, state).
Let mutable hasBreakOrReturn be false.
Repeat for us in unrolledBody:
Inspect us:
When CBreak:
Set hasBreakOrReturn to true.
When CReturn (retExpr):
Set hasBreakOrReturn to true.
Otherwise:
Let skip be true.
Repeat for us in unrolledBody:
Push us to blockResult.
If hasBreakOrReturn:
Return blockResult.
Otherwise:
Let skip be true.
If not didUnroll:
Let repModVars be collectSetVarsB(repBody).
Let sEnvF be peStaticEnvB(state).
Repeat for rmv in repModVars:
Let rmvK1 be "{rmv}".
If sEnvF contains rmvK1:
Let rmvK2 be "{rmv}".
Let rmvPrev be item rmvK2 of sEnvF.
Let rmvK3 be "{rmv}".
Push (a new CLet with name rmvK3 and expr rmvPrev) to blockResult.
Let rmvK4 be "{rmv}".
Remove rmvK4 from sEnvF.
Let rmvK5 be "{rmv}".
Set item rmvK5 of env to a new VNothing.
If sEnvF contains repVar:
Remove repVar from sEnvF.
Let repVarEnvKey be "{repVar}".
Set item repVarEnvKey of env to a new VNothing.
Let peBody be peBlockB(repBody, state).
Push (a new CRepeat with var repVar and coll peColl and body peBody) to blockResult.
When CRepeatRange (rrVar, rrStart, rrEnd, rrBody):
Let peStart be peExprB(rrStart, state).
Let peEnd be peExprB(rrEnd, state).
Let startStatic be checkStatic(peStart).
Let endStatic be checkStatic(peEnd).
If startStatic and endStatic:
Inspect peStart:
When CInt (startVal):
Inspect peEnd:
When CInt (endVal):
Let rangeSize be endVal - startVal.
If rangeSize is less than 64:
Let mutable ri be startVal.
While ri is at most endVal:
Let rrKey be "{rrVar}".
Set item rrKey of env to a new VInt with value ri.
Let rrValExpr be a new CInt with value ri.
Let rrKey2 be "{rrVar}".
Let sEnvRR be peStaticEnvB(state).
Set item rrKey2 of sEnvRR to rrValExpr.
Let unrolledBody be peBlockB(rrBody, state).
Repeat for us in unrolledBody:
Push us to blockResult.
Set ri to ri + 1.
Return blockResult.
Otherwise:
Let skip be true.
Otherwise:
Let skip be true.
Let rrModVars be collectSetVarsB(rrBody).
Let sEnvRR2 be peStaticEnvB(state).
Repeat for rrmv in rrModVars:
Let rrmvK1 be "{rrmv}".
If sEnvRR2 contains rrmvK1:
Let rrmvK2 be "{rrmv}".
Let rrmvPrev be item rrmvK2 of sEnvRR2.
Let rrmvK3 be "{rrmv}".
Push (a new CLet with name rrmvK3 and expr rrmvPrev) to blockResult.
Let rrmvK4 be "{rrmv}".
Remove rrmvK4 from sEnvRR2.
Let rrmvK5 be "{rrmv}".
Set item rrmvK5 of env to a new VNothing.
Let peBody be peBlockB(rrBody, state).
Push (a new CRepeatRange with var rrVar and start peStart and end peEnd and body peBody) to blockResult.
When CBreak:
Push a new CBreak to blockResult.
When CAdd (addElem, addTarget):
Let sEnvAdd be peStaticEnvB(state).
Let adk1 be "{addTarget}".
If sEnvAdd contains adk1:
Let adk2 be "{addTarget}".
Let adPrev be item adk2 of sEnvAdd.
Let adk3 be "{addTarget}".
Push (a new CLet with name adk3 and expr adPrev) to blockResult.
Let adk4 be "{addTarget}".
Remove adk4 from sEnvAdd.
Let adk5 be "{addTarget}".
Set item adk5 of env to a new VNothing.
Let peVal be peExprB(addElem, state).
Push (a new CAdd with elem peVal and target addTarget) to blockResult.
When CRemove (remElem, remTarget):
Let sEnvRem be peStaticEnvB(state).
Let rmk1 be "{remTarget}".
If sEnvRem contains rmk1:
Let rmk2 be "{remTarget}".
Let rmPrev be item rmk2 of sEnvRem.
Let rmk3 be "{remTarget}".
Push (a new CLet with name rmk3 and expr rmPrev) to blockResult.
Let rmk4 be "{remTarget}".
Remove rmk4 from sEnvRem.
Let rmk5 be "{remTarget}".
Set item rmk5 of env to a new VNothing.
Let peVal be peExprB(remElem, state).
Push (a new CRemove with elem peVal and target remTarget) to blockResult.
When CSetField (sfTarget, sfField, sfValExpr):
Let sEnvSF be peStaticEnvB(state).
Let sfk1 be "{sfTarget}".
If sEnvSF contains sfk1:
Let sfk2 be "{sfTarget}".
Let sfPrev be item sfk2 of sEnvSF.
Let sfk3 be "{sfTarget}".
Push (a new CLet with name sfk3 and expr sfPrev) to blockResult.
Let sfk4 be "{sfTarget}".
Remove sfk4 from sEnvSF.
Let sfk5 be "{sfTarget}".
Set item sfk5 of env to a new VNothing.
Let peVal be peExprB(sfValExpr, state).
Push (a new CSetField with target sfTarget and field sfField and val peVal) to blockResult.
When CStructDef (sdName, sdFieldNames):
Push (a new CStructDef with name sdName and fieldNames sdFieldNames) to blockResult.
When CEnumDef (edName, edVariants):
Push (a new CEnumDef with name edName and variants edVariants) to blockResult.
When CInspect (inspTarget, inspArms):
Let peTarget be peExprB(inspTarget, state).
Let targetStatic be checkStatic(peTarget).
If targetStatic:
Inspect peTarget:
When CNewVariant (nvTag, nvNames, nvVals):
Repeat for arm in inspArms:
Inspect arm:
When CWhen (wName, wBindings, wBody):
If wName equals nvTag:
Let mutable bidx be 1.
Repeat for b in wBindings:
Let bval be item bidx of nvVals.
Let b2 be "{b}".
Let bvalCopy be copy of bval.
Let sEnvI be peStaticEnvB(state).
Set item b2 of sEnvI to bvalCopy.
Set item b of env to exprToValB(bval).
Set bidx to bidx + 1.
Let matchedBody be peBlockB(wBody, state).
Repeat for ms in matchedBody:
Push ms to blockResult.
Return blockResult.
Otherwise:
Let skip be true.
Repeat for arm in inspArms:
Inspect arm:
When COtherwise (oBody):
Let otherwiseBody be peBlockB(oBody, state).
Repeat for os in otherwiseBody:
Push os to blockResult.
Return blockResult.
Otherwise:
Let skip be true.
When CNew (cnTypeName, cnFieldNames, cnFieldVals):
Repeat for arm in inspArms:
Inspect arm:
When CWhen (wName, wBindings, wBody):
If wName equals cnTypeName:
Let mutable bidx be 1.
Repeat for b in wBindings:
Let bval be item bidx of cnFieldVals.
Let b2 be "{b}".
Let bvalCopy be copy of bval.
Let sEnvI be peStaticEnvB(state).
Set item b2 of sEnvI to bvalCopy.
Set item b of env to exprToValB(bval).
Set bidx to bidx + 1.
Let matchedBody be peBlockB(wBody, state).
Repeat for ms in matchedBody:
Push ms to blockResult.
Return blockResult.
Otherwise:
Let skip be true.
Repeat for arm in inspArms:
Inspect arm:
When COtherwise (oBody):
Let otherwiseBody be peBlockB(oBody, state).
Repeat for os in otherwiseBody:
Push os to blockResult.
Return blockResult.
Otherwise:
Let skip be true.
Otherwise:
Let skip be true.
Let peArms be a new Seq of CMatchArm.
Repeat for arm in inspArms:
Inspect arm:
When CWhen (wName, wBindings, wBody):
Let peBody be peBlockB(wBody, state).
Push (a new CWhen with variantName wName and bindings wBindings and body peBody) to peArms.
When COtherwise (oBody):
Let peBody be peBlockB(oBody, state).
Push (a new COtherwise with body peBody) to peArms.
Push (a new CInspect with target peTarget and arms peArms) to blockResult.
When CRuntimeAssert (raCond, raMsg):
Let peRaCond be peExprB(raCond, state).
Let peRaMsg be peExprB(raMsg, state).
Push (a new CRuntimeAssert with cond peRaCond and msg peRaMsg) to blockResult.
When CGive (giveExpr, giveTarget):
Let peGiveExpr be peExprB(giveExpr, state).
Push (a new CGive with expr peGiveExpr and target giveTarget) to blockResult.
When CEscStmt (escCode):
Push (a new CEscStmt with code escCode) to blockResult.
When CSleep (sleepDur):
Let peSleepDur be peExprB(sleepDur, state).
Push (a new CSleep with duration peSleepDur) to blockResult.
When CReadConsole (rcTarget):
Push (a new CReadConsole with target rcTarget) to blockResult.
When CReadFile (rfPath, rfTarget):
Let peRfPath be peExprB(rfPath, state).
Push (a new CReadFile with path peRfPath and target rfTarget) to blockResult.
When CWriteFile (wfPath, wfContent):
Let peWfPath be peExprB(wfPath, state).
Let peWfContent be peExprB(wfContent, state).
Push (a new CWriteFile with path peWfPath and content peWfContent) to blockResult.
When CCheck (chkPred, chkMsg):
Let peChkPred be peExprB(chkPred, state).
Let peChkMsg be peExprB(chkMsg, state).
Push (a new CCheck with predicate peChkPred and msg peChkMsg) to blockResult.
When CAssert (assertProp):
Let peAssertProp be peExprB(assertProp, state).
Push (a new CAssert with proposition peAssertProp) to blockResult.
When CTrust (trustProp, trustJust):
Let peTrustProp be peExprB(trustProp, state).
Push (a new CTrust with proposition peTrustProp and justification trustJust) to blockResult.
When CRequire (reqDep):
Push (a new CRequire with dependency reqDep) to blockResult.
When CMerge (mergeTarget, mergeOther):
Let peMergeOther be peExprB(mergeOther, state).
Push (a new CMerge with target mergeTarget and other peMergeOther) to blockResult.
When CIncrease (incTarget, incAmount):
Let peIncAmount be peExprB(incAmount, state).
Push (a new CIncrease with target incTarget and amount peIncAmount) to blockResult.
When CDecrease (decTarget, decAmount):
Let peDecAmount be peExprB(decAmount, state).
Push (a new CDecrease with target decTarget and amount peDecAmount) to blockResult.
When CAppendToSeq (asTarget, asValue):
Let peAsValue be peExprB(asValue, state).
Push (a new CAppendToSeq with target asTarget and value peAsValue) to blockResult.
When CResolve (resTarget):
Push (a new CResolve with target resTarget) to blockResult.
When CSync (syncTarget, syncChannel):
Let peSyncChannel be peExprB(syncChannel, state).
Push (a new CSync with target syncTarget and channel peSyncChannel) to blockResult.
When CMount (mountTarget, mountPath):
Let peMountPath be peExprB(mountPath, state).
Push (a new CMount with target mountTarget and path peMountPath) to blockResult.
When CConcurrent (concBranches):
Let peConcBranches be a new Seq of Seq of CStmt.
Repeat for concBranch in concBranches:
Push peBlockB(concBranch, state) to peConcBranches.
Push (a new CConcurrent with branches peConcBranches) to blockResult.
When CParallel (parBranches):
Let peParBranches be a new Seq of Seq of CStmt.
Repeat for parBranch in parBranches:
Push peBlockB(parBranch, state) to peParBranches.
Push (a new CParallel with branches peParBranches) to blockResult.
When CLaunchTask (ltBody, ltHandle):
Let peLtBody be peBlockB(ltBody, state).
Push (a new CLaunchTask with body peLtBody and handle ltHandle) to blockResult.
When CStopTask (stHandle):
Let peStHandle be peExprB(stHandle, state).
Push (a new CStopTask with handle peStHandle) to blockResult.
When CSelect (selBranches):
Let peSelBranches be a new Seq of CSelectBranch.
Repeat for selBr in selBranches:
Inspect selBr:
When CSelectRecv (selChan, selVar, selBody):
Let peSelBody be peBlockB(selBody, state).
Push (a new CSelectRecv with chan selChan and var selVar and body peSelBody) to peSelBranches.
When CSelectTimeout (selDur, selBody):
Let peSelDur be peExprB(selDur, state).
Let peSelBody be peBlockB(selBody, state).
Push (a new CSelectTimeout with duration peSelDur and body peSelBody) to peSelBranches.
Push (a new CSelect with branches peSelBranches) to blockResult.
When CCreatePipe (cpName, cpCapacity):
Let peCpCapacity be peExprB(cpCapacity, state).
Push (a new CCreatePipe with name cpName and capacity peCpCapacity) to blockResult.
When CSendPipe (spPipe, spValue):
Let peSpValue be peExprB(spValue, state).
Push (a new CSendPipe with chan spPipe and value peSpValue) to blockResult.
When CReceivePipe (rpPipe, rpTarget):
Push (a new CReceivePipe with chan rpPipe and target rpTarget) to blockResult.
When CTrySendPipe (tspPipe, tspValue):
Let peTspValue be peExprB(tspValue, state).
Push (a new CTrySendPipe with chan tspPipe and value peTspValue) to blockResult.
When CTryReceivePipe (trpPipe, trpTarget):
Push (a new CTryReceivePipe with chan trpPipe and target trpTarget) to blockResult.
When CSpawn (spawnType, spawnTarget):
Push (a new CSpawn with agentType spawnType and target spawnTarget) to blockResult.
When CSendMessage (smTarget, smMsg):
Let peSmTarget be peExprB(smTarget, state).
Let peSmMsg be peExprB(smMsg, state).
Push (a new CSendMessage with target peSmTarget and msg peSmMsg) to blockResult.
When CAwaitMessage (amTarget):
Push (a new CAwaitMessage with target amTarget) to blockResult.
When CListen (listenAddr, listenHandler):
Let peListenAddr be peExprB(listenAddr, state).
Push (a new CListen with addr peListenAddr and handler listenHandler) to blockResult.
When CConnectTo (connAddr, connTarget):
Let peConnAddr be peExprB(connAddr, state).
Push (a new CConnectTo with addr peConnAddr and target connTarget) to blockResult.
When CZone (zoneName, zoneKind, zoneBody):
Let peZoneBody be peBlockB(zoneBody, state).
Push (a new CZone with name zoneName and kind zoneKind and body peZoneBody) to blockResult.
Otherwise:
Let skip be true.
Return blockResult.
## To validateExtractReturnB (result: CExpr) and (bodyStmts: Seq of CStmt) -> CExpr:
Inspect result:
When CVar (retName):
If retName equals "__no_return__":
Return result.
If retName equals "__unresolvable":
Return result.
Repeat for s in bodyStmts:
Inspect s:
When CLet (letName, letExpr):
If letName equals retName:
Return a new CVar with name "__no_return__".
Otherwise:
Let skip be true.
Return result.
Otherwise:
Return result.
## To extractReturnB (stmts: Seq of CStmt) -> CExpr:
Let mutable idx be length of stmts.
While idx is at least 1:
Let s be item idx of stmts.
Inspect s:
When CReturn (retExpr):
Return retExpr.
Otherwise:
Set idx to idx - 1.
Return a new CVar with name "__no_return__".