Compare Revisions

This comparison shows the changes necessary to convert path /trunk from Rev 25 to Rev 26 (Reverse comparison).
Path Comparison

Rev 25 ⟶ Rev 26

/src/parse/expression.sig
140,8 ⟶ 140,6
 
val varPos : var -> pos
 
val filter : (expr -> bool) -> expr -> expr list
 
val getFreeNames : expr -> AtomSet.set
val renameVar : {old : symbol, new: symbol} * expr -> expr
val renameVars : symbol AtomMap.map -> expr -> expr
/src/parse/environment.sig
212,5 ⟶ 212,14
val mapValues : (symbol * enventry -> 'a option) -> env -> 'a list
val mapTypes : (symbol * scopetag * ty -> 'a option) -> env -> 'a list
 
val filter : (env * expr -> bool) -> env -> expr -> expr list
(* Given a predicate, an environment, and an expression, filter returns a
* list of the biggest subexpressions that satisfy the predicate (`biggest'
* means that once a subexpression satisfies the predicates, its
* (sub-)subexpressions * are not considered).
*
* Env is updated with bound variables as they are encountered.
*)
 
end
 
/src/parse/environment.sml
382,5 ⟶ 382,40
List.mapPartial f' (ListMergeSort.sort createdAfter (Map.listItemsi tenv))
end
 
(* val filter : (env * expr -> bool) -> env -> expr -> expr list *)
fun filter p env e = let
fun f (env, e) = if p (env, e) then [e] (*{{{1*)
else case e
of E.VarExpr _ => []
| E.IntCExpr _ => []
| E.BoolCExpr _ => []
| E.Deadlock _ => []
| E.CallExpr {args, ...} => foldl (flist env) [] args
| E.NegExpr {expr, ...} => f (env, expr)
| E.NotExpr {expr, ...} => f (env, expr)
| E.UnaryModExpr {expr, ...}=> f (env, expr)
| E.BinIntExpr {left, right,...} => f (env, left)
@ f (env, right)
| E.BinBoolExpr {left, right,...} => f (env, left)
@ f (env, right)
| E.RelExpr {left, right, ...} => f (env, left)
@ f (env, right)
| E.AssignExpr {var, expr, ...} => f (env, var)
@ f (env, expr)
| E.CondExpr {test, trueexpr, falseexpr, ...}
=> f (env, test)
@ f (env, trueexpr)
@ f (env, falseexpr)
 
| E.ForAllExpr {id, ty, expr, ...} => let
val env' = addId BoundScope ((id, ty), env)
in f (env', expr) end
 
| E.ExistsExpr {id, ty, expr, ...} => let
val env' = addId BoundScope ((id, ty), env)
in f (env', expr) end
 
and flist env (e, el) = f (env, e) @ el
in f (env, e) end (*}}}1*)
end
 
/src/parse/expressionfn.sml
118,29 ⟶ 118,6
| varPos (RecordVar (_, _, pos)) = pos
| varPos (SubscriptVar (_, _, pos)) = pos
 
fun filter p e = let
fun f e = if p e then [e] (*{{{1*)
else case e
of VarExpr _ => []
| IntCExpr _ => []
| BoolCExpr _ => []
| Deadlock _ => []
| CallExpr {args, ...} => foldl flist [] args
| NegExpr {expr, ...} => f expr
| NotExpr {expr, ...} => f expr
| UnaryModExpr {expr, ...} => f expr
| BinIntExpr {left, right, ...} => f left @ f right
| BinBoolExpr {left, right, ...} => f left @ f right
| RelExpr {left, right, ...} => f left @ f right
| AssignExpr {var, expr, ...} => f var @ f expr
| CondExpr {test, trueexpr, falseexpr, ...} => f test
@ f trueexpr
@ f falseexpr
| ForAllExpr {expr, ...} => f expr
| ExistsExpr {expr, ...} => f expr
and flist (e, el) = f e @ el
in f e end (*}}}1*)
 
fun getFreeNames e = let
(*{{{1*)
val add = AtomSet.add
/src/TODO
18,3 ⟶ 18,6
for inputs, when no other transition for the input at a location is
enabled.
 
* Shift DTD information into program so that a separate file is no longer
required.
 
/src/maketest/clockexpression.sml
108,7 ⟶ 108,7
| isClkVar _ = false
 
fun containsClocks(env, expr) =
not (List.null (E.filter (fn e=>isClkVar (env, e)) expr))
not (List.null (Env.filter (fn (env',e)=>isClkVar (env', e)) env expr))
 
fun notClk (env, e) = if containsClocks (env, e)
then raise NonClockTerm
215,6 ⟶ 215,7
end
| conv (env, e as E.ExistsExpr _) = notClk (env, e)
(*}}}1*)
 
in (conv (env, expr), !forallbindings, !used) end
end (* local *)
 
/src/maketest/maketest.sml
78,8 ⟶ 78,8
| SOME n => n
in
Util.warn [errMsg];
Util.abort ["while processing transitions on channel ",
Atom.toString chanId, " from ", name]
Util.abort ["while processing transitions on channel '",
Atom.toString chanId, "' from ", name]
end
 
fun doLoc (location as P.Location {id=loc as P.LocId l,