Commit 6de297d3 authored by partain's avatar partain
Browse files

[project @ 1996-06-27 16:55:06 by partain]

partain 1.3 changes to 960626
parent 769ce8e7
This diff is collapsed.
This diff is collapsed.
/* Machine-generated file: do not edit! */
GHCLIB_HS = ghc/Bag.hs ghc/BitSet.hs ghc/CharSeq.hs ghc/FiniteMap.hs ghc/ListSetOps.hs ghc/Maybes.hs ghc/PackedString.hs ghc/Regex.hs ghc/MatchPS.hs ghc/Pretty.hs ghc/Set.hs ghc/Util.hs
GHCLIB_OBJS_DIRS = ghc/Bag ghc/BitSet ghc/CharSeq ghc/FiniteMap ghc/ListSetOps ghc/Maybes ghc/PackedString ghc/Regex ghc/MatchPS ghc/Pretty ghc/Set ghc/Util
IfGhcBuild_normal( GHCLIB_HC_norm = ghc/Bag.hc ghc/BitSet.hc ghc/CharSeq.hc ghc/FiniteMap.hc ghc/ListSetOps.hc ghc/Maybes.hc ghc/PackedString.hc ghc/Regex.hc ghc/MatchPS.hc ghc/Pretty.hc ghc/Set.hc ghc/Util.hc )
IfGhcBuild_normal( GHCLIB_DEP_norm = ghc/Bag.o ghc/BitSet.o ghc/CharSeq.o ghc/FiniteMap.o ghc/ListSetOps.o ghc/Maybes.o ghc/PackedString.o ghc/Regex.o ghc/MatchPS.o ghc/Pretty.o ghc/Set.o ghc/Util.o )
IfGhcBuild_p( GHCLIB_HC_p = ghc/Bag_p.hc ghc/BitSet_p.hc ghc/CharSeq_p.hc ghc/FiniteMap_p.hc ghc/ListSetOps_p.hc ghc/Maybes_p.hc ghc/PackedString_p.hc ghc/Regex_p.hc ghc/MatchPS_p.hc ghc/Pretty_p.hc ghc/Set_p.hc ghc/Util_p.hc )
IfGhcBuild_t( GHCLIB_HC_t = ghc/Bag_t.hc ghc/BitSet_t.hc ghc/CharSeq_t.hc ghc/FiniteMap_t.hc ghc/ListSetOps_t.hc ghc/Maybes_t.hc ghc/PackedString_t.hc ghc/Regex_t.hc ghc/MatchPS_t.hc ghc/Pretty_t.hc ghc/Set_t.hc ghc/Util_t.hc )
IfGhcBuild_u( GHCLIB_HC_u = ghc/Bag_u.hc ghc/BitSet_u.hc ghc/CharSeq_u.hc ghc/FiniteMap_u.hc ghc/ListSetOps_u.hc ghc/Maybes_u.hc ghc/PackedString_u.hc ghc/Regex_u.hc ghc/MatchPS_u.hc ghc/Pretty_u.hc ghc/Set_u.hc ghc/Util_u.hc )
IfGhcBuild_mc( GHCLIB_HC_mc = ghc/Bag_mc.hc ghc/BitSet_mc.hc ghc/CharSeq_mc.hc ghc/FiniteMap_mc.hc ghc/ListSetOps_mc.hc ghc/Maybes_mc.hc ghc/PackedString_mc.hc ghc/Regex_mc.hc ghc/MatchPS_mc.hc ghc/Pretty_mc.hc ghc/Set_mc.hc ghc/Util_mc.hc )
IfGhcBuild_mr( GHCLIB_HC_mr = ghc/Bag_mr.hc ghc/BitSet_mr.hc ghc/CharSeq_mr.hc ghc/FiniteMap_mr.hc ghc/ListSetOps_mr.hc ghc/Maybes_mr.hc ghc/PackedString_mr.hc ghc/Regex_mr.hc ghc/MatchPS_mr.hc ghc/Pretty_mr.hc ghc/Set_mr.hc ghc/Util_mr.hc )
IfGhcBuild_mt( GHCLIB_HC_mt = ghc/Bag_mt.hc ghc/BitSet_mt.hc ghc/CharSeq_mt.hc ghc/FiniteMap_mt.hc ghc/ListSetOps_mt.hc ghc/Maybes_mt.hc ghc/PackedString_mt.hc ghc/Regex_mt.hc ghc/MatchPS_mt.hc ghc/Pretty_mt.hc ghc/Set_mt.hc ghc/Util_mt.hc )
IfGhcBuild_mp( GHCLIB_HC_mp = ghc/Bag_mp.hc ghc/BitSet_mp.hc ghc/CharSeq_mp.hc ghc/FiniteMap_mp.hc ghc/ListSetOps_mp.hc ghc/Maybes_mp.hc ghc/PackedString_mp.hc ghc/Regex_mp.hc ghc/MatchPS_mp.hc ghc/Pretty_mp.hc ghc/Set_mp.hc ghc/Util_mp.hc )
IfGhcBuild_mg( GHCLIB_HC_mg = ghc/Bag_mg.hc ghc/BitSet_mg.hc ghc/CharSeq_mg.hc ghc/FiniteMap_mg.hc ghc/ListSetOps_mg.hc ghc/Maybes_mg.hc ghc/PackedString_mg.hc ghc/Regex_mg.hc ghc/MatchPS_mg.hc ghc/Pretty_mg.hc ghc/Set_mg.hc ghc/Util_mg.hc )
IfGhcBuild_2s( GHCLIB_HC_2s = ghc/Bag_2s.hc ghc/BitSet_2s.hc ghc/CharSeq_2s.hc ghc/FiniteMap_2s.hc ghc/ListSetOps_2s.hc ghc/Maybes_2s.hc ghc/PackedString_2s.hc ghc/Regex_2s.hc ghc/MatchPS_2s.hc ghc/Pretty_2s.hc ghc/Set_2s.hc ghc/Util_2s.hc )
IfGhcBuild_1s( GHCLIB_HC_1s = ghc/Bag_1s.hc ghc/BitSet_1s.hc ghc/CharSeq_1s.hc ghc/FiniteMap_1s.hc ghc/ListSetOps_1s.hc ghc/Maybes_1s.hc ghc/PackedString_1s.hc ghc/Regex_1s.hc ghc/MatchPS_1s.hc ghc/Pretty_1s.hc ghc/Set_1s.hc ghc/Util_1s.hc )
IfGhcBuild_du( GHCLIB_HC_du = ghc/Bag_du.hc ghc/BitSet_du.hc ghc/CharSeq_du.hc ghc/FiniteMap_du.hc ghc/ListSetOps_du.hc ghc/Maybes_du.hc ghc/PackedString_du.hc ghc/Regex_du.hc ghc/MatchPS_du.hc ghc/Pretty_du.hc ghc/Set_du.hc ghc/Util_du.hc )
IfGhcBuild_a( GHCLIB_HC_a = ghc/Bag_a.hc ghc/BitSet_a.hc ghc/CharSeq_a.hc ghc/FiniteMap_a.hc ghc/ListSetOps_a.hc ghc/Maybes_a.hc ghc/PackedString_a.hc ghc/Regex_a.hc ghc/MatchPS_a.hc ghc/Pretty_a.hc ghc/Set_a.hc ghc/Util_a.hc )
IfGhcBuild_b( GHCLIB_HC_b = ghc/Bag_b.hc ghc/BitSet_b.hc ghc/CharSeq_b.hc ghc/FiniteMap_b.hc ghc/ListSetOps_b.hc ghc/Maybes_b.hc ghc/PackedString_b.hc ghc/Regex_b.hc ghc/MatchPS_b.hc ghc/Pretty_b.hc ghc/Set_b.hc ghc/Util_b.hc )
IfGhcBuild_c( GHCLIB_HC_c = ghc/Bag_c.hc ghc/BitSet_c.hc ghc/CharSeq_c.hc ghc/FiniteMap_c.hc ghc/ListSetOps_c.hc ghc/Maybes_c.hc ghc/PackedString_c.hc ghc/Regex_c.hc ghc/MatchPS_c.hc ghc/Pretty_c.hc ghc/Set_c.hc ghc/Util_c.hc )
IfGhcBuild_d( GHCLIB_HC_d = ghc/Bag_d.hc ghc/BitSet_d.hc ghc/CharSeq_d.hc ghc/FiniteMap_d.hc ghc/ListSetOps_d.hc ghc/Maybes_d.hc ghc/PackedString_d.hc ghc/Regex_d.hc ghc/MatchPS_d.hc ghc/Pretty_d.hc ghc/Set_d.hc ghc/Util_d.hc )
IfGhcBuild_e( GHCLIB_HC_e = ghc/Bag_e.hc ghc/BitSet_e.hc ghc/CharSeq_e.hc ghc/FiniteMap_e.hc ghc/ListSetOps_e.hc ghc/Maybes_e.hc ghc/PackedString_e.hc ghc/Regex_e.hc ghc/MatchPS_e.hc ghc/Pretty_e.hc ghc/Set_e.hc ghc/Util_e.hc )
IfGhcBuild_f( GHCLIB_HC_f = ghc/Bag_f.hc ghc/BitSet_f.hc ghc/CharSeq_f.hc ghc/FiniteMap_f.hc ghc/ListSetOps_f.hc ghc/Maybes_f.hc ghc/PackedString_f.hc ghc/Regex_f.hc ghc/MatchPS_f.hc ghc/Pretty_f.hc ghc/Set_f.hc ghc/Util_f.hc )
IfGhcBuild_g( GHCLIB_HC_g = ghc/Bag_g.hc ghc/BitSet_g.hc ghc/CharSeq_g.hc ghc/FiniteMap_g.hc ghc/ListSetOps_g.hc ghc/Maybes_g.hc ghc/PackedString_g.hc ghc/Regex_g.hc ghc/MatchPS_g.hc ghc/Pretty_g.hc ghc/Set_g.hc ghc/Util_g.hc )
IfGhcBuild_h( GHCLIB_HC_h = ghc/Bag_h.hc ghc/BitSet_h.hc ghc/CharSeq_h.hc ghc/FiniteMap_h.hc ghc/ListSetOps_h.hc ghc/Maybes_h.hc ghc/PackedString_h.hc ghc/Regex_h.hc ghc/MatchPS_h.hc ghc/Pretty_h.hc ghc/Set_h.hc ghc/Util_h.hc )
IfGhcBuild_i( GHCLIB_HC_i = ghc/Bag_i.hc ghc/BitSet_i.hc ghc/CharSeq_i.hc ghc/FiniteMap_i.hc ghc/ListSetOps_i.hc ghc/Maybes_i.hc ghc/PackedString_i.hc ghc/Regex_i.hc ghc/MatchPS_i.hc ghc/Pretty_i.hc ghc/Set_i.hc ghc/Util_i.hc )
IfGhcBuild_j( GHCLIB_HC_j = ghc/Bag_j.hc ghc/BitSet_j.hc ghc/CharSeq_j.hc ghc/FiniteMap_j.hc ghc/ListSetOps_j.hc ghc/Maybes_j.hc ghc/PackedString_j.hc ghc/Regex_j.hc ghc/MatchPS_j.hc ghc/Pretty_j.hc ghc/Set_j.hc ghc/Util_j.hc )
IfGhcBuild_k( GHCLIB_HC_k = ghc/Bag_k.hc ghc/BitSet_k.hc ghc/CharSeq_k.hc ghc/FiniteMap_k.hc ghc/ListSetOps_k.hc ghc/Maybes_k.hc ghc/PackedString_k.hc ghc/Regex_k.hc ghc/MatchPS_k.hc ghc/Pretty_k.hc ghc/Set_k.hc ghc/Util_k.hc )
IfGhcBuild_l( GHCLIB_HC_l = ghc/Bag_l.hc ghc/BitSet_l.hc ghc/CharSeq_l.hc ghc/FiniteMap_l.hc ghc/ListSetOps_l.hc ghc/Maybes_l.hc ghc/PackedString_l.hc ghc/Regex_l.hc ghc/MatchPS_l.hc ghc/Pretty_l.hc ghc/Set_l.hc ghc/Util_l.hc )
IfGhcBuild_m( GHCLIB_HC_m = ghc/Bag_m.hc ghc/BitSet_m.hc ghc/CharSeq_m.hc ghc/FiniteMap_m.hc ghc/ListSetOps_m.hc ghc/Maybes_m.hc ghc/PackedString_m.hc ghc/Regex_m.hc ghc/MatchPS_m.hc ghc/Pretty_m.hc ghc/Set_m.hc ghc/Util_m.hc )
IfGhcBuild_n( GHCLIB_HC_n = ghc/Bag_n.hc ghc/BitSet_n.hc ghc/CharSeq_n.hc ghc/FiniteMap_n.hc ghc/ListSetOps_n.hc ghc/Maybes_n.hc ghc/PackedString_n.hc ghc/Regex_n.hc ghc/MatchPS_n.hc ghc/Pretty_n.hc ghc/Set_n.hc ghc/Util_n.hc )
IfGhcBuild_o( GHCLIB_HC_o = ghc/Bag_o.hc ghc/BitSet_o.hc ghc/CharSeq_o.hc ghc/FiniteMap_o.hc ghc/ListSetOps_o.hc ghc/Maybes_o.hc ghc/PackedString_o.hc ghc/Regex_o.hc ghc/MatchPS_o.hc ghc/Pretty_o.hc ghc/Set_o.hc ghc/Util_o.hc )
IfGhcBuild_p( GHCLIB_DEP_p = ghc/Bag_p.o ghc/BitSet_p.o ghc/CharSeq_p.o ghc/FiniteMap_p.o ghc/ListSetOps_p.o ghc/Maybes_p.o ghc/PackedString_p.o ghc/Regex_p.o ghc/MatchPS_p.o ghc/Pretty_p.o ghc/Set_p.o ghc/Util_p.o )
IfGhcBuild_t( GHCLIB_DEP_t = ghc/Bag_t.o ghc/BitSet_t.o ghc/CharSeq_t.o ghc/FiniteMap_t.o ghc/ListSetOps_t.o ghc/Maybes_t.o ghc/PackedString_t.o ghc/Regex_t.o ghc/MatchPS_t.o ghc/Pretty_t.o ghc/Set_t.o ghc/Util_t.o )
IfGhcBuild_u( GHCLIB_DEP_u = ghc/Bag_u.o ghc/BitSet_u.o ghc/CharSeq_u.o ghc/FiniteMap_u.o ghc/ListSetOps_u.o ghc/Maybes_u.o ghc/PackedString_u.o ghc/Regex_u.o ghc/MatchPS_u.o ghc/Pretty_u.o ghc/Set_u.o ghc/Util_u.o )
IfGhcBuild_mc( GHCLIB_DEP_mc = ghc/Bag_mc.o ghc/BitSet_mc.o ghc/CharSeq_mc.o ghc/FiniteMap_mc.o ghc/ListSetOps_mc.o ghc/Maybes_mc.o ghc/PackedString_mc.o ghc/Regex_mc.o ghc/MatchPS_mc.o ghc/Pretty_mc.o ghc/Set_mc.o ghc/Util_mc.o )
IfGhcBuild_mr( GHCLIB_DEP_mr = ghc/Bag_mr.o ghc/BitSet_mr.o ghc/CharSeq_mr.o ghc/FiniteMap_mr.o ghc/ListSetOps_mr.o ghc/Maybes_mr.o ghc/PackedString_mr.o ghc/Regex_mr.o ghc/MatchPS_mr.o ghc/Pretty_mr.o ghc/Set_mr.o ghc/Util_mr.o )
IfGhcBuild_mt( GHCLIB_DEP_mt = ghc/Bag_mt.o ghc/BitSet_mt.o ghc/CharSeq_mt.o ghc/FiniteMap_mt.o ghc/ListSetOps_mt.o ghc/Maybes_mt.o ghc/PackedString_mt.o ghc/Regex_mt.o ghc/MatchPS_mt.o ghc/Pretty_mt.o ghc/Set_mt.o ghc/Util_mt.o )
IfGhcBuild_mp( GHCLIB_DEP_mp = ghc/Bag_mp.o ghc/BitSet_mp.o ghc/CharSeq_mp.o ghc/FiniteMap_mp.o ghc/ListSetOps_mp.o ghc/Maybes_mp.o ghc/PackedString_mp.o ghc/Regex_mp.o ghc/MatchPS_mp.o ghc/Pretty_mp.o ghc/Set_mp.o ghc/Util_mp.o )
IfGhcBuild_mg( GHCLIB_DEP_mg = ghc/Bag_mg.o ghc/BitSet_mg.o ghc/CharSeq_mg.o ghc/FiniteMap_mg.o ghc/ListSetOps_mg.o ghc/Maybes_mg.o ghc/PackedString_mg.o ghc/Regex_mg.o ghc/MatchPS_mg.o ghc/Pretty_mg.o ghc/Set_mg.o ghc/Util_mg.o )
IfGhcBuild_2s( GHCLIB_DEP_2s = ghc/Bag_2s.o ghc/BitSet_2s.o ghc/CharSeq_2s.o ghc/FiniteMap_2s.o ghc/ListSetOps_2s.o ghc/Maybes_2s.o ghc/PackedString_2s.o ghc/Regex_2s.o ghc/MatchPS_2s.o ghc/Pretty_2s.o ghc/Set_2s.o ghc/Util_2s.o )
IfGhcBuild_1s( GHCLIB_DEP_1s = ghc/Bag_1s.o ghc/BitSet_1s.o ghc/CharSeq_1s.o ghc/FiniteMap_1s.o ghc/ListSetOps_1s.o ghc/Maybes_1s.o ghc/PackedString_1s.o ghc/Regex_1s.o ghc/MatchPS_1s.o ghc/Pretty_1s.o ghc/Set_1s.o ghc/Util_1s.o )
IfGhcBuild_du( GHCLIB_DEP_du = ghc/Bag_du.o ghc/BitSet_du.o ghc/CharSeq_du.o ghc/FiniteMap_du.o ghc/ListSetOps_du.o ghc/Maybes_du.o ghc/PackedString_du.o ghc/Regex_du.o ghc/MatchPS_du.o ghc/Pretty_du.o ghc/Set_du.o ghc/Util_du.o )
IfGhcBuild_a( GHCLIB_DEP_a = ghc/Bag_a.o ghc/BitSet_a.o ghc/CharSeq_a.o ghc/FiniteMap_a.o ghc/ListSetOps_a.o ghc/Maybes_a.o ghc/PackedString_a.o ghc/Regex_a.o ghc/MatchPS_a.o ghc/Pretty_a.o ghc/Set_a.o ghc/Util_a.o )
IfGhcBuild_b( GHCLIB_DEP_b = ghc/Bag_b.o ghc/BitSet_b.o ghc/CharSeq_b.o ghc/FiniteMap_b.o ghc/ListSetOps_b.o ghc/Maybes_b.o ghc/PackedString_b.o ghc/Regex_b.o ghc/MatchPS_b.o ghc/Pretty_b.o ghc/Set_b.o ghc/Util_b.o )
IfGhcBuild_c( GHCLIB_DEP_c = ghc/Bag_c.o ghc/BitSet_c.o ghc/CharSeq_c.o ghc/FiniteMap_c.o ghc/ListSetOps_c.o ghc/Maybes_c.o ghc/PackedString_c.o ghc/Regex_c.o ghc/MatchPS_c.o ghc/Pretty_c.o ghc/Set_c.o ghc/Util_c.o )
IfGhcBuild_d( GHCLIB_DEP_d = ghc/Bag_d.o ghc/BitSet_d.o ghc/CharSeq_d.o ghc/FiniteMap_d.o ghc/ListSetOps_d.o ghc/Maybes_d.o ghc/PackedString_d.o ghc/Regex_d.o ghc/MatchPS_d.o ghc/Pretty_d.o ghc/Set_d.o ghc/Util_d.o )
IfGhcBuild_e( GHCLIB_DEP_e = ghc/Bag_e.o ghc/BitSet_e.o ghc/CharSeq_e.o ghc/FiniteMap_e.o ghc/ListSetOps_e.o ghc/Maybes_e.o ghc/PackedString_e.o ghc/Regex_e.o ghc/MatchPS_e.o ghc/Pretty_e.o ghc/Set_e.o ghc/Util_e.o )
IfGhcBuild_f( GHCLIB_DEP_f = ghc/Bag_f.o ghc/BitSet_f.o ghc/CharSeq_f.o ghc/FiniteMap_f.o ghc/ListSetOps_f.o ghc/Maybes_f.o ghc/PackedString_f.o ghc/Regex_f.o ghc/MatchPS_f.o ghc/Pretty_f.o ghc/Set_f.o ghc/Util_f.o )
IfGhcBuild_g( GHCLIB_DEP_g = ghc/Bag_g.o ghc/BitSet_g.o ghc/CharSeq_g.o ghc/FiniteMap_g.o ghc/ListSetOps_g.o ghc/Maybes_g.o ghc/PackedString_g.o ghc/Regex_g.o ghc/MatchPS_g.o ghc/Pretty_g.o ghc/Set_g.o ghc/Util_g.o )
IfGhcBuild_h( GHCLIB_DEP_h = ghc/Bag_h.o ghc/BitSet_h.o ghc/CharSeq_h.o ghc/FiniteMap_h.o ghc/ListSetOps_h.o ghc/Maybes_h.o ghc/PackedString_h.o ghc/Regex_h.o ghc/MatchPS_h.o ghc/Pretty_h.o ghc/Set_h.o ghc/Util_h.o )
IfGhcBuild_i( GHCLIB_DEP_i = ghc/Bag_i.o ghc/BitSet_i.o ghc/CharSeq_i.o ghc/FiniteMap_i.o ghc/ListSetOps_i.o ghc/Maybes_i.o ghc/PackedString_i.o ghc/Regex_i.o ghc/MatchPS_i.o ghc/Pretty_i.o ghc/Set_i.o ghc/Util_i.o )
IfGhcBuild_j( GHCLIB_DEP_j = ghc/Bag_j.o ghc/BitSet_j.o ghc/CharSeq_j.o ghc/FiniteMap_j.o ghc/ListSetOps_j.o ghc/Maybes_j.o ghc/PackedString_j.o ghc/Regex_j.o ghc/MatchPS_j.o ghc/Pretty_j.o ghc/Set_j.o ghc/Util_j.o )
IfGhcBuild_k( GHCLIB_DEP_k = ghc/Bag_k.o ghc/BitSet_k.o ghc/CharSeq_k.o ghc/FiniteMap_k.o ghc/ListSetOps_k.o ghc/Maybes_k.o ghc/PackedString_k.o ghc/Regex_k.o ghc/MatchPS_k.o ghc/Pretty_k.o ghc/Set_k.o ghc/Util_k.o )
IfGhcBuild_l( GHCLIB_DEP_l = ghc/Bag_l.o ghc/BitSet_l.o ghc/CharSeq_l.o ghc/FiniteMap_l.o ghc/ListSetOps_l.o ghc/Maybes_l.o ghc/PackedString_l.o ghc/Regex_l.o ghc/MatchPS_l.o ghc/Pretty_l.o ghc/Set_l.o ghc/Util_l.o )
IfGhcBuild_m( GHCLIB_DEP_m = ghc/Bag_m.o ghc/BitSet_m.o ghc/CharSeq_m.o ghc/FiniteMap_m.o ghc/ListSetOps_m.o ghc/Maybes_m.o ghc/PackedString_m.o ghc/Regex_m.o ghc/MatchPS_m.o ghc/Pretty_m.o ghc/Set_m.o ghc/Util_m.o )
IfGhcBuild_n( GHCLIB_DEP_n = ghc/Bag_n.o ghc/BitSet_n.o ghc/CharSeq_n.o ghc/FiniteMap_n.o ghc/ListSetOps_n.o ghc/Maybes_n.o ghc/PackedString_n.o ghc/Regex_n.o ghc/MatchPS_n.o ghc/Pretty_n.o ghc/Set_n.o ghc/Util_n.o )
IfGhcBuild_o( GHCLIB_DEP_o = ghc/Bag_o.o ghc/BitSet_o.o ghc/CharSeq_o.o ghc/FiniteMap_o.o ghc/ListSetOps_o.o ghc/Maybes_o.o ghc/PackedString_o.o ghc/Regex_o.o ghc/MatchPS_o.o ghc/Pretty_o.o ghc/Set_o.o ghc/Util_o.o )
IfGhcBuild_p( GHCLIB_HIs_p = ghc/Bag_p.hi ghc/BitSet_p.hi ghc/CharSeq_p.hi ghc/FiniteMap_p.hi ghc/ListSetOps_p.hi ghc/Maybes_p.hi ghc/PackedString_p.hi ghc/Regex_p.hi ghc/MatchPS_p.hi ghc/Pretty_p.hi ghc/Set_p.hi ghc/Util_p.hi )
IfGhcBuild_t( GHCLIB_HIs_t = ghc/Bag_t.hi ghc/BitSet_t.hi ghc/CharSeq_t.hi ghc/FiniteMap_t.hi ghc/ListSetOps_t.hi ghc/Maybes_t.hi ghc/PackedString_t.hi ghc/Regex_t.hi ghc/MatchPS_t.hi ghc/Pretty_t.hi ghc/Set_t.hi ghc/Util_t.hi )
IfGhcBuild_u( GHCLIB_HIs_u = ghc/Bag_u.hi ghc/BitSet_u.hi ghc/CharSeq_u.hi ghc/FiniteMap_u.hi ghc/ListSetOps_u.hi ghc/Maybes_u.hi ghc/PackedString_u.hi ghc/Regex_u.hi ghc/MatchPS_u.hi ghc/Pretty_u.hi ghc/Set_u.hi ghc/Util_u.hi )
IfGhcBuild_mc( GHCLIB_HIs_mc = ghc/Bag_mc.hi ghc/BitSet_mc.hi ghc/CharSeq_mc.hi ghc/FiniteMap_mc.hi ghc/ListSetOps_mc.hi ghc/Maybes_mc.hi ghc/PackedString_mc.hi ghc/Regex_mc.hi ghc/MatchPS_mc.hi ghc/Pretty_mc.hi ghc/Set_mc.hi ghc/Util_mc.hi )
IfGhcBuild_mr( GHCLIB_HIs_mr = ghc/Bag_mr.hi ghc/BitSet_mr.hi ghc/CharSeq_mr.hi ghc/FiniteMap_mr.hi ghc/ListSetOps_mr.hi ghc/Maybes_mr.hi ghc/PackedString_mr.hi ghc/Regex_mr.hi ghc/MatchPS_mr.hi ghc/Pretty_mr.hi ghc/Set_mr.hi ghc/Util_mr.hi )
IfGhcBuild_mt( GHCLIB_HIs_mt = ghc/Bag_mt.hi ghc/BitSet_mt.hi ghc/CharSeq_mt.hi ghc/FiniteMap_mt.hi ghc/ListSetOps_mt.hi ghc/Maybes_mt.hi ghc/PackedString_mt.hi ghc/Regex_mt.hi ghc/MatchPS_mt.hi ghc/Pretty_mt.hi ghc/Set_mt.hi ghc/Util_mt.hi )
IfGhcBuild_mp( GHCLIB_HIs_mp = ghc/Bag_mp.hi ghc/BitSet_mp.hi ghc/CharSeq_mp.hi ghc/FiniteMap_mp.hi ghc/ListSetOps_mp.hi ghc/Maybes_mp.hi ghc/PackedString_mp.hi ghc/Regex_mp.hi ghc/MatchPS_mp.hi ghc/Pretty_mp.hi ghc/Set_mp.hi ghc/Util_mp.hi )
IfGhcBuild_mg( GHCLIB_HIs_mg = ghc/Bag_mg.hi ghc/BitSet_mg.hi ghc/CharSeq_mg.hi ghc/FiniteMap_mg.hi ghc/ListSetOps_mg.hi ghc/Maybes_mg.hi ghc/PackedString_mg.hi ghc/Regex_mg.hi ghc/MatchPS_mg.hi ghc/Pretty_mg.hi ghc/Set_mg.hi ghc/Util_mg.hi )
IfGhcBuild_2s( GHCLIB_HIs_2s = ghc/Bag_2s.hi ghc/BitSet_2s.hi ghc/CharSeq_2s.hi ghc/FiniteMap_2s.hi ghc/ListSetOps_2s.hi ghc/Maybes_2s.hi ghc/PackedString_2s.hi ghc/Regex_2s.hi ghc/MatchPS_2s.hi ghc/Pretty_2s.hi ghc/Set_2s.hi ghc/Util_2s.hi )
IfGhcBuild_1s( GHCLIB_HIs_1s = ghc/Bag_1s.hi ghc/BitSet_1s.hi ghc/CharSeq_1s.hi ghc/FiniteMap_1s.hi ghc/ListSetOps_1s.hi ghc/Maybes_1s.hi ghc/PackedString_1s.hi ghc/Regex_1s.hi ghc/MatchPS_1s.hi ghc/Pretty_1s.hi ghc/Set_1s.hi ghc/Util_1s.hi )
IfGhcBuild_du( GHCLIB_HIs_du = ghc/Bag_du.hi ghc/BitSet_du.hi ghc/CharSeq_du.hi ghc/FiniteMap_du.hi ghc/ListSetOps_du.hi ghc/Maybes_du.hi ghc/PackedString_du.hi ghc/Regex_du.hi ghc/MatchPS_du.hi ghc/Pretty_du.hi ghc/Set_du.hi ghc/Util_du.hi )
IfGhcBuild_a( GHCLIB_HIs_a = ghc/Bag_a.hi ghc/BitSet_a.hi ghc/CharSeq_a.hi ghc/FiniteMap_a.hi ghc/ListSetOps_a.hi ghc/Maybes_a.hi ghc/PackedString_a.hi ghc/Regex_a.hi ghc/MatchPS_a.hi ghc/Pretty_a.hi ghc/Set_a.hi ghc/Util_a.hi )
IfGhcBuild_b( GHCLIB_HIs_b = ghc/Bag_b.hi ghc/BitSet_b.hi ghc/CharSeq_b.hi ghc/FiniteMap_b.hi ghc/ListSetOps_b.hi ghc/Maybes_b.hi ghc/PackedString_b.hi ghc/Regex_b.hi ghc/MatchPS_b.hi ghc/Pretty_b.hi ghc/Set_b.hi ghc/Util_b.hi )
IfGhcBuild_c( GHCLIB_HIs_c = ghc/Bag_c.hi ghc/BitSet_c.hi ghc/CharSeq_c.hi ghc/FiniteMap_c.hi ghc/ListSetOps_c.hi ghc/Maybes_c.hi ghc/PackedString_c.hi ghc/Regex_c.hi ghc/MatchPS_c.hi ghc/Pretty_c.hi ghc/Set_c.hi ghc/Util_c.hi )
IfGhcBuild_d( GHCLIB_HIs_d = ghc/Bag_d.hi ghc/BitSet_d.hi ghc/CharSeq_d.hi ghc/FiniteMap_d.hi ghc/ListSetOps_d.hi ghc/Maybes_d.hi ghc/PackedString_d.hi ghc/Regex_d.hi ghc/MatchPS_d.hi ghc/Pretty_d.hi ghc/Set_d.hi ghc/Util_d.hi )
IfGhcBuild_e( GHCLIB_HIs_e = ghc/Bag_e.hi ghc/BitSet_e.hi ghc/CharSeq_e.hi ghc/FiniteMap_e.hi ghc/ListSetOps_e.hi ghc/Maybes_e.hi ghc/PackedString_e.hi ghc/Regex_e.hi ghc/MatchPS_e.hi ghc/Pretty_e.hi ghc/Set_e.hi ghc/Util_e.hi )
IfGhcBuild_f( GHCLIB_HIs_f = ghc/Bag_f.hi ghc/BitSet_f.hi ghc/CharSeq_f.hi ghc/FiniteMap_f.hi ghc/ListSetOps_f.hi ghc/Maybes_f.hi ghc/PackedString_f.hi ghc/Regex_f.hi ghc/MatchPS_f.hi ghc/Pretty_f.hi ghc/Set_f.hi ghc/Util_f.hi )
IfGhcBuild_g( GHCLIB_HIs_g = ghc/Bag_g.hi ghc/BitSet_g.hi ghc/CharSeq_g.hi ghc/FiniteMap_g.hi ghc/ListSetOps_g.hi ghc/Maybes_g.hi ghc/PackedString_g.hi ghc/Regex_g.hi ghc/MatchPS_g.hi ghc/Pretty_g.hi ghc/Set_g.hi ghc/Util_g.hi )
IfGhcBuild_h( GHCLIB_HIs_h = ghc/Bag_h.hi ghc/BitSet_h.hi ghc/CharSeq_h.hi ghc/FiniteMap_h.hi ghc/ListSetOps_h.hi ghc/Maybes_h.hi ghc/PackedString_h.hi ghc/Regex_h.hi ghc/MatchPS_h.hi ghc/Pretty_h.hi ghc/Set_h.hi ghc/Util_h.hi )
IfGhcBuild_i( GHCLIB_HIs_i = ghc/Bag_i.hi ghc/BitSet_i.hi ghc/CharSeq_i.hi ghc/FiniteMap_i.hi ghc/ListSetOps_i.hi ghc/Maybes_i.hi ghc/PackedString_i.hi ghc/Regex_i.hi ghc/MatchPS_i.hi ghc/Pretty_i.hi ghc/Set_i.hi ghc/Util_i.hi )
IfGhcBuild_j( GHCLIB_HIs_j = ghc/Bag_j.hi ghc/BitSet_j.hi ghc/CharSeq_j.hi ghc/FiniteMap_j.hi ghc/ListSetOps_j.hi ghc/Maybes_j.hi ghc/PackedString_j.hi ghc/Regex_j.hi ghc/MatchPS_j.hi ghc/Pretty_j.hi ghc/Set_j.hi ghc/Util_j.hi )
IfGhcBuild_k( GHCLIB_HIs_k = ghc/Bag_k.hi ghc/BitSet_k.hi ghc/CharSeq_k.hi ghc/FiniteMap_k.hi ghc/ListSetOps_k.hi ghc/Maybes_k.hi ghc/PackedString_k.hi ghc/Regex_k.hi ghc/MatchPS_k.hi ghc/Pretty_k.hi ghc/Set_k.hi ghc/Util_k.hi )
IfGhcBuild_l( GHCLIB_HIs_l = ghc/Bag_l.hi ghc/BitSet_l.hi ghc/CharSeq_l.hi ghc/FiniteMap_l.hi ghc/ListSetOps_l.hi ghc/Maybes_l.hi ghc/PackedString_l.hi ghc/Regex_l.hi ghc/MatchPS_l.hi ghc/Pretty_l.hi ghc/Set_l.hi ghc/Util_l.hi )
IfGhcBuild_m( GHCLIB_HIs_m = ghc/Bag_m.hi ghc/BitSet_m.hi ghc/CharSeq_m.hi ghc/FiniteMap_m.hi ghc/ListSetOps_m.hi ghc/Maybes_m.hi ghc/PackedString_m.hi ghc/Regex_m.hi ghc/MatchPS_m.hi ghc/Pretty_m.hi ghc/Set_m.hi ghc/Util_m.hi )
IfGhcBuild_n( GHCLIB_HIs_n = ghc/Bag_n.hi ghc/BitSet_n.hi ghc/CharSeq_n.hi ghc/FiniteMap_n.hi ghc/ListSetOps_n.hi ghc/Maybes_n.hi ghc/PackedString_n.hi ghc/Regex_n.hi ghc/MatchPS_n.hi ghc/Pretty_n.hi ghc/Set_n.hi ghc/Util_n.hi )
IfGhcBuild_o( GHCLIB_HIs_o = ghc/Bag_o.hi ghc/BitSet_o.hi ghc/CharSeq_o.hi ghc/FiniteMap_o.hi ghc/ListSetOps_o.hi ghc/Maybes_o.hi ghc/PackedString_o.hi ghc/Regex_o.hi ghc/MatchPS_o.hi ghc/Pretty_o.hi ghc/Set_o.hi ghc/Util_o.hi )
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
Library code for Glorious Glasgow Haskell
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
"Library code" is written in (possibly Glasgow-extended) Haskell. If
it has to be written in C, it's in ../runtime.
"tests" is supposed to be, well, tests.
"prelude" and "glaExts" hold the standard and not-so-standard Prelude
code; you get this stuff, like it or not.
"std", "hbc" and "ghc" (and eventually "yale", etc., etc?) are
libraries of useful modules. The idea is: once all implementers agree
on a module, it goes in "std"; otherwise, it lives in an
implementation-specific library.
Still in development.
Will Partain
93/07/09
[Still still in development -- WDP 94/12]
{-
%
% (c) The GRASP/AQUA Project, Glasgow University, 1995
%
......@@ -6,6 +7,7 @@
Standard, unbounded channel abstraction.
\begin{code}
-}
module Channel
(
{- abstract type defined -}
......@@ -26,10 +28,8 @@ module Channel
) where
import PreludeGlaST
import PreludePrimIO ( newEmptyMVar, newMVar, putMVar,
readMVar, takeMVar, _MVar
)
import GHCbase
{-
\end{code}
A channel is represented by two @MVar@s keeping track of the two ends
......@@ -37,16 +37,18 @@ of the channel contents,i.e., the read- and write ends. Empty @MVar@s
are used to handle consumers trying to read from an empty channel.
\begin{code}
-}
data Chan a
= Chan (_MVar (Stream a))
(_MVar (Stream a))
= Chan (MVar (Stream a))
(MVar (Stream a))
type Stream a = _MVar (ChItem a)
type Stream a = MVar (ChItem a)
data ChItem a = ChItem a (Stream a)
{-
\end{code}
See the Concurrent Haskell paper for a diagram explaining the
......@@ -56,6 +58,7 @@ how the different channel operations proceed.
these two @MVar@s with an empty @MVar@.
\begin{code}
-}
newChan :: IO (Chan a)
newChan
......@@ -64,6 +67,7 @@ newChan
newMVar hole >>= \ write ->
return (Chan read write)
{-
\end{code}
To put an element on a channel, a new hole at the write end is created.
......@@ -72,6 +76,7 @@ filled in with a new stream element holding the entered value and the
new hole.
\begin{code}
-}
putChan :: Chan a -> a -> IO ()
putChan (Chan read write) val
......@@ -81,9 +86,6 @@ putChan (Chan read write) val
putMVar old_hole (ChItem val new_hole) >>
return ()
\end{code}
\begin{code}
getChan :: Chan a -> IO a
getChan (Chan read write)
......@@ -92,9 +94,6 @@ getChan (Chan read write)
putMVar read new_rend >>
return val
\end{code}
\begin{code}
dupChan :: Chan a -> IO (Chan a)
dupChan (Chan read write)
......@@ -111,20 +110,41 @@ unGetChan (Chan read write) val
putMVar read new_rend >>
return ()
{-
\end{code}
Operators for interfacing with functional streams.
\begin{code}
-}
getChanContents :: Chan a -> IO [a]
getChanContents ch =
unsafeInterleavePrimIO (
getChan ch `thenPrimIO` \ ~(Right x) ->
unsafeInterleavePrimIO (getChanContents ch) `thenPrimIO` \ ~(Right xs) ->
returnPrimIO (Right (x:xs)))
getChanContents ch
{- WAS:
= unsafeInterleavePrimIO (
getChan ch `thenPrimIO` \ ~(Right x) ->
unsafeInterleavePrimIO (getChanContents ch) `thenPrimIO` \ ~(Right xs) ->
returnPrimIO (Right (x:xs)))
-}
= my_2_IO $ unsafeInterleavePrimIO (
getChan_prim ch >>= \ ~(Right x) ->
unsafeInterleavePrimIO (getChanContents_prim ch) >>= \ ~(Right xs) ->
returnPrimIO (Right (x:xs)))
my_2_IO :: PrimIO (Either IOError a) -> IO a -- simple; primIOToIO does too much!
my_2_IO m = IO m
getChan_prim :: Chan a -> PrimIO (Either IOError a)
getChanContents_prim :: Chan a -> PrimIO (Either IOError [a])
getChan_prim ch = ST $ \ s ->
case (getChan ch) of { IO (ST get) ->
get s }
getChanContents_prim ch = ST $ \ s ->
case (getChanContents ch) of { IO (ST get) ->
get s }
-------------
putList2Chan :: Chan a -> [a] -> IO ()
putList2Chan ch ls = sequence (map (putChan ch) ls)
\end{code}
{-
%
% (c) The GRASP/AQUA Project, Glasgow University, 1995
%
......@@ -7,6 +8,7 @@ Channel variables, are one-element channels described in the Concurrent
Haskell paper (available from @ftp://ftp.dcs.gla.ac.uk/pub/glasgow-fp/drafts@)
\begin{code}
-}
module ChannelVar
(
{- abstract -}
......@@ -14,14 +16,12 @@ module ChannelVar
newCVar, --:: IO (CVar a)
putCVar, --:: CVar a -> a -> IO ()
getCVar, --:: CVar a -> IO a
_MVar
MVar
) where
import PreludeGlaST
import PreludePrimIO ( newEmptyMVar, newMVar, putMVar,
readMVar, takeMVar, _MVar
)
import GHCbase
{-
\end{code}
@MVars@ provide the basic mechanisms for synchronising access to a shared
......@@ -31,10 +31,11 @@ access to the channel variable,i.e., a producer is forced to wait up for
a consumer to remove the previous value before it can deposit a new one in the @CVar@.
\begin{code}
-}
data CVar a
= CVar (_MVar a) -- prod -> cons
(_MVar ()) -- cons -> prod
= CVar (MVar a) -- prod -> cons
(MVar ()) -- cons -> prod
newCVar :: IO (CVar a)
putCVar :: CVar a -> a -> IO ()
......@@ -54,5 +55,3 @@ getCVar (CVar datum ack)
= takeMVar datum >>= \ val ->
putMVar ack () >>
return val
\end{code}
{-
%
% (c) The AQUA Project, Glasgow University, 1995
%
......@@ -10,23 +11,26 @@ Currently, the collection only contains the abstractions found in the
\tr{ftp.dcs.gla.ac.uk/pub/glasgow-fp/drafts}.) plus a couple of
others. See the paper and the individual files containing the module
definitions for explanation on what they do.
-}
\begin{code}
module Concurrent (
forkIO,
par, seq, -- reexported from Parallel
par, seq, fork, -- re-exported from GHCbase
threadWait, threadDelay,
-- waiting on file descriptor I/O
threadWaitRead, threadWaitWrite,
ChannelVar..,
Channel..,
Semaphore..,
Merge..,
SampleVar..,
-- wait for timeout
threadDelay,
module ChannelVar,
module Channel,
module Semaphore,
module Merge,
module SampleVar,
-- IVars and MVars come from here, too
IVar(..), MVar(..), -- for convenience...
_IVar, _MVar, -- abstract
IVar, MVar,
newEmptyMVar, takeMVar, putMVar, newMVar, readMVar, swapMVar,
newIVar, readIVar, writeIVar
......@@ -39,21 +43,12 @@ import Semaphore
import Merge
import SampleVar
import PreludeGlaST ( forkST )
import PreludePrimIO ( newEmptyMVar, newMVar, putMVar,
readMVar, swapMVar, takeMVar, _MVar,
newIVar, readIVar, writeIVar, _IVar,
IVar(..), MVar(..),
threadWait, threadDelay
)
import GHCbase
forkIO :: IO () -> IO ()
forkIO action s
= let
forkIO (IO (ST action)) = IO $ ST $ \ s ->
let
(_, new_s) = action s
in
new_s `_fork_` (Right (), s)
where
_fork_ x y = case (fork# x) of { 0# -> parError#; _ -> y }
\end{code}
new_s `fork` (Right (), s)
{-
%
% (c) The GRASP/AQUA Project, Glasgow University, 1995
%
......@@ -7,6 +8,7 @@ Avoiding the loss of ref. transparency by attaching the merge to the
IO monad.
\begin{code}
-}
module Merge
(
......@@ -18,12 +20,6 @@ import Semaphore
import PreludeGlaST
import Concurrent ( forkIO )
import PreludePrimIO ( newEmptyMVar, newMVar, putMVar,
readMVar, takeMVar, _MVar
)
\end{code}
\begin{code}
max_buff_size = 1
......@@ -52,9 +48,9 @@ mergeIO ls rs
return val
type Buffer a
= (_MVar (_MVar [a]), QSem)
= (MVar (MVar [a]), QSem)
suckIO :: _MVar Int -> Buffer a -> [a] -> IO ()
suckIO :: MVar Int -> Buffer a -> [a] -> IO ()
suckIO branches_running buff@(tail_list,e) vs
= case vs of
......@@ -94,24 +90,5 @@ nmergeIO lss
return val
where
mapIO f xs = accumulate (map f xs)
\end{code}
So as to avoid creating a mutual recursive module dep. with @Concurrent.lhs@,
the defn. of @forkIO@ is duplicated here:
\begin{code}
{- HAH! WDP 95/07
forkIO :: PrimIO a -> PrimIO a
forkIO action s
= let
(r, new_s) = action s
in
new_s `_fork_` (r, s)
where
_fork_ x y = case (fork# x) of { 0# -> parError#; _ -> y }
-}
#endif {- __CONCURRENT_HASKELL__ -}
\end{code}
{-
%
% (c) The GRASP/AQUA Project, Glasgow University, 1995-1996
%
\section[Parallel]{Parallel Constructs}
-}
module Parallel (par, seq -- re-exported
#if defined(__GRANSIM__)
, parGlobal, parLocal, parAt, parAtForNow
#endif
) where
import GHCbase ( par, seq )
#if defined(__GRANSIM__)
{-# INLINE parGlobal #-}
parGlobal :: Int -> Int -> Int -> Int -> a -> b -> b
parLocal :: Int -> Int -> Int -> Int -> a -> b -> b
parAt :: Int -> Int -> Int -> Int -> a -> b -> c -> c
parAtForNow :: Int -> Int -> Int -> Int -> a -> b -> c -> c
parGlobal (I# w) (I# g) (I# s) (I# p) x y = case (parGlobal# x w g s p y) of { 0# -> parError; _ -> y }
parLocal (I# w) (I# g) (I# s) (I# p) x y = case (parLocal# x w g s p y) of { 0# -> parError; _ -> y }
parAt (I# w) (I# g) (I# s) (I# p) v x y = case (parAt# x v w g s p y) of { 0# -> parError; _ -> y }
parAtForNow (I# w) (I# g) (I# s) (I# p) v x y = case (parAtForNow# x v w g s p y) of { 0# -> parError; _ -> y }
#endif
-- Maybe parIO and the like could be added here later.
{-
%
% (c) The GRASP/AQUA Project, Glasgow University, 1995
%
......@@ -15,11 +16,11 @@ potentially, wakes up a blocked reader (same as for @putMVar@ on empty @MVar@).
\item Writing to a filled @SampleVar@ overwrites the current value.
(different from @putMVar@ on full @MVar@.)
\end{itemize}
-}
\begin{code}
module SampleVar
(
SampleVar(..), --:: type _ =
SampleVar, --:: type _ =
newSampleVar, --:: IO (SampleVar a)
emptySampleVar, --:: SampleVar a -> IO ()
......@@ -28,25 +29,15 @@ module SampleVar
) where
import PreludeGlaST
import PreludePrimIO ( newEmptyMVar, newMVar, putMVar,
readMVar, swapMVar, takeMVar, _MVar
)
\end{code}
\begin{code}
import GHCbase
type SampleVar a
= _MVar (Int, -- 1 == full
= MVar (Int, -- 1 == full
-- 0 == empty
-- <0 no of readers blocked
_MVar a)
\end{code}
MVar a)
Initally, a @SampleVar@ is empty/unfilled.
\begin{code}
-- Initally, a @SampleVar@ is empty/unfilled.
newSampleVar :: IO (SampleVar a)
newSampleVar
......@@ -61,12 +52,6 @@ emptySampleVar v
else
putMVar v (readers,var)
\end{code}
\begin{code}
--
-- filled => make empty and grab sample
-- not filled => try to grab value, empty when read val.
......@@ -91,5 +76,3 @@ writeSample svar v
_ ->
putMVar val v >>
putMVar svar (min 1 (readers+1), val)
\end{code}
{-
%
% (c) The GRASP/AQUA Project, Glasgow University, 1995
%
......@@ -5,9 +6,8 @@
General/quantity semaphores
\begin{code}
-}
module Semaphore
(
{- abstract -}
QSem,
......@@ -24,21 +24,18 @@ module Semaphore
) where
import PreludeGlaST
import PreludePrimIO ( newEmptyMVar, newMVar, putMVar,
readMVar, takeMVar, _MVar
)
\end{code}
General semaphores are also implemented readily in terms of shared @MVar@s,
only have to catch the case when the semaphore is tried waited on
when it is empty (==0). Implement this in the same way as shared variables are
implemented - maintaining a list of @MVar@s representing threads currently
waiting. The counter is a shared variable, ensuring the mutual exclusion on its access.
import GHCbase
\begin{code}
{-
General semaphores are also implemented readily in terms of shared
@MVar@s, only have to catch the case when the semaphore is tried
waited on when it is empty (==0). Implement this in the same way as
shared variables are implemented - maintaining a list of @MVar@s
representing threads currently waiting. The counter is a shared
variable, ensuring the mutual exclusion on its access.
-}
data QSem = QSem (_MVar (Int, [_MVar ()]))
data QSem = QSem (MVar (Int, [MVar ()]))
newQSem :: Int -> IO QSem
newQSem init
......@@ -77,12 +74,8 @@ signalQSem (QSem sem)
putMVar block () >>
return ()
\end{code}
\begin{code}
data QSemN
= QSemN (_MVar (Int,[(Int,_MVar ())]))
= QSemN (MVar (Int,[(Int,MVar ())]))
newQSemN :: Int -> IO QSemN
newQSemN init
......@@ -117,6 +110,3 @@ signalQSemN (QSemN sem) n
else
free avail blocked >>= \ (avail',blocked') ->
return (avail',(req,block):blocked')
\end{code}
{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
_runST :: (_State _RealWorld -> (b, a)) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ #-}
_trace :: [Char] -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "SL" _N_ _N_ #-}
absent# :: a
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
error :: [Char] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
parError# :: a
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
patError# :: [Char] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
unpackAppendPS# :: Addr# -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "PL" _N_ _N_ #-}
unpackFoldrPS# :: Addr# -> (Char -> a -> a) -> a -> a
{-# GHC_PRAGMA _A_ 3 _U_ 222 _N_ _S_ "PLL" _N_ _N_ #-}
unpackPS# :: Addr# -> [Char]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
unpackPS2# :: Addr# -> Int# -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "PP" _N_ _N_ #-}
module PreludeBuiltin (
_runST,
_trace,
absent#,
error,