Only in Persistent_M3/pm3-1.1.15-unpacked/database: GRAS3
Only in Persistent_M3/pm3-1.1.15-unpacked/database: persistence
diff -r PolyMTL/pm3-1.1.15-unpacked/database/src/index.html Persistent_M3/pm3-1.1.15-unpacked/database/src/index.html
23a24,46
> GRAS3
> GRAS is a set of libraries and programs that together implement
> a structure-oriented client/server database management system. In general,
> structure-oriented DBMS offer a richer set of data types and constructors
> than e.g. relational DBMS. The data model of GRAS is the directed,
> attributed, node and edge labelled graph. GRAS is not intended as a
> stand-alone system, but must be accessed via its application programming
> interface.
> Orthogonal Persistence
> Libraries and HREF="../persistence/libpm3common/src">interfaces to orthogonally
> persistent distributed storage for Modula-3 objects. Persistent storage is
> (by default) provided by the GRAS3 transactional page server. An
> experimental binding to the SHORE object store is also available on
> machines where SHORE is installed. Example applications include
> implementations of the OO7
> traversal operations and a HREF="../persistence/primes/src">prime number generator that starts
> generating prime numbers where it left off in its previous invocation.
> Orthogonally persistent applications run as clients of the GRAS3 page
> server (or SHORE server), which must be running before they can
> execute. See the information on getting started with GRAS3 in the GRAS3 REL = INCLUDE HREF="../GRAS3/README">README.
diff -r PolyMTL/pm3-1.1.15-unpacked/graphics/animation/anim3D/src/m3makefile Persistent_M3/pm3-1.1.15-unpacked/graphics/animation/anim3D/src/m3makefile
87c87
< Module ("PropList")
---
> List ("Prop", "Prop")
Only in PolyMTL/pm3-1.1.15-unpacked/graphics/animation/anim3D/src: PropList.i3
Only in PolyMTL/pm3-1.1.15-unpacked/graphics/animation/anim3D/src: PropList.m3
Only in PolyMTL/pm3-1.1.15-unpacked/graphics/animation/mentor/src/kpaths: AtomEdgeTbl.i3
Only in PolyMTL/pm3-1.1.15-unpacked/graphics/animation/mentor/src/kpaths: AtomEdgeTbl.m3
Only in PolyMTL/pm3-1.1.15-unpacked/graphics/animation/mentor/src/kpaths: AtomVertexTbl.i3
Only in PolyMTL/pm3-1.1.15-unpacked/graphics/animation/mentor/src/kpaths: AtomVertexTbl.m3
Only in PolyMTL/pm3-1.1.15-unpacked/graphics/animation/mentor/src/kpaths: EdgeSeq.i3
Only in PolyMTL/pm3-1.1.15-unpacked/graphics/animation/mentor/src/kpaths: EdgeSeq.m3
Only in PolyMTL/pm3-1.1.15-unpacked/graphics/animation/mentor/src/kpaths: EdgeSeqRep.i3
diff -r PolyMTL/pm3-1.1.15-unpacked/graphics/animation/mentor/src/kpaths/m3makefile Persistent_M3/pm3-1.1.15-unpacked/graphics/animation/mentor/src/kpaths/m3makefile
14,17c14,15
< interface("EdgeSeqRep")
< interface("VertexSeqRep")
< module("EdgeSeq")
< module("VertexSeq")
---
> sequence ("Edge", "Edge")
> sequence("Vertex", "Vertex")
19,20c17,18
< module("AtomEdgeTbl")
< module("AtomVertexTbl")
---
> table("AtomEdge", "Atom", "Edge")
> table("AtomVertex", "Atom", "Vertex")
Only in PolyMTL/pm3-1.1.15-unpacked/graphics/animation/mentor/src/kpaths: VertexSeq.i3
Only in PolyMTL/pm3-1.1.15-unpacked/graphics/animation/mentor/src/kpaths: VertexSeq.m3
Only in PolyMTL/pm3-1.1.15-unpacked/graphics/animation/mentor/src/kpaths: VertexSeqRep.i3
diff -r PolyMTL/pm3-1.1.15-unpacked/graphics/animation/mentor/src/minimax/m3makefile Persistent_M3/pm3-1.1.15-unpacked/graphics/animation/mentor/src/minimax/m3makefile
18c18
< module ("MoveList")
---
> list ("Move", "GameMove")
Only in PolyMTL/pm3-1.1.15-unpacked/graphics/animation/mentor/src/minimax: MoveList.i3
Only in PolyMTL/pm3-1.1.15-unpacked/graphics/animation/mentor/src/minimax: MoveList.m3
diff -r PolyMTL/pm3-1.1.15-unpacked/graphics/animation/mgkit/src/MGRd.m3 Persistent_M3/pm3-1.1.15-unpacked/graphics/animation/mgkit/src/MGRd.m3
69c69
< t.buff := NEW(REF ARRAY OF CHAR, 1);
---
> t.buff := NEW(<*TRANSIENT*> REF ARRAY OF CHAR, 1);
diff -r PolyMTL/pm3-1.1.15-unpacked/graphics/animation/rehearsecode/src/RehearseCode.m3 Persistent_M3/pm3-1.1.15-unpacked/graphics/animation/rehearsecode/src/RehearseCode.m3
53c53
< st := 0, buff := NEW (REF ARRAY OF CHAR, BufferSize),
---
> st := 0, buff := NEW (<*TRANSIENT*> REF ARRAY OF CHAR, BufferSize),
diff -r PolyMTL/pm3-1.1.15-unpacked/graphics/gr-libs/jvideo/src/POSIX/JVConverter.i3 Persistent_M3/pm3-1.1.15-unpacked/graphics/gr-libs/jvideo/src/POSIX/JVConverter.i3
17c17
< Private <: ROOT;
---
> Private <: <*TRANSIENT*> ROOT;
diff -r PolyMTL/pm3-1.1.15-unpacked/graphics/gr-libs/ui/src/picture/Picture.i3 Persistent_M3/pm3-1.1.15-unpacked/graphics/gr-libs/ui/src/picture/Picture.i3
22c22
< TYPE T <: ROOT;
---
> TYPE T <: <*TRANSIENT*> ROOT;
diff -r PolyMTL/pm3-1.1.15-unpacked/graphics/gr-libs/ui/src/vbt/Trestle.i3 Persistent_M3/pm3-1.1.15-unpacked/graphics/gr-libs/ui/src/vbt/Trestle.i3
21c21
< T <: ROOT;
---
> T <: <*TRANSIENT*> ROOT;
diff -r PolyMTL/pm3-1.1.15-unpacked/graphics/gr-libs/ui/src/vbt/VBT.i3 Persistent_M3/pm3-1.1.15-unpacked/graphics/gr-libs/ui/src/vbt/VBT.i3
51c51
< Prefix <: ROOT;
---
> Prefix <: <*TRANSIENT*> ROOT;
diff -r PolyMTL/pm3-1.1.15-unpacked/graphics/gr-libs/vbtkit/src/etext/TypescriptVBT.m3 Persistent_M3/pm3-1.1.15-unpacked/graphics/gr-libs/vbtkit/src/etext/TypescriptVBT.m3
111c111,112
< buff := NEW (REF ARRAY OF CHAR, TerminalReaderBuffSize),
---
> buff := NEW (<*TRANSIENT*> REF ARRAY OF CHAR,
> TerminalReaderBuffSize),
115c116,117
< st := 0, buff := NEW (REF ARRAY OF CHAR, TerminalWriterBuffSize),
---
> st := 0, buff := NEW (<*TRANSIENT*> REF ARRAY OF CHAR,
> TerminalWriterBuffSize),
diff -r PolyMTL/pm3-1.1.15-unpacked/graphics/gr-libs/vbtkit/src/lego/ChoiceVBT.i3 Persistent_M3/pm3-1.1.15-unpacked/graphics/gr-libs/vbtkit/src/lego/ChoiceVBT.i3
54c54
< TYPE Group <: ROOT;
---
> TYPE Group <: <*TRANSIENT*> ROOT;
diff -r PolyMTL/pm3-1.1.15-unpacked/graphics/gr-libs/vbtkit/src/mtext/MTextRd.m3 Persistent_M3/pm3-1.1.15-unpacked/graphics/gr-libs/vbtkit/src/mtext/MTextRd.m3
30c30
< chars : REF ARRAY OF CHAR := NIL
---
> chars : <*TRANSIENT*> REF ARRAY OF CHAR := NIL
67c67
< rd.chars := NEW (REF ARRAY OF CHAR, BufferSize)
---
> rd.chars := NEW (<*TRANSIENT*> REF ARRAY OF CHAR, BufferSize)
diff -r PolyMTL/pm3-1.1.15-unpacked/graphics/gr-libs/vbtkit/src/vbtkitutils/AutoRepeat.i3 Persistent_M3/pm3-1.1.15-unpacked/graphics/gr-libs/vbtkit/src/vbtkitutils/AutoRepeat.i3
55c55
< Private <: ROOT;
---
> Private <: <*TRANSIENT*> ROOT;
diff -r PolyMTL/pm3-1.1.15-unpacked/graphics/lecternpkg/lectern/src/Lectern.m3 Persistent_M3/pm3-1.1.15-unpacked/graphics/lecternpkg/lectern/src/Lectern.m3
30,31c30,31
< TempFiles, Text, TextPort, TextRd, TextSeq, TextWr, Thread,
< ThumbnailVBT, Time, Trestle, TrestleComm,
---
> TempFiles, Text, TextPort, TextRd, TextTransientSeq AS TextSeq,
> TextWr, Thread, ThumbnailVBT, Time, Trestle, TrestleComm,
diff -r PolyMTL/pm3-1.1.15-unpacked/graphics/lecternpkg/lectern/src/MyFileBrowserVBT.m3 Persistent_M3/pm3-1.1.15-unpacked/graphics/lecternpkg/lectern/src/MyFileBrowserVBT.m3
22,23c22,23
< TextList, TextListSort, TextPort, TextRd, TextSeq, TextVBT, Thread,
< Time, TypeinVBT, VBT, WeakRef;
---
> TextList, TextListSort, TextPort, TextRd, TextTransientSeq AS TextSeq,
> TextVBT, Thread, Time, TypeinVBT, VBT, WeakRef;
Only in Persistent_M3/pm3-1.1.15-unpacked/intro/src/questions: bookstore.html
diff -r PolyMTL/pm3-1.1.15-unpacked/language/m3quake/src/QMachine.m3 Persistent_M3/pm3-1.1.15-unpacked/language/m3quake/src/QMachine.m3
11c11
< IMPORT Wr, Thread, OSError, TextSeq, TextF, Pipe;
---
> IMPORT Wr, Thread, OSError, TextTransientSeq AS TextSeq, TextF, Pipe;
diff -r PolyMTL/pm3-1.1.15-unpacked/language/m3quake/src/QMachRep.i3 Persistent_M3/pm3-1.1.15-unpacked/language/m3quake/src/QMachRep.i3
3c3,4
< IMPORT QMachine, QCode, QValue, QVTbl, QVSeq, M3Buf, IntRefTbl, TextSeq;
---
> IMPORT QMachine, QCode, QValue, QVTbl, QVSeq, M3Buf, IntRefTbl,
> TextTransientSeq AS TextSeq;
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3bootstrap/src/m3makefile Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3bootstrap/src/m3makefile
274a275,276
> AS="/usr/ccs/bin/as"
> AR="/usr/ccs/bin/ld"
287c289
<
---
>
293c295
<
---
>
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc/config/m68k/mot3300-crt0.S Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc/config/m68k/mot3300-crt0.S
100c100
< STRING ("$Id: mot3300-crt0.S,v 1.1.1.1 1997/02/06 21:32:33 ldd Exp $\n")
---
> STRING ("$Id: mot3300-crt0.S,v 1.1.1.1 1998/10/28 21:28:02 hosking Exp $\n")
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc/config/m68k/mot3300Mcrt0.S Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc/config/m68k/mot3300Mcrt0.S
146c146
< STRING ("$Id: mot3300Mcrt0.S,v 1.1.1.1 1997/02/06 21:32:33 ldd Exp $\n")
---
> STRING ("$Id: mot3300Mcrt0.S,v 1.1.1.1 1998/10/28 21:28:03 hosking Exp $\n")
Only in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc: cp
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc/function.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc/function.c
4224,4229d4223
<
< pad_to_arg_alignment (offset_ptr, boundary);
< if (where_pad == downward)
< pad_below (offset_ptr, passed_mode, sizetree);
< ADD_PARM_SIZE (*arg_size_ptr, sizetree);
< /**************** W.Kalsow 5/24/95 I'm confused... **************
4232d4225
<
4246,4247d4238
< *****************************************************************/
<
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc/gcc.1 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc/gcc.1
23c23
< .Id $Id: gcc.1,v 1.2 1997/02/07 20:01:12 ldd Exp $
---
> .Id $Id: gcc.1,v 1.1.1.1 1998/10/28 21:27:17 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc/genemit.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc/genemit.c
215d214
< printf (
216a216
> printf (
217a218
> INTVAL (x));
218a220
> printf (
220d221
< #endif
221a223
> #endif
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc/genrecog.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc/genrecog.c
1354d1353
< printf (
1355a1355
> printf (
1356a1357
> depth, p->elt_zero_wide + offset, offset ? "-1" : "");
1357a1359
> printf (
1359d1360
< #endif
1360a1362
> #endif
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc/just-fixinc Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc/just-fixinc
2c2
< # $Id: just-fixinc,v 1.2 1997/02/07 20:01:13 ldd Exp $
---
> # $Id: just-fixinc,v 1.1.1.1 1998/10/28 21:27:21 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc/Makefile.in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc/Makefile.in
68,69c68,69
< BISON = `if [ -f $(objdir)/../byacc/byacc ] ; then echo $(objdir)/../byacc/byacc ; else echo byacc ; fi`
< BISONFLAGS =
---
> BISON = yacc
> BISONFLAGS =
Only in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc: objc
Only in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3cc/gcc: testsuite
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinOps/Adr.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinOps/Adr.m3
20c20
< t := RefType.New (Expr.TypeOf (ce.args[0]), FALSE, NIL);
---
> t := RefType.New (Expr.TypeOf (ce.args[0]), FALSE, FALSE, NIL);
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinOps/Dispose.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinOps/Dispose.m3
12c12,13
< IMPORT Addr, Reff, Module, Error, ObjectRef, ObjectAdr, Target;
---
> IMPORT Addr, Reff, ReffTransient, Module, Error, ObjectRef, ObjectTransient,
> ObjectAdr, Target;
25a27
> OR Type.IsEqual (t, ReffTransient.T, NIL)
27a30
> OR Type.IsEqual (t, ObjectTransient.T, NIL)
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinOps/New.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinOps/New.m3
160c160,161
< newType := ObjectType.New (t, info.isTraced, NIL, fields, overrides);
---
> newType := ObjectType.New (t, info.isTraced, info.isTransient, NIL,
> fields, overrides);
249,250c250,253
< CONST PHook = ARRAY BOOLEAN OF Runtime.Hook { Runtime.Hook.NewUntracedRef,
< Runtime.Hook.NewTracedRef };
---
> TYPE TT = ARRAY BOOLEAN OF Runtime.Hook;
> CONST PHook = ARRAY BOOLEAN OF TT
> { TT { Runtime.Hook.NewUntracedRef, Runtime.Hook.NewUntracedRef },
> TT { Runtime.Hook.NewTracedRef, Runtime.Hook.NewTransientRef } };
262c265
< GenOpenArray (t, t_info.isTraced, r_info, ce);
---
> GenOpenArray (t, t_info.isTraced, t_info.isTransient, r_info, ce);
265c268
< GenRecord (t, base, t_info.isTraced, r_info, ce);
---
> GenRecord (t, base, t_info.isTraced, t_info.isTransient, r_info, ce);
268c271
< proc := Runtime.LookUpProc (PHook [t_info.isTraced]);
---
> proc := Runtime.LookUpProc (PHook [t_info.isTraced, t_info.isTransient]);
277c280
< PROCEDURE GenOpenArray (t: Type.T; traced: BOOLEAN;
---
> PROCEDURE GenOpenArray (t: Type.T; traced, transient: BOOLEAN;
279,280c282,285
< CONST PHook = ARRAY BOOLEAN OF Runtime.Hook { Runtime.Hook.NewUntracedArray,
< Runtime.Hook.NewTracedArray };
---
> TYPE TT = ARRAY BOOLEAN OF Runtime.Hook;
> CONST PHook = ARRAY BOOLEAN OF TT
> { TT { Runtime.Hook.NewUntracedArray, Runtime.Hook.NewUntracedArray },
> TT { Runtime.Hook.NewTracedArray, Runtime.Hook.NewTransientArray } };
287c292
< proc := Runtime.LookUpProc (PHook [traced]);
---
> proc := Runtime.LookUpProc (PHook [traced, transient]);
325c330
< PROCEDURE GenRecord (t, r: Type.T; traced: BOOLEAN;
---
> PROCEDURE GenRecord (t, r: Type.T; traced, transient: BOOLEAN;
327,328c332,335
< CONST PHook = ARRAY BOOLEAN OF Runtime.Hook { Runtime.Hook.NewUntracedRef,
< Runtime.Hook.NewTracedRef };
---
> TYPE TT = ARRAY BOOLEAN OF Runtime.Hook;
> CONST PHook = ARRAY BOOLEAN OF TT
> { TT { Runtime.Hook.NewUntracedRef, Runtime.Hook.NewUntracedRef },
> TT { Runtime.Hook.NewTracedRef, Runtime.Hook.NewTransientRef } };
335c342
< proc := Runtime.LookUpProc (PHook [traced]);
---
> proc := Runtime.LookUpProc (PHook [traced, transient]);
359,360c366,369
< CONST PHook = ARRAY BOOLEAN OF Runtime.Hook { Runtime.Hook.NewUntracedObj,
< Runtime.Hook.NewTracedRef };
---
> TYPE TT = ARRAY BOOLEAN OF Runtime.Hook;
> CONST PHook = ARRAY BOOLEAN OF TT
> { TT { Runtime.Hook.NewUntracedObj, Runtime.Hook.NewUntracedObj },
> TT { Runtime.Hook.NewTracedRef, Runtime.Hook.NewTransientRef } };
374c383
< proc := Runtime.LookUpProc (PHook [info.isTraced]);
---
> proc := Runtime.LookUpProc (PHook [info.isTraced, info.isTransient]);
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinOps/Typecode.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinOps/Typecode.m3
12c12
< IMPORT Reff, TypeExpr, ObjectType, M3RT;
---
> IMPORT Reff, ReffTransient, TypeExpr, ObjectType, M3RT;
22a23,24
> Error.Msg ("TYPECODE: T must be a fixed reference type");
> ELSIF (Type.IsEqual (t, ReffTransient.T, NIL)) THEN
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/Addr.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/Addr.m3
15c15,16
< T := RefType.New (NIL, FALSE, TextExpr.New (M3String.Add ("$address$")));
---
> T := RefType.New (NIL, traced := FALSE, transient := TRUE,
> brand := TextExpr.New (M3String.Add ("$address$")));
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/BuiltinTypes.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/BuiltinTypes.m3
12c12,13
< IMPORT Null, Reff, Textt, Mutex, ErrType, ObjectRef, ObjectAdr;
---
> IMPORT Null, Reff, ReffTransient, Textt, Mutex, ErrType, ObjectRef, ObjectAdr,
> ObjectTransient;
29a31
> ReffTransient.Initialize ();
31a34
> ObjectTransient.Initialize ();
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/EReel.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/EReel.m3
36a37
> p.info.isTransient := TRUE;
58c59,60
< PROCEDURE GenMap (<*UNUSED*> p: P; offset, size: INTEGER; refs_only: BOOLEAN) =
---
> PROCEDURE GenMap (<*UNUSED*> p: P; offset, size: INTEGER; refs_only: BOOLEAN;
> <*UNUSED*> transient: BOOLEAN) =
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/ErrType.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/ErrType.m3
36a37
> p.info.isTransient := TRUE;
60c61
< <*UNUSED*> refs_only: BOOLEAN) =
---
> <*UNUSED*> refs_only, transient: BOOLEAN) =
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/Int.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/Int.m3
36a37
> p.info.isTransient := TRUE;
58c59,60
< PROCEDURE GenMap (<*UNUSED*> p: P; offset, size: INTEGER; refs_only: BOOLEAN) =
---
> PROCEDURE GenMap (<*UNUSED*> p: P; offset, size: INTEGER; refs_only: BOOLEAN;
> <*UNUSED*> transient: BOOLEAN) =
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/LReel.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/LReel.m3
36a37
> p.info.isTransient := TRUE;
58c59,60
< PROCEDURE GenMap (<*UNUSED*> p: P; offset, size: INTEGER; refs_only: BOOLEAN) =
---
> PROCEDURE GenMap (<*UNUSED*> p: P; offset, size: INTEGER; refs_only: BOOLEAN;
> <*UNUSED*> transient: BOOLEAN) =
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/m3makefile Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/m3makefile
21a22
> module ("ObjectTransient")
23a25
> module ("ReffTransient")
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/Mutex.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/Mutex.m3
11c11
< IMPORT ObjectRef, Tipe;
---
> IMPORT ObjectTransient, Tipe;
15c15
< T := Tipe.DefineOpaque ("MUTEX", ObjectRef.T);
---
> T := Tipe.DefineOpaque ("MUTEX", ObjectTransient.T);
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/Null.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/Null.m3
15c15,16
< T := RefType.New (NIL, FALSE, TextExpr.New (M3String.Add ("$null$")));
---
> T := RefType.New (NIL, traced := FALSE, transient := TRUE,
> brand := TextExpr.New (M3String.Add ("$null$")));
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/ObjectAdr.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/ObjectAdr.m3
19c19
< T := ObjectType.New (NIL, FALSE, NIL, s, s);
---
> T := ObjectType.New (NIL, FALSE, TRUE, NIL, s, s);
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/ObjectRef.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/ObjectRef.m3
19c19
< T := ObjectType.New (NIL, TRUE, NIL, s, s);
---
> T := ObjectType.New (NIL, TRUE, FALSE, NIL, s, s);
Only in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes: ObjectTransient.i3
Only in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes: ObjectTransient.m3
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/Reel.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/Reel.m3
36a37
> p.info.isTransient := TRUE;
58c59,60
< PROCEDURE GenMap (<*UNUSED*> p: P; offset, size: INTEGER; refs_only: BOOLEAN) =
---
> PROCEDURE GenMap (<*UNUSED*> p: P; offset, size: INTEGER; refs_only: BOOLEAN;
> <*UNUSED*> transient: BOOLEAN) =
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/Reff.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes/Reff.m3
15c15,16
< T := RefType.New (NIL, TRUE, TextExpr.New (M3String.Add ("$refany$")));
---
> T := RefType.New (NIL, traced := TRUE, transient := FALSE,
> brand := TextExpr.New (M3String.Add ("$refany$")));
Only in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes: ReffTransient.i3
Only in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/builtinTypes: ReffTransient.m3
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/exprs/ArrayExpr.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/exprs/ArrayExpr.m3
147c147
< elt_info: Type.Info;
---
> info, elt_info: Type.Info;
218c218,221
< p.solidType := ArrayType.New (index, solidElt);
---
> EVAL Type.CheckInfo (p.tipe, info);
> p.solidType :=
> ArrayType.New (info.isTransient AND NOT elt_info.isTransient,
> index, solidElt);
224c227,228
< p.refType := RefType.New (p.tipe, traced := TRUE, brand := NIL);
---
> p.refType := RefType.New (p.tipe, traced := TRUE, transient := TRUE,
> brand := NIL, warn := TRUE);
489c493
< proc := Runtime.LookUpProc (Runtime.Hook.NewTracedArray);
---
> proc := Runtime.LookUpProc (Runtime.Hook.NewTransientArray);
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/exprs/ExprParse.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/exprs/ExprParse.m3
197c197
< | TK.tBRANDED, TK.tLBRACE, TK.tUNTRACED, TK.tOBJECT,
---
> | TK.tBRANDED, TK.tLBRACE, TK.tUNTRACED, TK.tOBJECT, TK.tTRANSIENT,
260c260
< a := TypeExpr.New (ObjectType.Parse (t, TRUE, brand));
---
> a := TypeExpr.New (ObjectType.Parse (t, TRUE, FALSE, brand));
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/CG.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/CG.i3
107c107,108
< PROCEDURE Declare_pointer (t, target: TypeUID; brand: TEXT; traced: BOOLEAN);
---
> PROCEDURE Declare_pointer (t, target: TypeUID; brand: TEXT;
> traced, transient: BOOLEAN);
118,119c119,122
< PROCEDURE Declare_object (t, super: TypeUID; brand: TEXT; traced: BOOLEAN;
< n_fields, n_methods, n_overrides: INTEGER; field_size: Size);
---
> PROCEDURE Declare_object (t, super: TypeUID; brand: TEXT;
> traced, transient: BOOLEAN;
> n_fields, n_methods, n_overrides: INTEGER;
> field_size: Size);
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/CG.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/CG.m3
267c267,268
< PROCEDURE Declare_pointer (t, target: TypeUID; brand: TEXT; traced: BOOLEAN)=
---
> PROCEDURE Declare_pointer (t, target: TypeUID; brand: TEXT;
> traced, transient: BOOLEAN)=
270c271
< WebInfo.Declare_pointer (t, target, brand, traced);
---
> WebInfo.Declare_pointer (t, target, brand, traced, transient);
306,308c307,310
< PROCEDURE Declare_object (t, super: TypeUID; brand: TEXT; traced: BOOLEAN;
< n_fields, n_methods, n_overrides: INTEGER;
< field_size: Size) =
---
> PROCEDURE Declare_object (t, super: TypeUID; brand: TEXT;
> traced, transient: BOOLEAN;
> n_fields, n_methods, n_overrides: INTEGER;
> field_size: Size) =
312c314
< WebInfo.Declare_object (t, super, brand, traced,
---
> WebInfo.Declare_object (t, super, brand, traced, transient,
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/Runtime.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/Runtime.i3
20c20
< NewTracedRef, NewTracedArray,
---
> NewTracedRef, NewTransientRef, NewTracedArray, NewTransientArray,
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/Runtime.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/Runtime.m3
14c14
< ActualHook = [0..14];
---
> ActualHook = [0..16];
24a25
> "AllocateTransient",
25a27
> "AllocateTransientOpenArray",
36,37c38,39
< 11, 12, 13, 14, 14, 14, 14, 14, 14,
< 14, 14, 14 };
---
> 11, 12, 13, 14, 15, 16, 16, 16, 16,
> 16, 16, 16, 16, 16 };
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/TipeMap.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/TipeMap.i3
23c23,24
< (*50*) SkipB_1, SkipB_2, SkipB_3, SkipB_4, SkipB_5, SkipB_6, SkipB_7, SkipB_8
---
> (*50*) SkipB_1, SkipB_2, SkipB_3, SkipB_4, SkipB_5, SkipB_6, SkipB_7, SkipB_8,
> (*58*) TransientRef
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/TipeMap.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/TipeMap.m3
71c71,72
< 8 (* SkipB_8 *)
---
> 8, (* SkipB_8 *)
> 0 (* TransientRef *)
133c134,135
< -7 (* SkipB_8 *)
---
> -7, (* SkipB_8 *)
> -8 (* TransientRef *)
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/Token.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/Token.i3
30c30
< tINLINE, tEXTERNAL, tASSERT, tUNUSED, tOBSOLETE, tTRACE,
---
> tINLINE, tEXTERNAL, tASSERT, tUNUSED, tOBSOLETE, tTRACE, tTRANSIENT,
77c77
< T.tREF, T.tSET, T.tLBRACKET, T.tLPAREN};
---
> T.tREF, T.tSET, T.tTRANSIENT, T.tLBRACKET, T.tLPAREN};
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/Token.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/Token.m3
25c25
< "INLINE", "EXTERNAL", "ASSERT", "UNUSED", "OBSOLETE", "TRACE",
---
> "INLINE", "EXTERNAL", "ASSERT", "UNUSED", "OBSOLETE", "TRACE", "TRANSIENT",
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/WebInfo.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/WebInfo.i3
64c64,65
< PROCEDURE Declare_pointer (t, target: TypeUID; brand: TEXT; traced: BOOLEAN);
---
> PROCEDURE Declare_pointer (t, target: TypeUID; brand: TEXT;
> traced, transient: BOOLEAN);
73,74c74,77
< PROCEDURE Declare_object (t, super: TypeUID; brand: TEXT; traced: BOOLEAN;
< n_fields, n_methods, n_overrides: INTEGER; field_size: Size);
---
> PROCEDURE Declare_object (t, super: TypeUID; brand: TEXT;
> traced, transient: BOOLEAN;
> n_fields, n_methods, n_overrides: INTEGER;
> field_size: Size);
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/WebInfo.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/misc/WebInfo.m3
140,141c140,144
< PROCEDURE Declare_pointer (t, target: TypeUID; brand: TEXT; traced: BOOLEAN) =
< CONST Tag = ARRAY BOOLEAN OF CHAR { 'O', 'P' };
---
> PROCEDURE Declare_pointer (t, target: TypeUID; brand: TEXT;
> traced, transient: BOOLEAN) =
> CONST Tag = ARRAY BOOLEAN, BOOLEAN OF CHAR
> { ARRAY BOOLEAN OF CHAR { 'O', 'O' },
> ARRAY BOOLEAN OF CHAR { 'P', 'p' } };
143c146
< OutX (t, Tag [traced]);
---
> OutX (t, Tag [traced, transient]);
184,186c187,193
< PROCEDURE Declare_object (t, super: TypeUID; brand: TEXT; traced: BOOLEAN;
< n_fields, n_methods, n_overrides: INTEGER; field_size: Size) =
< CONST Tag = ARRAY BOOLEAN OF CHAR { 'U', 'V' };
---
> PROCEDURE Declare_object (t, super: TypeUID; brand: TEXT;
> traced, transient: BOOLEAN;
> n_fields, n_methods, n_overrides: INTEGER;
> field_size: Size) =
> CONST Tag = ARRAY BOOLEAN, BOOLEAN OF CHAR
> { ARRAY BOOLEAN OF CHAR { 'U', 'U' },
> ARRAY BOOLEAN OF CHAR { 'V', 'v' } };
188c195
< OutX (t, Tag[traced]);
---
> OutX (t, Tag[traced, transient]);
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/ArrayType.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/ArrayType.i3
13c13
< PROCEDURE Parse (): Type.T;
---
> PROCEDURE Parse (transient: BOOLEAN): Type.T;
15c15
< PROCEDURE New (index, element: Type.T): Type.T;
---
> PROCEDURE New (transient: BOOLEAN; index, element: Type.T): Type.T;
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/ArrayType.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/ArrayType.m3
28a29
> transient : BOOLEAN;
42c43
< PROCEDURE Parse (): Type.T =
---
> PROCEDURE Parse (transient: BOOLEAN): Type.T =
48c49
< p0 := New (NIL, NIL); p := p0;
---
> p0 := New (transient, NIL, NIL); p := p0;
53c54
< p.element := New (NIL, NIL);
---
> p.element := New (FALSE, NIL, NIL);
62c63
< RETURN OpenArrayType.New (Type.Parse ());
---
> RETURN OpenArrayType.New (transient, Type.Parse ());
66c67
< PROCEDURE New (index, element: Type.T): Type.T =
---
> PROCEDURE New (transient: BOOLEAN; index, element: Type.T): Type.T =
79a81
> p.transient := transient;
126c128
< p.openCousin := OpenArrayType.New (p.element);
---
> p.openCousin := OpenArrayType.New (p.transient, p.element);
214a217,221
> IF p.transient AND elt_info.isTransient THEN
> Error.Warn (1, "array type already transient, <*TRANSIENT*> ignored");
> END;
> p.info.isTransient := p.transient OR elt_info.isTransient;
>
354c361
< PROCEDURE GenMap (p: P; offset, size: INTEGER; refs_only: BOOLEAN) =
---
> PROCEDURE GenMap (p: P; offset, size: INTEGER; refs_only, transient: BOOLEAN) =
359c366,367
< Type.GenMap (p.element, offset, p.elt_pack, refs_only);
---
> Type.GenMap (p.element, offset, p.elt_pack, refs_only,
> p.transient OR transient);
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/EnumType.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/EnumType.m3
138a139
> p.info.isTransient := TRUE;
209c210,211
< PROCEDURE GenMap (<*UNUSED*> p: P; offset, size: INTEGER; refs_only: BOOLEAN) =
---
> PROCEDURE GenMap (<*UNUSED*> p: P; offset, size: INTEGER; refs_only: BOOLEAN;
> <*UNUSED*> transient: BOOLEAN) =
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/NamedType.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/NamedType.m3
61c61
< t := ObjectType.Parse (t, FALSE, RefType.ParseBrand ());
---
> t := ObjectType.Parse (t, FALSE, FALSE, RefType.ParseBrand ());
63c63
< t := ObjectType.Parse (t, FALSE, NIL);
---
> t := ObjectType.Parse (t, FALSE, FALSE, NIL);
197c197
< PROCEDURE GenMap (p: P; offset, size: INTEGER; refs_only: BOOLEAN) =
---
> PROCEDURE GenMap (p: P; offset, size: INTEGER; refs_only, transient: BOOLEAN) =
200c200
< Type.GenMap (p.type, offset, size, refs_only);
---
> Type.GenMap (p.type, offset, size, refs_only, transient);
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/ObjectType.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/ObjectType.i3
14c14,15
< PROCEDURE Parse (super: Type.T; traced: BOOLEAN; brand: Expr.T): Type.T;
---
> PROCEDURE Parse (super: Type.T; traced, transient: BOOLEAN; brand: Expr.T):
> Type.T;
16c17
< PROCEDURE New (super: Type.T; traced: BOOLEAN; brand: Expr.T;
---
> PROCEDURE New (super: Type.T; traced, transient: BOOLEAN; brand: Expr.T;
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/ObjectType.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/ObjectType.m3
14,15c14,16
< IMPORT Field, Reff, Addr, RefType, Word, TextExpr, M3Buf, ErrType;
< IMPORT ObjectAdr, ObjectRef, Token, Module, Method;
---
> IMPORT Field, Reff, ReffTransient, Addr, RefType, Word, TextExpr, M3Buf,
> ErrType;
> IMPORT ObjectAdr, ObjectRef, ObjectTransient, Token, Module, Method;
39a41
> isTransient : BOOLEAN;
57a60
> TROOT_ID: INTEGER := 0;
59c62,63
< PROCEDURE Parse (sup: Type.T; traced: BOOLEAN; brand: Expr.T): Type.T =
---
> PROCEDURE Parse (sup: Type.T; traced, transient: BOOLEAN; brand: Expr.T):
> Type.T =
64c68
< p := New (sup, traced, brand, NIL, NIL);
---
> p := New (sup, traced, transient, brand, NIL, NIL);
89a94
> transient := FALSE;
146,147c151,152
< PROCEDURE New (super: Type.T; traced: BOOLEAN; brand: Expr.T;
< fields, methods: Scope.T): Type.T =
---
> PROCEDURE New (super: Type.T; traced, transient: BOOLEAN; brand: Expr.T;
> fields, methods: Scope.T): Type.T =
151,154c156,162
< IF (traced)
< THEN super := ObjectRef.T;
< ELSE super := ObjectAdr.T;
< END;
---
> IF traced THEN
> IF transient THEN
> super := ObjectTransient.T;
> ELSE
> super := ObjectRef.T;
> END;
> ELSE super := ObjectAdr.T; END;
158a167
> p.isTransient := transient;
354a364
> p.isTransient := super_info.isTransient;
365a376
> p.isTransient := super_info.isTransient;
409a421
> p.info.isTransient := p.isTransient;
442c454,458
< IF (NOT p.isTraced) AND Module.IsSafe() THEN CheckTracedFields (p) END;
---
> IF p.isTraced THEN
> IF p.isTransient THEN CheckNonTransientFields (p) END;
> ELSE
> IF Module.IsSafe() THEN CheckTracedFields (p) END;
> END;
462a479,496
> PROCEDURE CheckNonTransientFields (p: P) =
> VAR fields := Scope.ToList (p.fields); info: Type.Info; field: Field.Info;
> BEGIN
> WHILE (fields # NIL) DO
> EVAL Type.CheckInfo (Value.TypeOf (fields), info);
> Field.Split (fields, field);
> IF NOT info.isTransient AND NOT field.transient THEN
> VAR save := Scanner.offset;
> BEGIN
> Scanner.offset := fields.origin;
> Error.Warn (1, "transient object contains a non-transient field");
> Scanner.offset := save;
> END;
> END;
> fields := fields.next;
> END;
> END CheckNonTransientFields;
>
488,489c522,523
< brand, p.isTraced, nFields, nMethods, nOverrides,
< p.fieldSize);
---
> brand, p.isTraced, p.isTransient, nFields, nMethods,
> nOverrides, p.fieldSize);
586c620,624
< CG.Init_intt (offset + M3RT.TC_traced, isz, 1);
---
> IF p.isTransient THEN
> CG.Init_intt (offset + M3RT.TC_traced, isz, 3);
> ELSE
> CG.Init_intt (offset + M3RT.TC_traced, isz, 1);
> END;
631c669
< Type.GenMap (field.type, field.offset, -1, refs_only);
---
> Type.GenMap (field.type, field.offset, -1, refs_only, field.transient);
810a849
> OR (a.isTransient # b.isTransient)
838d876
< VAR root := Reff.T;
840,841c878,885
< IF (NOT a.isTraced) THEN root := Addr.T END;
< IF Type.IsEqual (t, root, NIL) THEN RETURN TRUE END;
---
> IF a.isTraced THEN
> IF a.isTransient THEN
> IF Type.IsEqual (t, ReffTransient.T, NIL) THEN RETURN TRUE END;
> END;
> IF Type.IsEqual (t, Reff.T, NIL) THEN RETURN TRUE END;
> ELSE
> IF Type.IsEqual (t, Addr.T, NIL) THEN RETURN TRUE END;
> END;
859a904,906
> ELSIF Type.IsEqual (p, ObjectTransient.T, NIL) THEN
> x.tag := "$objecttransient";
> x.n_nodes := 0;
862c909,913
< IF (NOT p.isTraced) THEN M3Buf.PutText (x.buf, "-UNTRACED") END;
---
> IF p.isTraced THEN
> IF p.isTransient THEN M3Buf.PutText (x.buf, "-TRANSIENT") END;
> ELSE
> M3Buf.PutText (x.buf, "-UNTRACED");
> END;
1005a1057
> TROOT_ID := Type.GlobalUID (ObjectTransient.T);
1008c1060
< IF (t_id = NIL_ID) OR (t_id = ROOT_ID) OR (t_id = UROOT_ID) THEN
---
> IF t_id = NIL_ID OR t_id = ROOT_ID OR t_id = UROOT_ID OR t_id = TROOT_ID THEN
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/OpaqueType.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/OpaqueType.m3
19a20
> isTransient: BOOLEAN;
81a83
> p.isTransient := info.isTransient;
96a99
> p.info.isTransient := info.isTransient;
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/OpenArrayType.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/OpenArrayType.i3
13c13
< PROCEDURE New (element: Type.T): Type.T;
---
> PROCEDURE New (transient: BOOLEAN; element: Type.T): Type.T;
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/OpenArrayType.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/OpenArrayType.m3
20a21
> transient : BOOLEAN;
34c35
< PROCEDURE New (element: Type.T): Type.T =
---
> PROCEDURE New (transient: BOOLEAN; element: Type.T): Type.T =
42a44
> p.transient := transient;
118a121,125
> IF p.transient AND elt_info.isTransient THEN
> Error.Warn (1, "array type already transient, <*TRANSIENT*> ignored");
> END;
> p.info.isTransient := p.transient OR elt_info.isTransient;
>
276c283
< refs_only: BOOLEAN) =
---
> refs_only, transient: BOOLEAN) =
281c288,289
< Type.GenMap (OpenType (p), a, p.elt_pack, refs_only);
---
> Type.GenMap (OpenType (p), a, p.elt_pack, refs_only,
> p.transient OR transient);
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/PackedType.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/PackedType.m3
118a119
> p.info.isTransient := info.isTransient;
169c170
< PROCEDURE GenMap (p: P; offset, size: INTEGER; refs_only: BOOLEAN) =
---
> PROCEDURE GenMap (p: P; offset, size: INTEGER; refs_only, transient: BOOLEAN) =
172c173
< Type.GenMap (p.baseType, offset, size, refs_only);
---
> Type.GenMap (p.baseType, offset, size, refs_only, transient);
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/ProcType.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/ProcType.m3
218a219
> p.info.isTransient := TRUE;
473c474,475
< PROCEDURE GenMap (<*UNUSED*> p: P; offset, size: INTEGER; refs_only: BOOLEAN) =
---
> PROCEDURE GenMap (<*UNUSED*> p: P; offset, size: INTEGER; refs_only: BOOLEAN;
> <*UNUSED*> transient: BOOLEAN) =
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/RecordType.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/RecordType.i3
13c13
< PROCEDURE Parse (): Type.T;
---
> PROCEDURE Parse (transient: BOOLEAN): Type.T;
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/RecordType.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/RecordType.m3
14a15
> IMPORT Scanner;
21a23
> transient : BOOLEAN;
35c37
< PROCEDURE Parse (): Type.T =
---
> PROCEDURE Parse (transient: BOOLEAN): Type.T =
44a47
> p.transient := transient;
57c60,66
< WHILE (cur.token = TK.tIDENT) DO
---
> LOOP
> info.transient := FALSE;
> IF cur.token = TK.tTRANSIENT THEN
> GetToken (); Match (TK.tENDPRAGMA); (* <*TRANSIENT*> *)
> info.transient := TRUE;
> END;
> IF cur.token # TK.tIDENT THEN EXIT; END;
77,80c86,94
< FOR i := 0 TO n - 1 DO
< info.name := Ident.stack [j + i];
< info.index := nFields; INC (nFields);
< Scope.Insert (Field.New (info));
---
> VAR save := Scanner.offset;
> BEGIN
> FOR i := 0 TO n - 1 DO
> info.name := Ident.stack [j + i];
> Scanner.offset := Ident.offset [j + i];
> info.index := nFields; INC (nFields);
> Scope.Insert (Field.New (info));
> END;
> Scanner.offset := save;
129a144
> p.info.isTransient := TRUE;
137a153,154
> p.info.isTransient :=
> p.info.isTransient AND (info.isTransient OR field.transient);
143a161,165
> IF p.transient AND p.info.isTransient THEN
> Error.Warn (1, "record type already transient, <*TRANSIENT*> ignored");
> END;
> p.info.isTransient := p.transient OR p.info.isTransient;
>
378c400
< refs_only: BOOLEAN) =
---
> refs_only, transient: BOOLEAN) =
383c405,406
< Type.GenMap (field.type, offset + field.offset, -1, refs_only);
---
> Type.GenMap (field.type, offset + field.offset, -1, refs_only,
> p.transient OR field.transient OR transient);
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/RefType.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/RefType.i3
16c16,17
< PROCEDURE New (target: Type.T; traced: BOOLEAN; brand: Expr.T): Type.T;
---
> PROCEDURE New (target: Type.T; traced, transient: BOOLEAN; brand: Expr.T;
> warn := TRUE): Type.T;
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/RefType.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/RefType.m3
12c12
< IMPORT Null, Reff, Addr, Error, Expr, Module, M3Buf, TextExpr;
---
> IMPORT Null, Reff, ReffTransient, Addr, Error, Expr, Module, M3Buf, TextExpr;
14c14,15
< IMPORT ProcType, ObjectAdr, Word, M3RT;
---
> IMPORT ProcType, ObjectAdr, ObjectTransient, Word, M3RT;
> IMPORT RecordType, ArrayType;
17c18
< P = Type.T BRANDED "RefType.T"OBJECT
---
> P = Type.T BRANDED "RefType.T" OBJECT
21a23
> isTransient: BOOLEAN;
22a25
> warn : BOOLEAN;
44c47
< VAR root : M3ID.T := M3ID.NoID;
---
> VAR root, refany: M3ID.T := M3ID.NoID;
56c59
< VAR brand: Expr.T; traced: BOOLEAN; super: Type.T;
---
> VAR brand: Expr.T; traced, transient: BOOLEAN; super: Type.T;
58a62
> transient := FALSE;
73a78,100
> transient := TRUE;
> ELSIF Scanner.cur.token = Token.T.tTRANSIENT THEN
> Scanner.GetToken(); Scanner.Match(Token.T.tENDPRAGMA);(* <*TRANSIENT*> *)
> IF Scanner.cur.token = Token.T.tIDENT THEN
> IF refany = M3ID.NoID THEN refany := M3ID.Add ("REFANY"); END;
> IF Scanner.cur.id = refany THEN
> Scanner.GetToken (); (* REFANY *)
> RETURN ReffTransient.T;
> END;
> IF root = M3ID.NoID THEN root := M3ID.Add ("ROOT"); END;
> IF Scanner.cur.id # root THEN
> Error.ID (Scanner.cur.id, "expected <*TRANSIENT*> ROOT/REFANY");
> END;
> Scanner.GetToken (); (* ROOT *)
> super := ObjectTransient.T;
> IF Scanner.cur.token # Token.T.tOBJECT
> AND Scanner.cur.token # Token.T.tBRANDED THEN RETURN super END;
> ELSIF Scanner.cur.token = Token.T.tRECORD THEN
> RETURN RecordType.Parse (transient := TRUE);
> ELSIF Scanner.cur.token = Token.T.tARRAY THEN
> RETURN ArrayType.Parse (transient := TRUE);
> END;
> transient := TRUE;
79c106,114
< RETURN New (Type.Parse (), traced, brand);
---
> VAR origin := Scanner.offset;
> t := Type.Parse();
> save := Scanner.offset;
> BEGIN
> Scanner.offset := origin;
> t := New (t, traced, transient, brand);
> Scanner.offset := save;
> RETURN t;
> END;
84c119,122
< RETURN ObjectType.Parse (super, traced, brand);
---
> IF super = NIL AND transient THEN
> Error.Msg ("expected <*TRANSIENT*> ROOT OBJECT");
> END;
> RETURN ObjectType.Parse (super, traced, transient, brand);
88c126,128
< PROCEDURE New (target: Type.T; traced: BOOLEAN; brand: Expr.T): Type.T =
---
> PROCEDURE New (target: Type.T; traced, transient: BOOLEAN; brand: Expr.T;
> warn := TRUE):
> Type.T =
93,97c133,139
< p.isTraced := traced;
< p.brandE := brand;
< p.brand := NIL;
< p.target := target;
< p.user_name := NIL;
---
> p.isTraced := traced;
> p.isTransient := transient;
> p.brandE := brand;
> p.brand := NIL;
> p.target := target;
> p.user_name := NIL;
> p.warn := warn;
227,236c269,279
< p.info.size := Target.Address.size;
< p.info.min_size := Target.Address.size;
< p.info.alignment := Target.Address.align;
< p.info.mem_type := CG.Type.Addr;
< p.info.stk_type := CG.Type.Addr;
< p.info.class := Type.Class.Ref;
< p.info.isTraced := p.isTraced;
< p.info.isEmpty := FALSE;
< p.info.isSolid := TRUE;
< p.info.hash := hash;
---
> p.info.size := Target.Address.size;
> p.info.min_size := Target.Address.size;
> p.info.alignment := Target.Address.align;
> p.info.mem_type := CG.Type.Addr;
> p.info.stk_type := CG.Type.Addr;
> p.info.class := Type.Class.Ref;
> p.info.isTraced := p.isTraced;
> p.info.isTransient := p.isTransient;
> p.info.isEmpty := FALSE;
> p.info.isSolid := TRUE;
> p.info.hash := hash;
245,246c288,296
< IF (NOT p.isTraced) AND (info.isTraced) AND Module.IsSafe() THEN
< Error.Msg ("unsafe: untraced ref type to a traced type");
---
> IF p.isTraced THEN
> IF p.warn
> AND p.isTransient AND info.isTraced AND NOT info.isTransient THEN
> Error.Warn (1, "transient ref type to a non-transient type");
> END;
> ELSE
> IF info.isTraced AND Module.IsSafe() THEN
> Error.Msg ("unsafe: untraced ref type to a traced type");
> END;
258c308
< brand, p.isTraced);
---
> brand, p.isTraced, p.isTransient);
323c373,377
< CG.Init_intt (offset + M3RT.TC_traced, isz, 1);
---
> IF p.isTransient THEN
> CG.Init_intt (offset + M3RT.TC_traced, isz, 3);
> ELSE
> CG.Init_intt (offset + M3RT.TC_traced, isz, 1);
> END;
354c408
< PROCEDURE GenTypeMap (p: P; refs_only: BOOLEAN): INTEGER =
---
> PROCEDURE GenTypeMap (p: P; refs_only: BOOLEAN): INTEGER =
358c412
< Type.GenMap (p.target, 0, -1, refs_only);
---
> Type.GenMap (p.target, 0, -1, refs_only, transient := FALSE);
408a463
> AND (a.isTransient = b.isTransient)
424a480,481
> OR ((a.isTraced) AND (a.isTransient)
> AND Type.IsEqual (b, ReffTransient.T, NIL))
435c492,493
< IF Type.IsEqual (p, Reff.T, NIL) THEN
---
> IF Type.IsEqual (p, Reff.T, NIL) OR
> Type.IsEqual (p, ReffTransient.T, NIL) THEN
450a509,511
> ELSIF Type.IsEqual (p, ReffTransient.T, NIL) THEN
> x.tag := "$refanytransient";
> x.n_nodes := 0;
459c520,524
< IF (NOT p.isTraced) THEN M3Buf.PutText (x.buf, "-UNTRACED") END;
---
> IF p.isTraced THEN
> IF p.isTransient THEN M3Buf.PutText (x.buf, "-TRANSIENT") END;
> ELSE
> M3Buf.PutText (x.buf, "-UNTRACED");
> END;
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/SetType.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/SetType.m3
72a73
> p.info.isTransient := TRUE;
114c115
< <*UNUSED*> refs_only: BOOLEAN) =
---
> <*UNUSED*> refs_only, transient: BOOLEAN) =
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/SubrangeType.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/SubrangeType.m3
161a162
> p.info.isTransient := TRUE;
299c300,301
< PROCEDURE GenMap (p: P; offset, size: INTEGER; refs_only: BOOLEAN) =
---
> PROCEDURE GenMap (p: P; offset, size: INTEGER; refs_only: BOOLEAN;
> <*UNUSED*> transient: BOOLEAN) =
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/Type.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/Type.i3
31,40c31,41
< size : INTEGER; (* size in bits, -1 if variable sized *)
< min_size : INTEGER; (* minimum size in bits. *)
< alignment : INTEGER; (* minimum alignment in bits *)
< hash : INTEGER; (* internal hash code *)
< stk_type : CG.Type; (* code generator representation on operator stack *)
< mem_type : CG.Type; (* code generator representation as a variable *)
< class : Class;
< isTraced : M3.Flag;
< isEmpty : M3.Flag;
< isSolid : M3.Flag;
---
> size : INTEGER; (* size in bits, -1 if variable sized *)
> min_size : INTEGER; (* minimum size in bits. *)
> alignment : INTEGER; (* minimum alignment in bits *)
> hash : INTEGER; (* internal hash code *)
> stk_type : CG.Type; (* code generator representation on operator stack *)
> mem_type : CG.Type; (* code generator representation as a variable *)
> class : Class;
> isTraced : M3.Flag;
> isTransient: M3.Flag;
> isEmpty : M3.Flag;
> isSolid : M3.Flag;
145c146
< PROCEDURE GenMap (t: T; offset, size: INTEGER; refs_only: BOOLEAN);
---
> PROCEDURE GenMap (t: T; offset, size: INTEGER; refs_only, transient: BOOLEAN);
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/Type.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/Type.m3
16a17
> IMPORT ObjectTransient, ReffTransient;
87c88
< | TK.tARRAY => t := ArrayType.Parse ();
---
> | TK.tARRAY => t := ArrayType.Parse (transient := FALSE);
92c93,94
< | TK.tOBJECT => t := ObjectType.Parse (NIL, TRUE, NIL);
---
> | TK.tTRANSIENT => t := RefType.Parse ();
> | TK.tOBJECT => t := ObjectType.Parse (NIL, TRUE, FALSE, NIL);
95c97
< | TK.tRECORD => t := RecordType.Parse ();
---
> | TK.tRECORD => t := RecordType.Parse (transient := FALSE);
104c106
< t := ObjectType.Parse (t, FALSE, RefType.ParseBrand ());
---
> t := ObjectType.Parse (t, FALSE, FALSE, RefType.ParseBrand ());
106c108
< t := ObjectType.Parse (t, FALSE, NIL);
---
> t := ObjectType.Parse (t, FALSE, FALSE, NIL);
593a596
> EVAL TypeTbl.Put (compiled, Check(ObjectTransient.T), ObjectTransient.T);
596a600
> EVAL TypeTbl.Put (compiled, Check(ReffTransient.T), ReffTransient.T);
662c666
< PROCEDURE GenMap (t: T; offset, size: INTEGER; refs_only: BOOLEAN) =
---
> PROCEDURE GenMap (t: T; offset, size: INTEGER; refs_only, transient: BOOLEAN) =
667c671
< u.mapper (offset, MIN (size, nat_sz), refs_only);
---
> u.mapper (offset, MIN (size, nat_sz), refs_only, transient);
829c833,834
< PROCEDURE GenRefMap (t: T; offset, size: INTEGER; refs_only: BOOLEAN) =
---
> PROCEDURE GenRefMap (t: T; offset, size: INTEGER;
> refs_only, transient: BOOLEAN) =
834c839,843
< TipeMap.Add (offset, TipeMap.Op.Ref, 0);
---
> IF u.info.isTransient OR transient THEN
> TipeMap.Add (offset, TipeMap.Op.TransientRef, 0);
> ELSE
> TipeMap.Add (offset, TipeMap.Op.Ref, 0);
> END;
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/TypeRep.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/types/TypeRep.i3
39c39
< mapper (offset, size: INTEGER; refs: BOOLEAN);
---
> mapper (offset, size: INTEGER; refs, transient: BOOLEAN);
56,57c56,58
< PROCEDURE GenRefMap (t: TT; offset, size: INTEGER; refs_only: BOOLEAN);
< (* == TypeMap.Add (offset, Op.{Untraced}Ref, 0) *)
---
> PROCEDURE GenRefMap (t: TT; offset, size: INTEGER;
> refs_only, transient: BOOLEAN);
> (* == TypeMap.Add (offset, Op.{Untraced|Transient}Ref, 0) *)
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/values/Exceptionz.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/values/Exceptionz.m3
160c160
< t.refTipe := RefType.New (t.tipe, TRUE, NIL);
---
> t.refTipe := RefType.New (t.tipe, TRUE, FALSE, NIL);
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/values/Field.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/values/Field.i3
18a19
> transient: BOOLEAN;
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/values/Field.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/values/Field.m3
19a20
> transient: BOOLEAN;
44a46
> t.transient := info.transient;
64a67
> info.transient := t.transient;
111a115,118
>
> IF t.transient AND info.isTransient THEN
> Error.Warn (1, "field type already transient, <*TRANSIENT*> ignored");
> END;
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/values/Formal.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/values/Formal.m3
189c189,190
< t.refType := RefType.New (t.tipe, traced := TRUE, brand := NIL);
---
> t.refType := RefType.New (t.tipe, traced := TRUE, transient := TRUE,
> brand := NIL, warn := TRUE);
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/values/Variable.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3front/src/values/Variable.m3
661c661
< proc := Runtime.LookUpProc (Runtime.Hook.NewTracedArray);
---
> proc := Runtime.LookUpProc (Runtime.Hook.NewTransientArray);
748c748,749
< Type.GenMap (t.tipe, 0, -1, refs_only := TRUE);
---
> Type.GenMap (t.tipe, 0, -1, refs_only := TRUE,
> transient := FALSE);
752c753,754
< Type.GenMap (t.tipe, t.offset, -1, refs_only := TRUE);
---
> Type.GenMap (t.tipe, t.offset, -1, refs_only := TRUE,
> transient := FALSE);
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3tests/src/p1/p108/Main.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3compiler/m3tests/src/p1/p108/Main.m3
32c32
< * $Header: /home/cvsroot/m3/pm3/language/modula3/m3compiler/m3tests/src/p1/p108/Main.m3,v 1.1.1.1 1997/01/16 21:31:15 ldd Exp $
---
> * $Header: /u/u84/hosking/CVS/pm3/language/modula3/m3compiler/m3tests/src/p1/p108/Main.m3,v 1.1.1.1 1998/10/28 21:33:44 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/gnuemacs/src/flex-bison/lex.yy.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/gnuemacs/src/flex-bison/lex.yy.c
4c4
< * $Header: /home/cvsroot/m3/pm3/language/modula3/m3tools/gnuemacs/src/flex-bison/lex.yy.c,v 1.2 1997/01/24 19:53:09 ldd Exp $
---
> * $Header: /u/u84/hosking/CVS/pm3/language/modula3/m3tools/gnuemacs/src/flex-bison/lex.yy.c,v 1.1.1.1 1998/10/28 21:34:29 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3browser/src/Main.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3browser/src/Main.m3
10c10
< (* in interfaces with their implmentations. - Mar 7, 1995 *)
---
> (* in interfaces with their implementations. - Mar 7, 1995 *)
119a120
> TREFANY_UID = 16_51e4b739;
121a123
> TROOT_UID = 16_a973d3a6;
642c644,649
< | 'U', 'V' =>
---
> | 'p' =>
> start := cur-1;
> uid := ReadUID (buf, cur);
> NoteType (s, uid, buf, start, cur_unit, c);
> NoteSubtype (s, uid, TREFANY_UID);
> | 'U', 'V', 'v' =>
852a860
> & "?51e4b739 TRANSIENT-REFANY\n"
857a866,867
> & "va973d3a6 00000000 0 0 0 4\n" (* <*TRANSIENT*> ROOT *)
> & "Ea973d3a6 TRANSIENT-ROOT\n"
871a882,883
> NoteSubtype (s, TREFANY_UID,REFANY_UID); (* TRANSIENT-REFANY <: REFANY *)
> NoteSubtype (s, TROOT_UID, TREFANY_UID); (* TRANSIENT-ROOT <: TRANSIENT-REFANY *)
2149c2161
< traced : BOOLEAN := FALSE;
---
> traced, transient: BOOLEAN := FALSE;
2211c2223
< IF (ch # 'U') AND (ch # 'V') THEN RETURN END;
---
> IF (ch # 'U') AND (ch # 'V') AND (ch # 'v') THEN RETURN END;
2212a2225
> IF (ch = 'v') THEN info.traced := TRUE; info.transient := TRUE END;
2283c2296,2297
< IF (NOT info.traced) THEN fmt.putText ("UNTRACED "); END;
---
> IF (NOT info.traced) THEN fmt.putText ("UNTRACED ROOT "); END;
> IF (info.transient) THEN fmt.putText ("<*TRANSIENT*> ROOT "); END;
2390c2404
< IF (t.class = 'V') OR (t.class = 'U') OR
---
> IF (t.class = 'V') OR (t.class = 'U') OR (t.class = 'v') OR
2560c2574
< | 'O', 'P' => (* untraced ref *)
---
> | 'O', 'P', 'p' => (* untraced/traced/transient ref *)
2566a2581,2582
> ELSIF (ch = 'p') THEN
> fmt.putText ("<*TRANSIENT*> ");
2639c2655
< | 'U', 'V' => (* untraced obj, obj *)
---
> | 'U', 'V', 'v' => (* untraced obj, obj, transient obj *)
2660c2676,2677
< IF (ch = 'U') THEN fmt.putText ("UNTRACED "); END;
---
> IF (ch = 'U') THEN fmt.putText ("UNTRACED ROOT "); END;
> IF (ch = 'v') THEN fmt.putText ("<*TRANSIENT*> ROOT "); END;
2815c2832,2833
< RETURN (t.class = 'P') OR (t.class = 'V')
---
> RETURN (t.class = 'P') OR (t.class = 'p')
> OR (t.class = 'V') OR (t.class = 'v')
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/bfd/doc/bfd.texinfo Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/bfd/doc/bfd.texinfo
3c3
< @c $Id: bfd.texinfo,v 1.3 1998/11/03 17:36:04 dagenais Exp $
---
> @c $Id: bfd.texinfo,v 1.1.1.2 1998/11/05 23:28:25 hosking Exp $
70c70
< \xdef\manvers{\$Revision: 1.3 $} % For use in headers, footers too
---
> \xdef\manvers{\$Revision: 1.1.1.2 $} % For use in headers, footers too
Only in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/bfd: VERSION
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/configure Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/configure
86c86
< version="$Revision: 1.3 $"
---
> version="$Revision: 1.1.1.2 $"
Only in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb: COPYING.NEWLIB
Only in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb: .cvsignore
Only in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb: CYGNUS
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/doc/gdbint.texinfo Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/doc/gdbint.texinfo
3c3
< @c $Id: gdbint.texinfo,v 1.3 1998/11/03 17:36:39 dagenais Exp $
---
> @c $Id: gdbint.texinfo,v 1.1.1.2 1998/11/05 23:31:08 hosking Exp $
45c45
< \xdef\manvers{\$Revision: 1.3 $} % For use in headers, footers too
---
> \xdef\manvers{\$Revision: 1.1.1.2 $} % For use in headers, footers too
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/doc/stabs.texinfo Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/doc/stabs.texinfo
46c46
< \xdef\manvers{\$Revision: 1.3 $} % For use in headers, footers too
---
> \xdef\manvers{\$Revision: 1.1.1.2 $} % For use in headers, footers too
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/eval.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/eval.c
1688a1689
> || TYPE_CODE (t) == TYPE_CODE_M3_TRANSIENT_REFANY
1690c1691,1692
< || TYPE_CODE (t) == TYPE_CODE_M3_ROOT) {
---
> || TYPE_CODE (t) == TYPE_CODE_M3_ROOT
> || TYPE_CODE (t) == TYPE_CODE_M3_TRANSIENT_ROOT) {
1762a1765
> || TYPE_CODE (arg1_type) == TYPE_CODE_M3_TRANSIENT_REFANY
1763a1767
> || TYPE_CODE (arg1_type) == TYPE_CODE_M3_TRANSIENT_ROOT
1791c1795,1796
< if (TYPE_CODE (arg1_type) == TYPE_CODE_M3_REFANY) {
---
> if (TYPE_CODE (arg1_type) == TYPE_CODE_M3_REFANY
> || TYPE_CODE (arg1_type) == TYPE_CODE_M3_TRANSIENT_REFANY) {
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/gdb.1 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/gdb.1
3c3
< .\" $Id: gdb.1,v 1.2 1997/02/27 15:58:48 ldd Exp $
---
> .\" $Id: gdb.1,v 1.1.1.1 1998/10/28 21:35:12 hosking Exp $
Only in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb: .gdbinit
Only in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb: gdbtk.c
Only in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb: gdbtk.tcl
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/gdbtypes.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/gdbtypes.h
141a142
> TYPE_CODE_M3_TRANSIENT_REFANY,
142a144
> TYPE_CODE_M3_TRANSIENT_ROOT,
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/m3-lang.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/m3-lang.c
784a785
> struct type *builtin_type_m3_transient_root;
790a792
> struct type *builtin_type_m3_transient_refany;
835a838,842
> builtin_type_m3_transient_root =
> init_type (TYPE_CODE_M3_TRANSIENT_ROOT, TARGET_PTR_BIT / HOST_CHAR_BIT, 0,
> "TRANSIENT_ROOT", (struct objfile *) NULL);
> TYPE_M3_SIZE (builtin_type_m3_transient_root) = TARGET_PTR_BIT;
>
865a873,877
> builtin_type_m3_transient_refany =
> init_type (TYPE_CODE_M3_TRANSIENT_REFANY, TARGET_PTR_BIT / HOST_CHAR_BIT, 0,
> "TRANSIENT_REFANY", (struct objfile *) NULL);
> TYPE_M3_SIZE (builtin_type_m3_transient_refany) = TARGET_PTR_BIT;
>
1284a1297
> else if (uid_val == 0xa973d3a6) { return builtin_type_m3_transient_root; }
1290a1304
> else if (uid_val == 0x51e4b739) { return builtin_type_m3_transient_refany; }
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/m3-typeprint.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/m3-typeprint.c
198a199,200
> else if (sc == TYPE_CODE_M3_TRANSIENT_ROOT) {
> fprintf_filtered (stream, "TRANSIENT "); }
340a343,346
> case TYPE_CODE_M3_TRANSIENT_REFANY:
> fprintf_filtered (stream, "TRANSIENT REFANY");
> break;
>
350a357,360
> break;
>
> case TYPE_CODE_M3_TRANSIENT_ROOT:
> fprintf_filtered (stream, "TRANSIENT ROOT");
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/m3-valprint.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/m3-valprint.c
133a134
> || TYPE_CODE (this_obj) == TYPE_CODE_M3_TRANSIENT_ROOT
534a536
> case TYPE_CODE_M3_TRANSIENT_ROOT:
544c546,547
< case TYPE_CODE_M3_REFANY: {
---
> case TYPE_CODE_M3_REFANY:
> case TYPE_CODE_M3_TRANSIENT_REFANY: {
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/adperr.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/adperr.h
12c12
< * $Date: 1998/10/20 17:25:36 $
---
> * $Date: 1998/11/05 23:33:57 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/adp.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/adp.h
12c12
< * $Date: 1998/10/20 17:25:35 $
---
> * $Date: 1998/11/05 23:33:57 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/angel.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/angel.h
17c17
< * $Date: 1998/10/20 17:25:36 $
---
> * $Date: 1998/11/05 23:33:57 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/ardi.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/ardi.c
15c15
< * $Date: 1998/10/20 17:25:36 $
---
> * $Date: 1998/11/05 23:33:57 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/ardi.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/ardi.h
14c14
< * $Date: 1998/10/20 17:25:36 $
---
> * $Date: 1998/11/05 23:33:57 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/armdbg.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/armdbg.h
15c15
< * Checkin $Date: 1998/10/20 17:25:36 $
---
> * Checkin $Date: 1998/11/05 23:33:57 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/buffers.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/buffers.h
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:57 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/bytesex.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/bytesex.c
16c16
< * Checkin $Date: 1998/10/20 17:25:37 $
---
> * Checkin $Date: 1998/11/05 23:33:57 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/bytesex.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/bytesex.h
15c15
< * Checkin $Date: 1998/10/20 17:25:37 $
---
> * Checkin $Date: 1998/11/05 23:33:57 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/chandefs.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/chandefs.h
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:57 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/channels.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/channels.h
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:57 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/chanpriv.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/chanpriv.h
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:57 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/crc.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/crc.c
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:57 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/crc.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/crc.h
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:57 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/dbg_conf.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/dbg_conf.h
15c15
< * Checkin $Date: 1998/10/20 17:25:37 $
---
> * Checkin $Date: 1998/11/05 23:33:57 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/dbg_cp.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/dbg_cp.h
15c15
< * Checkin $Date: 1998/10/20 17:25:37 $
---
> * Checkin $Date: 1998/11/05 23:33:58 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/dbg_hif.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/dbg_hif.h
19c19
< * Checkin $Date: 1998/10/20 17:25:37 $
---
> * Checkin $Date: 1998/11/05 23:33:58 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/dbg_rdi.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/dbg_rdi.h
15c15
< * Checkin $Date: 1998/10/20 17:25:37 $
---
> * Checkin $Date: 1998/11/05 23:33:58 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/devclnt.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/devclnt.h
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:58 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/devices.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/devices.h
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:58 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/devsw.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/devsw.c
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:58 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/devsw.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/devsw.h
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:58 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/drivers.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/drivers.c
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:58 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/drivers.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/drivers.h
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:58 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/endian.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/endian.h
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:58 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/etherdrv.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/etherdrv.c
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:58 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/ethernet.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/ethernet.h
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:58 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/hostchan.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/hostchan.c
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:58 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/hostchan.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/hostchan.h
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:58 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/hsys.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/hsys.c
13c13
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:58 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/hsys.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/hsys.h
13c13
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:58 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/logging.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/logging.c
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:58 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/logging.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/logging.h
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:59 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/msgbuild.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/msgbuild.c
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:59 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/msgbuild.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/msgbuild.h
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:59 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/params.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/params.c
12c12
< * $Date: 1998/10/20 17:25:37 $
---
> * $Date: 1998/11/05 23:33:59 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/params.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/params.h
12c12
< * $Date: 1998/10/20 17:25:38 $
---
> * $Date: 1998/11/05 23:33:59 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/rx.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/rx.c
12c12
< * $Date: 1998/10/20 17:25:38 $
---
> * $Date: 1998/11/05 23:33:59 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/rxtx.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/rxtx.h
12c12
< * $Date: 1998/10/20 17:25:38 $
---
> * $Date: 1998/11/05 23:33:59 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/serdrv.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/serdrv.c
12c12
< * $Date: 1998/10/20 17:25:38 $
---
> * $Date: 1998/11/05 23:33:59 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/serpardr.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/serpardr.c
12c12
< * $Date: 1998/10/20 17:25:38 $
---
> * $Date: 1998/11/05 23:33:59 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/sys.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/sys.h
14c14
< * $Date: 1998/10/20 17:25:38 $
---
> * $Date: 1998/11/05 23:33:59 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/tx.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/tx.c
12c12
< * $Date: 1998/10/20 17:25:38 $
---
> * $Date: 1998/11/05 23:33:59 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/unixcomm.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/unixcomm.c
12c12
< * $Date: 1998/10/20 17:25:38 $
---
> * $Date: 1998/11/05 23:33:59 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/unixcomm.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/rdi-share/unixcomm.h
12c12
< * $Date: 1998/10/20 17:25:38 $
---
> * $Date: 1998/11/05 23:33:59 $
Only in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb: README.GDBTK
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/sol-thread.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/sol-thread.c
965c965
< ps_pstop (const struct ps_prochandle *ph)
---
> ps_pstop (struct ps_prochandle *ph)
971c971
< ps_pcontinue (const struct ps_prochandle *ph)
---
> ps_pcontinue (struct ps_prochandle *ph)
977c977
< ps_lstop (const struct ps_prochandle *ph, lwpid_t lwpid)
---
> ps_lstop (struct ps_prochandle *ph, lwpid_t lwpid)
983c983
< ps_lcontinue (const struct ps_prochandle *ph, lwpid_t lwpid)
---
> ps_lcontinue (struct ps_prochandle *ph, lwpid_t lwpid)
989c989
< ps_pglobal_lookup (const struct ps_prochandle *ph, const char *ld_object_name,
---
> ps_pglobal_lookup (struct ps_prochandle *ph, const char *ld_object_name,
1049c1049
< ps_pdread (const struct ps_prochandle *ph, paddr_t addr, char *buf, int size)
---
> ps_pdread (struct ps_prochandle *ph, paddr_t addr, void *buf, size_t size)
1055c1055
< ps_pdwrite (const struct ps_prochandle *ph, paddr_t addr, char *buf, int size)
---
> ps_pdwrite (struct ps_prochandle *ph, paddr_t addr, const void *buf, size_t size)
1061c1061
< ps_ptread (const struct ps_prochandle *ph, paddr_t addr, char *buf, int size)
---
> ps_ptread (struct ps_prochandle *ph, paddr_t addr, void *buf, size_t size)
1067c1067
< ps_ptwrite (const struct ps_prochandle *ph, paddr_t addr, char *buf, int size)
---
> ps_ptwrite (struct ps_prochandle *ph, paddr_t addr, const void *buf, size_t size)
1075c1075
< ps_lgetregs (const struct ps_prochandle *ph, lwpid_t lwpid,
---
> ps_lgetregs (struct ps_prochandle *ph, lwpid_t lwpid,
1098c1098
< ps_lsetregs (const struct ps_prochandle *ph, lwpid_t lwpid,
---
> ps_lsetregs (struct ps_prochandle *ph, lwpid_t lwpid,
1131c1131
< ps_lgetxregsize (const struct ps_prochandle *ph, lwpid_t lwpid, int *xregsize)
---
> ps_lgetxregsize (struct ps_prochandle *ph, lwpid_t lwpid, int *xregsize)
1159c1159
< ps_lgetxregs (const struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
---
> ps_lgetxregs (struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
1182c1182
< ps_lsetxregs (const struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
---
> ps_lsetxregs (struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
1205c1205
< ps_lgetfpregs (const struct ps_prochandle *ph, lwpid_t lwpid,
---
> ps_lgetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
1228c1228
< ps_lsetfpregs (const struct ps_prochandle *ph, lwpid_t lwpid,
---
> ps_lsetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/values.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/gdb/values.c
1285a1286
> case TYPE_CODE_M3_TRANSIENT_REFANY:
1288a1290
> case TYPE_CODE_M3_TRANSIENT_ROOT:
1338a1341
> case TYPE_CODE_M3_TRANSIENT_REFANY:
1341a1345
> case TYPE_CODE_M3_TRANSIENT_ROOT:
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/mmalloc/mmalloc.texi Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/mmalloc/mmalloc.texi
50c50
< \xdef\manvers{\$Revision: 1.2 $} % For use in headers, footers too
---
> \xdef\manvers{\$Revision: 1.1.1.1 $} % For use in headers, footers too
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/sim/mips/gencode.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/sim/mips/gencode.c
16,18c16,18
< $Revision: 1.3 $
< $Author: dagenais $
< $Date: 1998/11/03 17:36:55 $
---
> $Revision: 1.1.1.2 $
> $Author: hosking $
> $Date: 1998/11/05 23:37:17 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/sim/mips/interp.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/sim/mips/interp.c
16,18c16,18
< $Revision: 1.3 $
< $Author: dagenais $
< $Date: 1998/11/03 17:36:56 $
---
> $Revision: 1.1.1.2 $
> $Author: hosking $
> $Date: 1998/11/05 23:37:18 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/sim/mips/support.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/sim/mips/support.h
16,18c16,18
< $Revision: 1.2 $
< $Author: ldd $
< $Date: 1997/02/27 15:59:09 $
---
> $Revision: 1.1.1.1 $
> $Author: hosking $
> $Date: 1998/10/28 21:37:07 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/texinfo/cygnus/texinfo.tex Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/texinfo/cygnus/texinfo.tex
1c1
< %$Id: texinfo.tex,v 1.2 1997/02/27 15:59:10 ldd Exp $
---
> %$Id: texinfo.tex,v 1.1.1.1 1998/10/28 21:37:26 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/texinfo/cygnus/texiplus.tex Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/texinfo/cygnus/texiplus.tex
5c5
< %%$Id: texiplus.tex,v 1.2 1997/02/27 15:59:10 ldd Exp $
---
> %%$Id: texiplus.tex,v 1.1.1.1 1998/10/28 21:37:26 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/texinfo/texinfo.tex Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/texinfo/texinfo.tex
2c2
< %% $Id: texinfo.tex,v 1.3 1998/11/03 17:36:59 dagenais Exp $
---
> %% $Id: texinfo.tex,v 1.1.1.2 1998/11/05 23:38:16 hosking Exp $
39c39
< \deftexinfoversion$Revision: 1.3 $
---
> \deftexinfoversion$Revision: 1.1.1.2 $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/texinfo/util/texi2dvi Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/texinfo/util/texi2dvi
6c6
< # $Id: texi2dvi,v 1.2 1997/02/27 15:59:12 ldd Exp $
---
> # $Id: texi2dvi,v 1.1.1.1 1998/10/28 21:37:31 hosking Exp $
50c50
< rcs_revision='$Revision: 1.2 $'
---
> rcs_revision='$Revision: 1.1.1.1 $'
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/mondfe/Makefile.in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/mondfe/Makefile.in
19c19
< # $Id: Makefile.in,v 1.2 1997/02/27 15:59:13 ldd Exp $
---
> # $Id: Makefile.in,v 1.1.1.1 1998/10/28 21:37:36 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/montip/Makefile.in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/montip/Makefile.in
19c19
< # $Id: Makefile.in,v 1.2 1997/02/27 15:59:13 ldd Exp $
---
> # $Id: Makefile.in,v 1.1.1.1 1998/10/28 21:37:37 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/dos2udip.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/dos2udip.c
25c25
< * $Id: dos2udip.c,v 1.2 1997/02/27 15:59:14 ldd Exp $
---
> * $Id: dos2udip.c,v 1.1.1.1 1998/10/28 21:37:34 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/dos386c.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/dos386c.c
23c23
< * $Id: dos386c.c,v 1.2 1997/02/27 15:59:14 ldd Exp $
---
> * $Id: dos386c.c,v 1.1.1.1 1998/10/28 21:37:34 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/dos386c.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/dos386c.h
23c23
< * $Id: dos386c.h,v 1.2 1997/02/27 15:59:14 ldd Exp $
---
> * $Id: dos386c.h,v 1.1.1.1 1998/10/28 21:37:34 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/dosdfe.asm Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/dosdfe.asm
23c23
< ;* $Id: dosdfe.asm,v 1.2 1997/02/27 15:59:14 ldd Exp $
---
> ;* $Id: dosdfe.asm,v 1.1.1.1 1998/10/28 21:37:34 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/dostip.asm Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/dostip.asm
24c24
< ;* $Id: dostip.asm,v 1.2 1997/02/27 15:59:14 ldd Exp $
---
> ;* $Id: dostip.asm,v 1.1.1.1 1998/10/28 21:37:35 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/Makefile.in Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/Makefile.in
19c19
< # $Id: Makefile.in,v 1.2 1997/02/27 15:59:14 ldd Exp $
---
> # $Id: Makefile.in,v 1.1.1.1 1998/10/28 21:37:34 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/udidos.ah Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/udidos.ah
23c23
< ;* $Id: udidos.ah,v 1.2 1997/02/27 15:59:15 ldd Exp $
---
> ;* $Id: udidos.ah,v 1.1.1.1 1998/10/28 21:37:35 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/udidos.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/udidos.h
23c23
< * $Id: udidos.h,v 1.2 1997/02/27 15:59:15 ldd Exp $
---
> * $Id: udidos.h,v 1.1.1.1 1998/10/28 21:37:35 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/udip2dos.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/udip2dos.c
23c23
< * $Id: udip2dos.c,v 1.2 1997/02/27 15:59:15 ldd Exp $
---
> * $Id: udip2dos.c,v 1.1.1.1 1998/10/28 21:37:35 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/udiphdos.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/udiphdos.h
23c23
< * $Id: udiphdos.h,v 1.2 1997/02/27 15:59:15 ldd Exp $
---
> * $Id: udiphdos.h,v 1.1.1.1 1998/10/28 21:37:35 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/udiphsun.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/udiphsun.h
23c23
< * $Id: udiphsun.h,v 1.2 1997/02/27 15:59:15 ldd Exp $
---
> * $Id: udiphsun.h,v 1.1.1.1 1998/10/28 21:37:35 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/udiproc.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/udiproc.h
30c30
< * $Id: udiproc.h,v 1.2 1997/02/27 15:59:15 ldd Exp $
---
> * $Id: udiproc.h,v 1.1.1.1 1998/10/28 21:37:35 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/udipt29k.h Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3gdb/gdb/utils/amd-udi/udi/udipt29k.h
23c23
< * $Id: udipt29k.h,v 1.2 1997/02/27 15:59:15 ldd Exp $
---
> * $Id: udipt29k.h,v 1.1.1.1 1998/10/28 21:37:35 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/m3tk/src/files/Common/M3PathElemList.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/m3tk/src/files/Common/M3PathElemList.i3
9,10c9
< INTERFACE M3PathElemList = List(M3PathElem)
< END M3PathElemList.
---
> INTERFACE M3PathElemList = List(Root, M3PathElem) END M3PathElemList.
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/pp/src/ExceptionArg.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/pp/src/ExceptionArg.i3
6c6
< $Id: ExceptionArg.i3,v 1.1.1.1 1997/01/16 21:31:50 ldd Exp $
---
> $Id: ExceptionArg.i3,v 1.1.1.1 1998/10/28 21:38:21 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/pp/src/FBE.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/pp/src/FBE.i3
7c7
< $Id: FBE.i3,v 1.1.1.1 1997/01/16 21:31:50 ldd Exp $
---
> $Id: FBE.i3,v 1.1.1.1 1998/10/28 21:38:21 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/pp/src/FBEPostScript.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/pp/src/FBEPostScript.i3
7c7
< $Id: FBEPostScript.i3,v 1.1.1.1 1997/01/16 21:31:50 ldd Exp $
---
> $Id: FBEPostScript.i3,v 1.1.1.1 1998/10/28 21:38:21 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/pp/src/FBEPostScript.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/pp/src/FBEPostScript.m3
7c7
< $Id: FBEPostScript.m3,v 1.1.1.1 1997/01/16 21:31:50 ldd Exp $
---
> $Id: FBEPostScript.m3,v 1.2 1998/12/01 21:05:40 hosking Exp $
35c35
< AFMDir = "/usr/local/lib/ps/";
---
> AFMDir = "/usr/openwin/lib/X11/fonts/F3/afm/";
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/pp/src/FBEWr.i3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/pp/src/FBEWr.i3
7c7
< $Id: FBEWr.i3,v 1.1.1.1 1997/01/16 21:31:50 ldd Exp $
---
> $Id: FBEWr.i3,v 1.1.1.1 1998/10/28 21:38:21 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/pp/src/FBEWr.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/pp/src/FBEWr.m3
7c7
< $Id: FBEWr.m3,v 1.1.1.1 1997/01/16 21:31:50 ldd Exp $
---
> $Id: FBEWr.m3,v 1.1.1.1 1998/10/28 21:38:21 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/pp/src/flex-bison/lex.yy.c Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/pp/src/flex-bison/lex.yy.c
4c4
< * $Header: /home/cvsroot/m3/pm3/language/modula3/m3tools/pp/src/flex-bison/lex.yy.c,v 1.1.1.1 1997/01/16 21:31:50 ldd Exp $
---
> * $Header: /u/u84/hosking/CVS/pm3/language/modula3/m3tools/pp/src/flex-bison/lex.yy.c,v 1.1.1.1 1998/10/28 21:38:22 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/language/modula3/m3tools/showheap/src/ShowHeap.m3 Persistent_M3/pm3-1.1.15-unpacked/language/modula3/m3tools/showheap/src/ShowHeap.m3
18c18
< FROM RTHeapRep IMPORT Desc, Generation, Note, Page, Space;
---
> FROM RTHeapRep IMPORT Desc, Generation, Note, Page, Space, Access;
30c30
< TYPE Counter = {None, New, Copied, Immobile, Older};
---
> TYPE Counter = {None, New, Copied, Immobile, Older, Persistent};
39c39,40
< d.space, d.generation, d.pure, d.note, d.gray, d.protected];
---
> d.space, d.generation, d.pure, d.note, d.gray, d.access,
> d.resident, d.dirty];
65,66c66,68
< BOOLEAN (* gray *), BOOLEAN (* protected *) OF
< Color.T;
---
> BOOLEAN (* gray *), Access,
> BOOLEAN (* resident *),
> BOOLEAN (* dirty *) OF Color.T;
68,69c70,72
< BOOLEAN (* gray *), BOOLEAN (* protected *) OF
< PaintOp.T;
---
> BOOLEAN (* gray *), Access,
> BOOLEAN (* resident *),
> BOOLEAN (* dirty *) OF PaintOp.T;
71,72c74,76
< BOOLEAN (* gray *), BOOLEAN (* protected *) OF
< Counter;
---
> BOOLEAN (* gray *), Access,
> BOOLEAN (* resident *),
> BOOLEAN (* dirty *) OF Counter;
95c99,101
< FOR protected := FIRST(BOOLEAN) TO LAST(BOOLEAN) DO
---
> FOR access := FIRST(Access) TO LAST(Access) DO
> FOR resident := FIRST(BOOLEAN) TO LAST(BOOLEAN) DO
> FOR dirty := FIRST(BOOLEAN) TO LAST(BOOLEAN) DO
98,99c104,106
< rgb[space, generation, pure, note, gray, protected] :=
< Color.T{0.0, 0.0, 0.0};
---
> rgb[space, generation, pure, note, gray, access,
> resident, dirty] :=
> Color.T{0.0, 0.0, 0.0};
101,102c108,109
< space, generation, pure, note, gray, protected] :=
< Counter.None;
---
> space, generation, pure, note, gray, access,
> resident, dirty] := Counter.None;
104,105c111,113
< rgb[space, generation, pure, note, gray, protected] :=
< Color.T{1.0, 1.0, 1.0};
---
> rgb[space, generation, pure, note, gray, access,
> resident, dirty] :=
> Color.T{1.0, 1.0, 1.0};
107,108c115,116
< space, generation, pure, note, gray, protected] :=
< Counter.None;
---
> space, generation, pure, note, gray, access,
> resident, dirty] := Counter.None;
110,111c118,120
< rgb[space, generation, pure, note, gray, protected] :=
< Color.T{0.25, 0.25, 0.25};
---
> rgb[space, generation, pure, note, gray, access,
> resident, dirty] :=
> Color.T{0.25, 0.25, 0.25};
113,114c122,123
< space, generation, pure, note, gray, protected] :=
< Counter.None;
---
> space, generation, pure, note, gray, access,
> resident, dirty] := Counter.None;
118,119c127,129
< rgb[space, generation, pure, note, gray, protected] :=
< Color.T{0.730, 0.730, 1.0};
---
> rgb[space, generation, pure, note, gray, access,
> resident, dirty] :=
> Color.T{0.730, 0.730, 1.0};
121,122c131,132
< space, generation, pure, note, gray, protected] :=
< Counter.New;
---
> space, generation, pure, note, gray, access,
> resident, dirty] := Counter.New;
125,127c135,137
< rgb[
< space, generation, pure, note, gray, protected] :=
< Color.T{1.0, 0.343, 0.343};
---
> rgb[space, generation, pure, note, gray, access,
> resident, dirty] :=
> Color.T{1.0, 0.343, 0.343};
129,131c139,141
< rgb[
< space, generation, pure, note, gray, protected] :=
< Color.T{0.75, 0.421, 0.421};
---
> rgb[space, generation, pure, note, gray, access,
> resident, dirty] :=
> Color.T{0.75, 0.421, 0.421};
134,135c144,145
< space, generation, pure, note, gray, protected] :=
< Counter.Copied;
---
> space, generation, pure, note, gray, access,
> resident, dirty] := Counter.Copied;
138,140c148,150
< rgb[
< space, generation, pure, note, gray, protected] :=
< Color.T{0.0, 0.812, 0.0};
---
> rgb[space, generation, pure, note, gray, access,
> resident, dirty] :=
> Color.T{0.0, 0.812, 0.0};
142,144c152,154
< rgb[
< space, generation, pure, note, gray, protected] :=
< Color.T{0.275, 0.676, 0.275};
---
> rgb[space, generation, pure, note, gray, access,
> resident, dirty] :=
> Color.T{0.275, 0.676, 0.275};
147,148c157,158
< space, generation, pure, note, gray, protected] :=
< Counter.Immobile;
---
> space, generation, pure, note, gray, access,
> resident, dirty] := Counter.Immobile;
151,153c161,163
< rgb[
< space, generation, pure, note, gray, protected] :=
< Color.T{0.0, 0.812, 0.0};
---
> rgb[space, generation, pure, note, gray, access,
> resident, dirty] :=
> Color.T{0.0, 0.812, 0.0};
155,157c165,167
< rgb[
< space, generation, pure, note, gray, protected] :=
< Color.T{0.275, 0.676, 0.275};
---
> rgb[space, generation, pure, note, gray, access,
> resident, dirty] :=
> Color.T{0.275, 0.676, 0.275};
160,161c170,171
< space, generation, pure, note, gray, protected] :=
< Counter.Immobile;
---
> space, generation, pure, note, gray, access,
> resident, dirty] := Counter.Immobile;
164,166c174,176
< rgb[
< space, generation, pure, note, gray, protected] :=
< Color.T{1.0, 0.198, 1.0};
---
> rgb[space, generation, pure, note, gray, access,
> resident, dirty] :=
> Color.T{1.0, 0.198, 1.0};
168,170c178,180
< rgb[
< space, generation, pure, note, gray, protected] :=
< Color.T{0.725, 0.225, 0.725};
---
> rgb[space, generation, pure, note, gray, access,
> resident, dirty] :=
> Color.T{0.725, 0.225, 0.725};
173,174c183,198
< space, generation, pure, note, gray, protected] :=
< Counter.Older;
---
> space, generation, pure, note, gray, access,
> resident, dirty] := Counter.Older;
> | Note.Persistent =>
> IF gray THEN
> rgb[space, generation, pure, note, gray, access,
> resident, dirty] :=
> Color.T{1.0, 0.75, 0.0};
> ELSE
> rgb[space, generation, pure, note, gray, access,
> resident, dirty] :=
> Color.T{1.0, 0.75, 0.0};
> END;
> counterOf[
> space, generation, pure, note, gray, access,
> resident, dirty] :=
> Counter.Persistent;
177,180c201,205
< WITH rgb = rgb[space, generation, pure, note, gray,
< protected] DO
< tint[space, generation, pure, note, gray, protected] :=
< PaintOp.FromRGB(rgb.r, rgb.g, rgb.b);
---
> WITH rgb = rgb[space, generation, pure, note, gray, access,
> resident, dirty] DO
> tint[space, generation, pure, note, gray, access,
> resident, dirty] :=
> PaintOp.FromRGB(rgb.r, rgb.g, rgb.b);
182c207,209
< END;
---
> END
> END
> END
220a248,256
> VAR
> rgb := Color.T{1.0, 0.75, 0.0};
> quad := PaintOp.MakeColorQuad(
> PaintOp.FromRGB(rgb.r, rgb.g, rgb.b), PaintOp.Bg);
> BEGIN
> countVBT[Counter.Persistent] := TextVBT.New("", bgFg := quad);
> countTextVBT[Counter.Persistent] := TextVBT.New("persistent",
> bgFg := quad);
> END;
301c337,338
< d.note, d.gray, d.protected]);
---
> d.note, d.gray, d.access, d.resident,
> d.dirty]);
330c367,368
< t := tint[d.space, d.generation, d.pure, d.note, d.gray, d.protected];
---
> t := tint[d.space, d.generation, d.pure, d.note, d.gray, d.access,
> d.resident, d.dirty];
410c448,449
< countVBT[Counter.Older], countTextVBT[Counter.Older]);
---
> countVBT[Counter.Older], countTextVBT[Counter.Older],
> countVBT[Counter.Persistent], countTextVBT[Counter.Persistent]);
Only in Persistent_M3/pm3-1.1.15-unpacked/libs: bag
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/atom/Atom.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/atom/Atom.i3
24c24
< TYPE T <: REFANY;
---
> TYPE T <: <*TRANSIENT*> REFANY;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/atom/Atom.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/atom/Atom.m3
5,6c5
< (* Last modified on Thu Mar 10 16:10:31 PST 1994
< by kalsow *)
---
> (* Last modified on Thu Mar 10 16:10:31 PST 1994 by kalsow *)
14,15c13,14
< T = BRANDED Brand REF RECORD
< text : TEXT;
---
> T = <*TRANSIENT*> BRANDED Brand REF RECORD
> <*TRANSIENT*> text : TEXT;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/formatter/Formatter.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/formatter/Formatter.m3
26,27c26,28
< REVEAL
< T = BRANDED REF RECORD
---
> REVEAL T = T_;
> TYPE
> T_ = <*TRANSIENT*> BRANDED REF RECORD
29c30
<
---
>
55c56
< failureCode: REFANY;
---
> <*TRANSIENT*> failureCode: REFANY;
112c113
< ExprBuf = REF ARRAY OF REFANY;
---
> ExprBuf = <*TRANSIENT*> REF <*TRANSIENT*> ARRAY OF REFANY;
116c117
< ConsumerThreadClosure = Thread.SizedClosure OBJECT t: T; METHODS END;
---
> ConsumerThreadClosure = Thread.SizedClosure OBJECT t: T_; METHODS END;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/list/List.ig Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/list/List.ig
14c14
< GENERIC INTERFACE List(Elem);
---
> GENERIC INTERFACE List(Super, Elem);
29c29
< CONST Brand = "(List " & Elem.Brand & ")";
---
> CONST Brand = "(" & Super.Brand & " List " & Elem.Brand & ")";
31c31
< TYPE T = OBJECT head: Elem.T; tail: T END;
---
> TYPE T = Super.T OBJECT head: Elem.T; tail: T END;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/list/list.tmpl Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/list/list.tmpl
13c13
< build_generic_intf (list, "List", [elt], VISIBLE)
---
> build_generic_intf (list, "List", ["Root", elt], VISIBLE)
19c19,31
< build_generic_intf (list, "List", [elt], HIDDEN)
---
> build_generic_intf (list, "List", ["Root", elt], HIDDEN)
> build_generic_impl (list, "List", [elt])
> end
>
> readonly proc TransientList (nm, elt) is
> local list = nm & "List"
> build_generic_intf (list, "List", ["RootTransient", elt], VISIBLE)
> build_generic_impl (list, "List", [elt])
> end
>
> readonly proc transientList (nm, elt) is
> local list = nm & "List"
> build_generic_intf (list, "List", ["RootTransient", elt], HIDDEN)
31a44,57
> build_generic_impl (list, "ListSort", [elt])
> end
>
> readonly proc TransientList_sort (nm, elt) is
> local list = nm & "ListSort"
> local eltlist = nm & "List"
> build_generic_intf (list, "ListSort", [elt, eltlist], VISIBLE)
> build_generic_impl (list, "ListSort", [elt])
> end
>
> readonly proc transientList_sort (nm, elt) is
> local list = nm & "ListSort"
> local eltlist = nm & "List"
> build_generic_intf (list, "ListSort", [elt, eltlist], HIDDEN)
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/list/m3makefile Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/list/m3makefile
18d17
< List ("Atom", "Atom")
23c22,26
< List_sort ("Atom", "Atom")
---
> TransientList ("Atom", "Atom")
> TransientList ("IntTransient", "Integer")
> TransientList ("RefTransient", "RefanyTransient")
> TransientList ("TextTransient", "Text")
>
26a30,34
>
> TransientList_sort ("Atom", "Atom")
> TransientList_sort ("IntTransient", "Integer")
> TransientList_sort ("RefTransient", "RefanyTransient")
> TransientList_sort ("TextTransient", "Text")
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/os/Common/File.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/os/Common/File.i3
38c38
< Public = OBJECT METHODS
---
> Public = <*TRANSIENT*> ROOT OBJECT METHODS
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/os/Common/Pathname.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/os/Common/Pathname.i3
13c13
< IMPORT TextSeq;
---
> IMPORT TextTransientSeq AS TextSeq;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/os/POSIX/FSPosix.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/os/POSIX/FSPosix.m3
14c14,15
< OSErrorPosix, Pathname, Process, Time, Text, TextSeq, Unix,
---
> OSErrorPosix, Pathname, Process, Time, Text,
> TextTransientSeq AS TextSeq, Unix,
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/pickle/ConvertPacking.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pickle/ConvertPacking.i3
45c45
< Public = OBJECT METHODS
---
> Public = <*TRANSIENT*> ROOT OBJECT METHODS
81c81
< RVPublic = OBJECT METHODS
---
> RVPublic = <*TRANSIENT*> ROOT OBJECT METHODS
96c96
< WVPublic = OBJECT METHODS
---
> WVPublic = <*TRANSIENT*> ROOT OBJECT METHODS
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/pickle/ConvertPacking.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pickle/ConvertPacking.m3
19,22c19,22
< * $Source: /home/cvsroot/m3/pm3/libs/libm3/src/pickle/ConvertPacking.m3,v $
< * $Date: 1998/02/26 16:37:33 $
< * $Author: dagenais $
< * $Revision: 1.1 $
---
> * $Source: /u/u84/hosking/CVS/pm3/libs/libm3/src/pickle/ConvertPacking.m3,v $
> * $Date: 1999/03/25 22:22:36 $
> * $Author: hosking $
> * $Revision: 1.3 $
24a25,33
> * Revision 1.3 1999/03/25 22:22:36 hosking
> * Cleaned up some template types to allow transient instances.
> *
> * Revision 1.2 1999/01/18 18:00:47 hosking
> * Added check for <*TRANSIENT*> ROOT alongside that for ROOT.
> *
> * Revision 1.1.1.1 1998/10/28 21:38:58 hosking
> * Polytechnique de Montreal Modula-3
> *
457c466
< field := NEW(REF ARRAY OF CARDINAL,
---
> field := NEW(<*TRANSIENT*> REF ARRAY OF CARDINAL,
548c557
< field := NEW(REF ARRAY OF CARDINAL, 1)) DO
---
> field := NEW(<*TRANSIENT*> REF ARRAY OF CARDINAL, 1)) DO
595c604
< WITH new_field = NEW(REF ARRAY OF CARDINAL,
---
> WITH new_field = NEW(<*TRANSIENT*> REF ARRAY OF CARDINAL,
631c640,641
< field := NEW(REF ARRAY OF CARDINAL, count)) DO
---
> field := NEW(<*TRANSIENT*> REF ARRAY OF CARDINAL,
> count)) DO
646c656,657
< field := NEW(REF ARRAY OF CARDINAL, extraCnt)) DO
---
> field := NEW(<*TRANSIENT*> REF ARRAY OF CARDINAL,
> extraCnt)) DO
848c859
< ref : REFANY;
---
> ref : <*TRANSIENT*> REFANY;
881c892
< ref : REFANY;
---
> ref : <*TRANSIENT*> REFANY;
1245c1256,1257
< IF o.super.typecode = TYPECODE(ROOT) THEN
---
> IF o.super.typecode = TYPECODE(ROOT)
> OR o.super.typecode = TYPECODE(<*TRANSIENT*> ROOT) THEN
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/pickle/m3makefile Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pickle/m3makefile
9c9
< sequence ("PklAction", "PklAction")
---
> transientSequence ("PklAction", "PklAction")
11c11
< table ("Packing", "PackingTypeCode", "Refany")
---
> transientTable ("Packing", "PackingTypeCode", "RefanyTransient")
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/pickle/PackingTypeCode.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pickle/PackingTypeCode.i3
19,22c19,22
< * $Source: /home/cvsroot/m3/pm3/libs/libm3/src/pickle/PackingTypeCode.i3,v $
< * $Date: 1998/02/26 16:37:33 $
< * $Author: dagenais $
< * $Revision: 1.1 $
---
> * $Source: /u/u84/hosking/CVS/pm3/libs/libm3/src/pickle/PackingTypeCode.i3,v $
> * $Date: 1998/10/28 21:38:58 $
> * $Author: hosking $
> * $Revision: 1.1.1.1 $
24a25,27
> * Revision 1.1.1.1 1998/10/28 21:38:58 hosking
> * Polytechnique de Montreal Modula-3
> *
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/pickle/PackingTypeCode.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pickle/PackingTypeCode.m3
19,22c19,22
< * $Source: /home/cvsroot/m3/pm3/libs/libm3/src/pickle/PackingTypeCode.m3,v $
< * $Date: 1998/02/26 16:37:34 $
< * $Author: dagenais $
< * $Revision: 1.1 $
---
> * $Source: /u/u84/hosking/CVS/pm3/libs/libm3/src/pickle/PackingTypeCode.m3,v $
> * $Date: 1998/10/28 21:38:58 $
> * $Author: hosking $
> * $Revision: 1.1.1.1 $
24a25,27
> * Revision 1.1.1.1 1998/10/28 21:38:58 hosking
> * Polytechnique de Montreal Modula-3
> *
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/pickle/Pickle.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pickle/Pickle.i3
131c131
< WriterPublic = OBJECT
---
> WriterPublic = <*TRANSIENT*> ROOT OBJECT
198c198
< ReaderPublic = OBJECT
---
> ReaderPublic = <*TRANSIENT*> ROOT OBJECT
312c312
< SpecialPublic = OBJECT
---
> SpecialPublic = <*TRANSIENT*> ROOT OBJECT
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/pickle/Pickle.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pickle/Pickle.m3
84c84
< RefTable = REF ARRAY OF RECORD
---
> RefTable = <*TRANSIENT*> REF ARRAY OF RECORD
86c86
< r: REFANY := NIL; (* the Ref *)
---
> <*TRANSIENT*> r: REFANY := NIL; (* the Ref *)
92c92
< RefArray = REF ARRAY OF REFANY;
---
> RefArray = <*TRANSIENT*> REF <*TRANSIENT*> ARRAY OF REFANY;
94c94
< TypeTable = REF ARRAY OF INTEGER;
---
> TypeTable = <*TRANSIENT*> REF ARRAY OF INTEGER;
99c99
< SpecialTable = REF ARRAY OF Special;
---
> SpecialTable = <*TRANSIENT*> REF ARRAY OF Special;
184a185
> RTTypeMap.Kind.TransientRef,
748c749
< IF kind = RTTypeMap.Kind.Ref THEN
---
> IF kind = RTTypeMap.Kind.Ref OR kind = RTTypeMap.Kind.TransientRef THEN
853c854
< IF kind = RTTypeMap.Kind.Ref THEN
---
> IF kind = RTTypeMap.Kind.Ref OR kind = RTTypeMap.Kind.TransientRef THEN
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/pickle/PickleRd.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pickle/PickleRd.i3
19,22c19,22
< * $Source: /home/cvsroot/m3/pm3/libs/libm3/src/pickle/PickleRd.i3,v $
< * $Date: 1998/02/26 16:37:34 $
< * $Author: dagenais $
< * $Revision: 1.1 $
---
> * $Source: /u/u84/hosking/CVS/pm3/libs/libm3/src/pickle/PickleRd.i3,v $
> * $Date: 1998/10/28 21:38:59 $
> * $Author: hosking $
> * $Revision: 1.1.1.1 $
24a25,27
> * Revision 1.1.1.1 1998/10/28 21:38:59 hosking
> * Polytechnique de Montreal Modula-3
> *
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/pickle/PickleStubs.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pickle/PickleStubs.i3
19,22c19,22
< * $Source: /home/cvsroot/m3/pm3/libs/libm3/src/pickle/PickleStubs.i3,v $
< * $Date: 1998/02/26 16:37:34 $
< * $Author: dagenais $
< * $Revision: 1.1 $
---
> * $Source: /u/u84/hosking/CVS/pm3/libs/libm3/src/pickle/PickleStubs.i3,v $
> * $Date: 1998/10/28 21:38:59 $
> * $Author: hosking $
> * $Revision: 1.1.1.1 $
24a25,27
> * Revision 1.1.1.1 1998/10/28 21:38:59 hosking
> * Polytechnique de Montreal Modula-3
> *
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/pickle/PickleStubs.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pickle/PickleStubs.m3
19,22c19,22
< * $Source: /home/cvsroot/m3/pm3/libs/libm3/src/pickle/PickleStubs.m3,v $
< * $Date: 1998/02/26 16:37:34 $
< * $Author: dagenais $
< * $Revision: 1.1 $
---
> * $Source: /u/u84/hosking/CVS/pm3/libs/libm3/src/pickle/PickleStubs.m3,v $
> * $Date: 1998/10/28 21:38:59 $
> * $Author: hosking $
> * $Revision: 1.1.1.1 $
24a25,27
> * Revision 1.1.1.1 1998/10/28 21:38:59 hosking
> * Polytechnique de Montreal Modula-3
> *
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/pickle/PklAction.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pickle/PklAction.i3
19,22c19,22
< * $Source: /home/cvsroot/m3/pm3/libs/libm3/src/pickle/PklAction.i3,v $
< * $Date: 1998/02/26 16:37:34 $
< * $Author: dagenais $
< * $Revision: 1.1 $
---
> * $Source: /u/u84/hosking/CVS/pm3/libs/libm3/src/pickle/PklAction.i3,v $
> * $Date: 1999/03/25 22:22:36 $
> * $Author: hosking $
> * $Revision: 1.2 $
24a25,30
> * Revision 1.2 1999/03/25 22:22:36 hosking
> * Cleaned up some template types to allow transient instances.
> *
> * Revision 1.1.1.1 1998/10/28 21:38:59 hosking
> * Polytechnique de Montreal Modula-3
> *
38c44
< T = OBJECT kind: Kind; length: INTEGER END;
---
> T = <*TRANSIENT*> ROOT OBJECT kind: Kind; length: INTEGER END;
79c85
< field : REF ARRAY OF CARDINAL;
---
> field : <*TRANSIENT*> REF ARRAY OF CARDINAL;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/pickle/PklTipeMap.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pickle/PklTipeMap.i3
19,22c19,22
< * $Source: /home/cvsroot/m3/pm3/libs/libm3/src/pickle/PklTipeMap.i3,v $
< * $Date: 1998/02/26 16:37:34 $
< * $Author: dagenais $
< * $Revision: 1.1 $
---
> * $Source: /u/u84/hosking/CVS/pm3/libs/libm3/src/pickle/PklTipeMap.i3,v $
> * $Date: 1998/10/28 21:38:59 $
> * $Author: hosking $
> * $Revision: 1.1.1.1 $
24a25,27
> * Revision 1.1.1.1 1998/10/28 21:38:59 hosking
> * Polytechnique de Montreal Modula-3
> *
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/pickle/PklTipeMap.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pickle/PklTipeMap.m3
19,22c19,22
< * $Source: /home/cvsroot/m3/pm3/libs/libm3/src/pickle/PklTipeMap.m3,v $
< * $Date: 1998/02/26 16:37:34 $
< * $Author: dagenais $
< * $Revision: 1.1 $
---
> * $Source: /u/u84/hosking/CVS/pm3/libs/libm3/src/pickle/PklTipeMap.m3,v $
> * $Date: 1998/12/15 22:42:30 $
> * $Author: hosking $
> * $Revision: 1.2 $
24a25,30
> * Revision 1.2 1998/12/15 22:42:30 hosking
> * Added new TransientRef opcode in type maps.
> *
> * Revision 1.1.1.1 1998/10/28 21:39:00 hosking
> * Polytechnique de Montreal Modula-3
> *
114c120,121
< "Set" (* bit set *)
---
> "Set", (* bit set *)
> "TransientRef"
133c140,141
< RTTypeMap.Kind.Set
---
> RTTypeMap.Kind.Set,
> RTTypeMap.Kind.TransientRef
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/pqueue/m3makefile Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pqueue/m3makefile
8a9
> Generic_interface ("PQueueTransientRep")
12d12
< Pqueue ("Atom", "Atom")
15a16,20
>
> TransientPqueue ("Atom", "Atom")
> TransientPqueue ("IntTransient", "Integer")
> TransientPqueue ("RefTransient", "RefanyTransient")
> TransientPqueue ("TextTransient", "Text")
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/pqueue/PQueue.ig Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pqueue/PQueue.ig
12c12
< GENERIC INTERFACE PQueue(Priority);
---
> GENERIC INTERFACE PQueue(Super, Priority);
28c28
< EltBrand = "(PQueueElt " & Priority.Brand & ")";
---
> EltBrand = "(" & Super.Brand & " PQueueElt " & Priority.Brand & ")";
32c32
< Elt <: OBJECT
---
> Elt <: Super.T OBJECT
51c51
< T = OBJECT METHODS
---
> T = Super.T OBJECT METHODS
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/pqueue/PQueue.mg Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pqueue/PQueue.mg
6c6
< GENERIC MODULE PQueue(Priority, PQ, PQRep);
---
> GENERIC MODULE PQueue(Super, Priority, PQ, PQRep);
10c10
< EltPub = OBJECT
---
> EltPub = Super.T OBJECT
79c79
< THEN pq.heap := NEW(REF ARRAY OF Elt, sizeHint + 1)
---
> THEN pq.heap := NEW(PQRep.EltsArray, sizeHint + 1)
90c90
< THEN pq.heap := NEW(REF ARRAY OF Elt, newSz + 1)
---
> THEN pq.heap := NEW(PQRep.EltsArray, newSz + 1)
106c106
< VAR new := NEW(REF ARRAY OF Elt, NUMBER(pq.heap^) * 2); BEGIN
---
> VAR new := NEW(PQRep.EltsArray, NUMBER(pq.heap^) * 2); BEGIN
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/pqueue/pqueue.tmpl Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pqueue/pqueue.tmpl
14c14
< build_generic_intf (pq, "PQueue", [elt], vis)
---
> build_generic_intf (pq, "PQueue", ["Root", elt], vis)
16c16,24
< build_generic_impl (pq, "PQueue", [elt, pq, rep])
---
> build_generic_impl (pq, "PQueue", ["Root", elt, pq, rep])
> end
>
> readonly proc _build_transient_pqueue(nm, elt, vis) is
> local pq = nm & "PQ"
> local rep = pq & "Rep"
> build_generic_intf (pq, "PQueue", ["RootTransient", elt], vis)
> build_generic_intf (rep, "PQueueTransientRep", [pq], vis)
> build_generic_impl (pq, "PQueue", ["RootTransient", elt, pq, rep])
24a33,40
> end
>
> readonly proc transientPqueue (nm, elt) is
> _build_transient_pqueue(nm, elt, HIDDEN)
> end
>
> readonly proc TransientPqueue (nm, elt) is
> _build_transient_pqueue(nm, elt, VISIBLE)
Only in Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/pqueue: PQueueTransientRep.ig
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/random/Common/Random.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/random/Common/Random.i3
22c22
< T = OBJECT METHODS
---
> T = ROOT OBJECT METHODS
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/FileRd.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/FileRd.m3
19c19
< TYPE CharBuffer = REF ARRAY OF CHAR;
---
> TYPE CharBuffer = <*TRANSIENT*> REF ARRAY OF CHAR;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/FileWr.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/FileWr.m3
45c45
< TYPE CharBuffer = REF ARRAY OF CHAR;
---
> TYPE CharBuffer = <*TRANSIENT*> REF ARRAY OF CHAR;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/NullWr.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/NullWr.m3
32c32
< wr.buff := NEW(REF ARRAY OF CHAR, BuffSize);
---
> wr.buff := NEW(<*TRANSIENT*> REF ARRAY OF CHAR, BuffSize);
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/RdClass.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/RdClass.i3
27c27
< Private <: ROOT;
---
> Private <: <*TRANSIENT*> ROOT;
33c33
< buff : REF ARRAY OF CHAR;
---
> buff : <*TRANSIENT*> REF ARRAY OF CHAR;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/Rd.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/Rd.i3
98c98
< TYPE T <: ROOT;
---
> TYPE T <: <*TRANSIENT*> ROOT;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/TextRd.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/TextRd.m3
27c27
< rd.buff := NEW(REF ARRAY OF CHAR, len);
---
> rd.buff := NEW(<*TRANSIENT*> REF ARRAY OF CHAR, len);
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/TextWr.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/TextWr.m3
33,34c33,34
< Buffer = REF ARRAY OF CHAR;
< BufferList = REF ARRAY OF Buffer;
---
> Buffer = <*TRANSIENT*> REF ARRAY OF CHAR;
> BufferList = <*TRANSIENT*> REF ARRAY OF Buffer;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/WrClass.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/WrClass.i3
79c79
< Private <: ROOT;
---
> Private <: <*TRANSIENT*> ROOT;
83c83
< buff : REF ARRAY OF CHAR;
---
> buff : <*TRANSIENT*> REF ARRAY OF CHAR;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/Wr.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/rw/Common/Wr.i3
104c104
< TYPE T <: ROOT;
---
> TYPE T <: <*TRANSIENT*> ROOT;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/sequence/m3makefile Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/sequence/m3makefile
13a14
> Generic_interface("SequenceTransientRep")
19d19
< Sequence ("Atom", "Atom")
22a23,27
>
> TransientSequence ("Atom", "Atom")
> TransientSequence ("IntTransient", "Integer")
> TransientSequence ("RefTransient", "RefanyTransient")
> TransientSequence ("TextTransient", "Text")
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/sequence/Sequence.ig Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/sequence/Sequence.ig
28c28
< GENERIC INTERFACE Sequence(Elem);
---
> GENERIC INTERFACE Sequence(Super, Elem);
41c41
< Brand = "(Sequence " & Elem.Brand & ")";
---
> Brand = "(" & Super.Brand & " Sequence " & Elem.Brand & ")";
45c45
< Public = OBJECT METHODS
---
> Public = Super.T OBJECT METHODS
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/sequence/sequence.tmpl Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/sequence/sequence.tmpl
17c17
< build_generic_intf (seq, "Sequence", [elt], vis)
---
> build_generic_intf (seq, "Sequence", ["Root", elt], vis)
27a28,44
> end
>
> readonly proc _build_transient_sequence (nm, elt, vis) is
> local seq = nm & "Seq"
> local rep = nm & "SeqRep"
>
> build_generic_intf (seq, "Sequence", ["RootTransient", elt], vis)
> build_generic_intf (rep, "SequenceTransientRep", [elt, seq], vis)
> build_generic_impl (seq, "Sequence", [elt, seq, rep])
> end
>
> readonly proc transientSequence (nm, elt) is
> _build_transient_sequence (nm, elt, HIDDEN)
> end
>
> readonly proc TransientSequence (nm, elt) is
> _build_transient_sequence (nm, elt, VISIBLE)
Only in Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/sequence: SequenceTransientRep.ig
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/sortedtable/m3makefile Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/sortedtable/m3makefile
9a10,11
> Generic_interface("SortedTableRep")
> Generic_interface("SortedTableTransientRep")
15,18c17,21
< Sorted_table ("AtomAtom", "Atom", "Atom")
< Sorted_table ("AtomInt", "Atom", "Integer")
< Sorted_table ("AtomRef", "Atom", "Refany")
< Sorted_table ("AtomText", "Atom", "Text")
---
> TransientSorted_table ("AtomAtom", "Atom", "Atom")
> TransientSorted_table ("AtomInt", "Atom", "Integer")
> TransientSorted_table ("AtomRefTransient", "Atom", "RefanyTransient")
> TransientSorted_table ("AtomRef", "Atom", "Refany")
> TransientSorted_table ("AtomText", "Atom", "Text")
20d22
< Sorted_table ("IntAtom", "Integer", "Atom")
25c27,31
< Sorted_table ("RefAtom", "Refany", "Atom")
---
> TransientSorted_table ("IntAtom", "Integer", "Atom")
> TransientSorted_table ("IntIntTransient", "Integer", "Integer")
> TransientSorted_table ("IntRefTransient", "Integer", "RefanyTransient")
> TransientSorted_table ("IntTextTransient", "Integer", "Text")
>
30c36,41
< Sorted_table ("TextAtom", "Text", "Atom")
---
> TransientSorted_table ("RefAtom", "Refany", "Atom")
> TransientSorted_table ("RefAtomTransient", "RefanyTransient", "Atom")
> TransientSorted_table ("RefIntTransient", "RefanyTransient", "Integer")
> TransientSorted_table ("RefRefTransient", "RefanyTransient", "RefanyTransient")
> TransientSorted_table ("RefTextTransient", "RefanyTransient", "Text")
>
33a45,49
>
> TransientSorted_table ("TextAtom", "Text", "Atom")
> TransientSorted_table ("TextIntTransient", "Text", "Integer")
> TransientSorted_table ("TextRefTransient", "Text", "RefanyTransient")
> TransientSorted_table ("TextTextTransient", "Text", "Text")
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/sortedtable/SortedTable.mg Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/sortedtable/SortedTable.mg
14c14
< GENERIC MODULE SortedTable (Key, Value, Tbl);
---
> GENERIC MODULE SortedTable (Key, Value, Tbl, Rep);
18a19
> FROM Rep IMPORT Node;
48,55d48
< END;
<
< TYPE
< Node = REF RECORD
< key : Key.T;
< value : Value.T;
< child := ARRAY [0..1] OF Node { NIL, NIL };
< priority: INTEGER (* random num; tree is a heap on these *)
Only in Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/sortedtable: SortedTableRep.ig
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/sortedtable/sortedtable.tmpl Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/sortedtable/sortedtable.tmpl
14a15
> local rep = tab & "Rep"
16c17,18
< build_generic_impl (tab, "SortedTable", [key, value, base])
---
> build_generic_intf (rep, "SortedTableRep", [key, value], VISIBLE)
> build_generic_impl (tab, "SortedTable", [key, value, base, rep])
21a24
> local rep = tab & "Rep"
23c26,45
< build_generic_impl (tab, "SortedTable", [key, value, base])
---
> build_generic_intf (rep, "SortedTableRep", [key, value], HIDDEN)
> build_generic_impl (tab, "SortedTable", [key, value, base, rep])
> end
>
> readonly proc TransientSorted_table (nm, key, value) is
> local base = nm & "Tbl"
> local tab = "Sorted" & base
> local rep = tab & "Rep"
> build_generic_intf (tab, "SortedTable", [key, base], VISIBLE)
> build_generic_intf (rep, "SortedTableTransientRep", [key, value], VISIBLE)
> build_generic_impl (tab, "SortedTable", [key, value, base, rep])
> end
>
> readonly proc transientSorted_table (nm, key, value) is
> local base = nm & "Tbl"
> local tab = "Sorted" & base
> local rep = tab & "Rep"
> build_generic_intf (tab, "SortedTable", [key, base], HIDDEN)
> build_generic_intf (rep, "SortedTableTransientRep", [key, value], HIDDEN)
> build_generic_impl (tab, "SortedTable", [key, value, base, rep])
Only in Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/sortedtable: SortedTableTransientRep.ig
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/sx/Sx.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/sx/Sx.m3
133,136c133,136
< MList = REF RECORD
< ch : CHAR;
< m : ReadMacro;
< next: MList := NIL
---
> MList = <*TRANSIENT*> REF RECORD
> ch: CHAR;
> <*TRANSIENT*> m: ReadMacro;
> next: MList := NIL
297,298c297,298
< buff := NEW (REF ARRAY OF CHAR, MAXLEN), lo := 0, st := 0,
< seekable := TRUE, intermittent := FALSE);
---
> buff := NEW (<*TRANSIENT*> REF ARRAY OF CHAR, MAXLEN),
> lo := 0, st := 0, seekable := TRUE, intermittent := FALSE);
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/table/m3makefile Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/table/m3makefile
7a8,9
> Generic_interface("TableRep")
> Generic_interface("TableTransientRep")
13,16c15,19
< Table ("AtomAtom", "Atom", "Atom")
< Table ("AtomInt", "Atom", "Integer")
< Table ("AtomRef", "Atom", "Refany")
< Table ("AtomText", "Atom", "Text")
---
> TransientTable ("AtomAtom", "Atom", "Atom")
> TransientTable ("AtomInt", "Atom", "Integer")
> TransientTable ("AtomRef", "Atom", "Refany")
> TransientTable ("AtomRefTransient", "Atom", "RefanyTransient")
> TransientTable ("AtomText", "Atom", "Text")
18d20
< Table ("IntAtom", "Integer", "Atom")
23c25,29
< Table ("RefAtom", "Refany", "Atom")
---
> TransientTable ("IntAtom", "Integer", "Atom")
> TransientTable ("IntIntTransient", "Integer", "Integer")
> TransientTable ("IntRefTransient", "Integer", "RefanyTransient")
> TransientTable ("IntTextTransient", "Integer", "Text")
>
28c34,39
< Table ("TextAtom", "Text", "Atom")
---
> TransientTable ("RefAtom", "Refany", "Atom")
> TransientTable ("RefAtomTransient", "RefanyTransient", "Atom")
> TransientTable ("RefIntTransient", "RefanyTransient", "Integer")
> TransientTable ("RefRefTransient", "RefanyTransient", "RefanyTransient")
> TransientTable ("RefTextTransient", "RefanyTransient", "Text")
>
32a44,47
> TransientTable ("TextAtom", "Text", "Atom")
> TransientTable ("TextIntTransient", "Text", "Integer")
> TransientTable ("TextRefTransient", "Text", "RefanyTransient")
> TransientTable ("TextTextTransient", "Text", "Text")
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/table/Table.ig Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/table/Table.ig
18c18
< GENERIC INTERFACE Table(Key, Value);
---
> GENERIC INTERFACE Table(Super, Key, Value);
45c45
< Brand = "(Table " & Key.Brand & " " & Value.Brand & ")";
---
> Brand = "(" & Super.Brand & " Table " & Key.Brand & " " & Value.Brand & ")";
50c50
< T = OBJECT METHODS
---
> T = Super.T OBJECT METHODS
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/table/Table.mg Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/table/Table.mg
14c14
< GENERIC MODULE Table(Key, Value);
---
> GENERIC MODULE Table(Key, Value, Rep);
18a19
> FROM Rep IMPORT BucketArray, EntryList;
30c31
< buckets: REF ARRAY OF EntryList;
---
> buckets: BucketArray;
46,51d46
< TYPE EntryList = REF RECORD
< key: Key.T;
< value: Value.T;
< tail: EntryList
< END;
<
209c204
< tbl.buckets := NEW(REF ARRAY OF EntryList, numBuckets);
---
> tbl.buckets := NEW(BucketArray, numBuckets);
Only in Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/table: TableRep.ig
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/table/table.tmpl Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/table/table.tmpl
13,14c13,16
< build_generic_intf (tab, "Table", [key, value], VISIBLE)
< build_generic_impl (tab, "Table", [key, value])
---
> local tabrep = nm & "TblRep"
> build_generic_intf (tab, "Table", ["Root", key, value], VISIBLE)
> build_generic_intf (tabrep, "TableRep", [key, value], VISIBLE)
> build_generic_impl (tab, "Table", [key, value, tabrep])
19,20c21,40
< build_generic_intf (tab, "Table", [key, value], HIDDEN)
< build_generic_impl (tab, "Table", [key, value])
---
> local tabrep = nm & "TblRep"
> build_generic_intf (tab, "Table", ["Root", key, value], HIDDEN)
> build_generic_intf (tabrep, "TableRep", [key, value], HIDDEN)
> build_generic_impl (tab, "Table", [key, value, tabrep])
> end
>
> readonly proc TransientTable (nm, key, value) is
> local tab = nm & "Tbl"
> local tabrep = nm & "TblRep"
> build_generic_intf (tab, "Table", ["RootTransient", key, value], VISIBLE)
> build_generic_intf (tabrep, "TableTransientRep", [key, value], VISIBLE)
> build_generic_impl (tab, "Table", [key, value, tabrep])
> end
>
> readonly proc transientTable (nm, key, value) is
> local tab = nm & "Tbl"
> local tabrep = nm & "TblRep"
> build_generic_intf (tab, "Table", ["RootTransient", key, value], HIDDEN)
> build_generic_intf (tabrep, "TableTransientRep", [key, value], HIDDEN)
> build_generic_impl (tab, "Table", [key, value, tabrep])
Only in Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/table: TableTransientRep.ig
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/types/m3makefile Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/types/m3makefile
20a21,23
> Module ("Root")
> Module ("RefanyTransient")
> Module ("RootTransient")
27a31,33
> HtmlInterface("Root")
> HtmlInterface("RefanyTransient")
> HtmlInterface("RootTransient")
Only in Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/types: RefanyTransient.i3
Only in Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/types: RefanyTransient.m3
Only in Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/types: Root.i3
Only in Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/types: Root.m3
Only in Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/types: RootTransient.i3
Only in Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/types: RootTransient.m3
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/libm3/src/uid/Common/Capability.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/libm3/src/uid/Common/Capability.m3
14c14
< VAR state := NEW(Thread.Mutex OBJECT r: Random.T := NIL; END);
---
> VAR state := NEW(Thread.Mutex OBJECT <*TRANSIENT*> r: Random.T := NIL; END);
Only in Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/C/FreeBSD3: Cstdio.i3.orig
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/Csupport/SUN386/waitpid.c Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/Csupport/SUN386/waitpid.c
31c31
< static char rcsid[] = "$Header: /home/cvsroot/m3/pm3/libs/m3core/src/Csupport/SUN386/waitpid.c,v 1.1.1.1 1997/01/16 21:30:02 ldd Exp $ SPRITE (Berkeley)";
---
> static char rcsid[] = "$Header: /u/u84/hosking/CVS/pm3/libs/m3core/src/Csupport/SUN386/waitpid.c,v 1.1.1.1 1998/10/28 21:39:46 hosking Exp $ SPRITE (Berkeley)";
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/fingerprint/Fingerprint.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/fingerprint/Fingerprint.i3
65a66,69
> PROCEDURE Compare(fp1, fp2: T): [-1..1];
> (* Return -1 if "fp1" occurs before "fp2", 0 if "Equal(fp1, fp2)", +1 if
> "fp1" occurs after "fp2" in lexicographic order. *)
>
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/fingerprint/Fingerprint.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/fingerprint/Fingerprint.m3
107a108,117
> PROCEDURE Compare(fp1, fp2: T): [-1..1] =
> BEGIN
> FOR i := 0 TO 7 DO
> IF fp1.byte[i] < fp2.byte[i] THEN RETURN -1;
> ELSIF fp1.byte[i] > fp2.byte[i] THEN RETURN +1;
> END;
> END;
> RETURN 0;
> END Compare;
>
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/ALPHA_OSF/RTHeapDepC.c Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/ALPHA_OSF/RTHeapDepC.c
1296c1296
< result = syscall(SYS_sigaction, signal, action, o_action);
---
> result = __sigaction(signal, action, o_action);
1307c1307
< result = syscall(SYS_sigpending, set);
---
> result = __sigpending(set);
1321c1321
< result = syscall(SYS_sigprocmask, how, set, o_set);
---
> result = __sigprocmask(how, set, o_set);
1368c1368
< result = syscall(SYS_sigsuspend, signal_mask);
---
> result = __sigsuspend(signal_mask);
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/ALPHA_OSF/RTHeapDep.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/ALPHA_OSF/RTHeapDep.m3
19,20c19,21
< PROCEDURE Fault (sig: Ctypes.int; code: Ctypes.int;
< scp: UNTRACED REF Usignal.struct_sigcontext) =
---
> PROCEDURE Fault (sig: Ctypes.int;
> sip: UNTRACED REF Usignal.siginfo_t;
> scp: UNTRACED REF Usignal.struct_sigcontext) =
23a25
> VAR sip_fault := LOOPHOLE(sip, UNTRACED REF Usignal.siginfo_t_fault);
26,29c28,32
< (* The field "sc_traparg_a0" of a "Usignal.struct_sigcontext"
< is the virtual address that caused the fault. *)
< IF scp # NIL AND RTHeapRep.Fault(LOOPHOLE(scp.sc_traparg_a0, ADDRESS)) THEN
< RETURN
---
> IF sig = Usignal.SIGSEGV AND sip # NIL THEN
> <*ASSERT sig = sip.si_signo*>
> IF RTHeapRep.Fault(sip_fault.si_addr) THEN
> RETURN;
> END
35c38
< Core(sig, code, scp);
---
> Core(sig, sip, scp);
37c40
< origSIGSEGV(sig, code, scp);
---
> origSIGSEGV(sig, sip, scp);
44,45c47,49
< PROCEDURE Core (sig: Ctypes.int; <*UNUSED*> code: Ctypes.int;
< <*UNUSED*> scp: UNTRACED REF Usignal.struct_sigcontext) =
---
> PROCEDURE Core (sig: Ctypes.int;
> <*UNUSED*> sip: UNTRACED REF Usignal.siginfo_t;
> <*UNUSED*> scp: UNTRACED REF Usignal.struct_sigcontext) =
50,54d53
< VAR
< (* default signal handler *)
< in_vec := Usignal.struct_sigvec{
< sv_handler := Usignal.SIG_DFL, sv_mask := 0, sv_flags := 0};
< dummy_vec: Usignal.struct_sigvec;
63,64c62,77
< EVAL Usignal.sigvec(sig, in_vec, (*OUT*) dummy_vec);
< EVAL Usignal.sigsetmask(0);
---
>
> (* establish default handler *)
> VAR
> new, old: Usignal.struct_sigaction;
> BEGIN
> new.sa_flags := 0;
> new.sa_handler := Usignal.SIG_DFL;
> EVAL Usignal.sigemptyset(new.sa_mask);
> EVAL Usignal.sigaction(sig, new, old);
> END;
>
> VAR set: Usignal.sigset_t;
> BEGIN
> EVAL Usignal.sigemptyset(set);
> EVAL Usignal.sigprocmask(Usignal.SIG_SETMASK, set);
> END;
77,79d89
< CONST
< (* block the "SIGVTALRM" signal when signal handlers are called *)
< Mask = Word.LeftShift(1, Usignal.SIGVTALRM - 1);
89,92c99
< in_vec := Usignal.struct_sigvec{
< sv_handler := Fault, sv_mask := Mask, sv_flags := 0};
< out_vec: Usignal.struct_sigvec;
< ret := Usignal.sigvec(Usignal.SIGSEGV, in_vec, (*OUT*) out_vec);
---
> new, old : Usignal.struct_sigaction;
94,95c101,117
< <* ASSERT ret = 0 *>
< origSIGSEGV := out_vec.sv_handler;
---
> new.sa_flags := Word.Or(Usignal.SA_NODEFER,
> Word.Or(Usignal.SA_RESTART, Usignal.SA_SIGINFO));
> new.sa_handler := Fault;
> WITH i = Usignal.sigemptyset(new.sa_mask) DO
> <*ASSERT i = 0*>
> END;
> (* block the "SIGVTALRM" signal when signal handlers are called *)
> WITH i = Usignal.sigaddset(new.sa_mask, Usignal.SIGVTALRM) DO
> <*ASSERT i = 0*>
> END;
> WITH i = Usignal.sigaddset(new.sa_mask, Usignal.SIGINT) DO
> <*ASSERT i = 0*>
> END;
> WITH i = Usignal.sigaction(Usignal.SIGSEGV, new, old) DO
> <*ASSERT i = 0*>
> END;
> origSIGSEGV := old.sa_handler;
100c122
< install a for "sig" that dumps core. *)
---
> install a handler for "sig" that dumps core. *)
102,105c124
< in_vec := Usignal.struct_sigvec{
< sv_handler := Core, sv_mask := Mask, sv_flags := 0};
< out_vec: Usignal.struct_sigvec;
< ret := Usignal.sigvec(sig, in_vec, (*OUT*) out_vec);
---
> new, old: Usignal.struct_sigaction;
107c126,136
< <* ASSERT ret = 0 *>
---
> new.sa_flags := Usignal.SA_SIGINFO;
> new.sa_handler := Core;
> WITH i = Usignal.sigemptyset(new.sa_mask) DO
> <*ASSERT i = 0*>
> END;
> WITH i = Usignal.sigaddset(new.sa_mask, Usignal.SIGVTALRM) DO
> <*ASSERT i = 0*>
> END;
> WITH i = Usignal.sigaction(sig, new, old) DO
> <*ASSERT i = 0*>
> END;
109,113c138,141
< IF out_vec.sv_handler # Usignal.SIG_DFL THEN
< VAR dummy_vec: Usignal.struct_sigvec; BEGIN
< ret := Usignal.sigvec(sig, out_vec, (*OUT*) dummy_vec);
< <* ASSERT ret = 0 *>
< END
---
> IF old.sa_handler # Usignal.SIG_DFL THEN
> WITH i = Usignal.sigaction(sig, old, new) DO
> <*ASSERT i = 0*>
> END;
155c183
< ret := Uresource.getrusage(Uresource.RUSAGE_SELF, (*OUT*) ADR(usage));
---
> ret := Uresource.getrusage(Uresource.RUSAGE_SELF, usage);
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/ALPHA_OSF/RTSignal.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/ALPHA_OSF/RTSignal.m3
14c14,15
< SigInfo = UNTRACED REF Usignal.struct_sigcontext;
---
> SigInfo = UNTRACED REF Usignal.siginfo_t;
> SigContext = UNTRACED REF Usignal.struct_sigcontext;
19c20
< initial_handlers : ARRAY [0..5] OF Usignal.struct_sigvec;
---
> initial_handlers : ARRAY [0..5] OF Usignal.struct_sigaction;
38c39
< VAR new: Usignal.struct_sigvec;
---
> VAR new: Usignal.struct_sigaction;
40,44c41,49
< new.sv_handler := LOOPHOLE (handler, Usignal.SignalHandler);
< new.sv_mask := Usignal.empty_sv_mask;
< new.sv_flags := 0;
< EVAL Usignal.sigvec (sig, new, initial_handlers[id]);
< IF (initial_handlers[id].sv_handler # DefaultHandler) THEN
---
> new.sa_handler := LOOPHOLE (handler, Usignal.SignalHandler);
> new.sa_flags := Usignal.SA_SIGINFO;
> WITH i = Usignal.sigemptyset(new.sa_mask) DO
> <*ASSERT i = 0*>
> END;
> WITH i = Usignal.sigaction (sig, new, initial_handlers[id]) DO
> <*ASSERT i = 0*>
> END;
> IF (initial_handlers[id].sa_handler # DefaultHandler) THEN
46c51,53
< EVAL Usignal.sigvec (sig, initial_handlers[id], new);
---
> WITH i = Usignal.sigaction (sig, initial_handlers[id], new) DO
> <*ASSERT i = 0*>
> END;
61c68
< VAR old: Usignal.struct_sigvec;
---
> VAR old: Usignal.struct_sigaction;
63c70
< EVAL Usignal.sigvec (sig, initial_handlers[id], old);
---
> EVAL Usignal.sigaction (sig, initial_handlers[id], old);
66,71c73,80
< PROCEDURE Shutdown (sig: int; <*UNUSED*> code: int; <*UNUSED*> scp: SigInfo) =
< VAR new, old: Usignal.struct_sigvec;
< BEGIN
< new.sv_handler := DefaultHandler;
< new.sv_mask := Usignal.empty_sv_mask;
< new.sv_flags := 0;
---
> PROCEDURE Shutdown (sig: int;
> <*UNUSED*> sip: SigInfo;
> <*UNUSED*> scp: SigContext) =
> VAR new, old: Usignal.struct_sigaction;
> BEGIN
> new.sa_handler := DefaultHandler;
> new.sa_flags := 0;
> EVAL Usignal.sigemptyset(new.sa_mask);
73c82
< EVAL Usignal.sigvec (sig, new, old); (* restore default handler *)
---
> EVAL Usignal.sigaction (sig, new, old); (* restore default handler *)
77c86
< PROCEDURE Interrupt (sig: int; code: int; scp: SigInfo) =
---
> PROCEDURE Interrupt (sig: int; sip: SigInfo; scp: SigContext) =
81c90
< Shutdown (sig, code, scp);
---
> Shutdown (sig, sip, scp);
88c97,99
< PROCEDURE Quit (<*UNUSED*> sig, code: int; scp: SigInfo) =
---
> PROCEDURE Quit (<*UNUSED*> sig: int;
> <*UNUSED*> sip: SigInfo;
> scp: SigContext) =
95c106,108
< PROCEDURE SegV (<*UNUSED*> sig, code: int; scp: SigInfo) =
---
> PROCEDURE SegV (<*UNUSED*> sig: int;
> <*UNUSED*> sip: SigInfo;
> scp: SigContext) =
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/ALPHA_OSF/RTThread.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/ALPHA_OSF/RTThread.m3
89a90,92
> VAR
> ThreadSwitchSignal: Usignal.sigset_t;
>
91c94
< VAR sv, osv: Usignal.struct_sigvec; i: INTEGER;
---
> VAR new, old: Usignal.struct_sigaction;
93,97c96,103
< sv.sv_handler := handler;
< sv.sv_mask := Usignal.empty_sv_mask;
< sv.sv_flags := 0;
< i := Usignal.sigvec (Usignal.SIGVTALRM, sv, osv);
< <*ASSERT i = 0*>
---
> new.sa_handler := handler;
> new.sa_flags := Word.Or(Usignal.SA_RESTART, Usignal.SA_SIGINFO);
> WITH i = Usignal.sigemptyset(new.sa_mask) DO
> <* ASSERT i = 0 *>
> END;
> WITH i = Usignal.sigaction (Usignal.SIGVTALRM, new, old) DO
> <* ASSERT i = 0 *>
> END;
101d106
< VAR i : Word.T;
103,105c108,110
< i := Usignal.sigsetmask (0);
< i := Word.And (i, Word.Not (Usignal.sigmask (Usignal.SIGVTALRM)));
< EVAL Usignal.sigsetmask (i);
---
> WITH i = Usignal.sigprocmask(Usignal.SIG_UNBLOCK, ThreadSwitchSignal) DO
> <* ASSERT i = 0 *>
> END;
109d113
< VAR i : Word.T;
111,113c115,117
< i := Usignal.sigsetmask (0);
< i := Word.Or (i, Usignal.sigmask (Usignal.SIGVTALRM));
< EVAL Usignal.sigsetmask (i);
---
> WITH i = Usignal.sigprocmask(Usignal.SIG_BLOCK, ThreadSwitchSignal) DO
> <* ASSERT i = 0 *>
> END;
116a121,126
> WITH i = Usignal.sigemptyset(ThreadSwitchSignal) DO
> <* ASSERT i = 0 *>
> END;
> WITH i = Usignal.sigaddset(ThreadSwitchSignal, Usignal.SIGVTALRM) DO
> <* ASSERT i = 0 *>
> END;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/m3makefile Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/m3makefile
24a25,26
> Interface ("RTHeapDB")
> Interface ("RTDB")
49a52
> Interface ("RTTxn")
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTAllocator.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTAllocator.m3
16c16,17
< FROM RTHeapRep IMPORT Header, RefHeader, AllocForNew, Malloc;
---
> FROM RTHeapRep
> IMPORT Header, RefHeader, AllocForNew, AllocForNewTransient, Malloc;
34c35,40
< RETURN Allocate(def);
---
> IF def.traced = 1 THEN
> RETURN Allocate(def);
> ELSE
> <* ASSERT def.traced = 3 *>
> RETURN AllocateTransient(def);
> END;
82c88,93
< RETURN AllocateOpenArray(def, s);
---
> IF def.traced = 1 THEN
> RETURN AllocateOpenArray(def, s);
> ELSE
> <* ASSERT def.traced = 3 *>
> RETURN AllocateTransientOpenArray(def, s);
> END;
148a160,198
> PROCEDURE AllocateTransient (defn: ADDRESS): REFANY =
> VAR
> def : RT0.TypeDefn := defn;
> tc : Typecode := def.typecode;
> res : ADDRESS;
> BEGIN
> RTOS.LockHeap();
> BEGIN
> WITH z = RT0u.alloc_cnts[tc] DO z := Word.Plus (z, 1) END;
> res := AllocForNewTransient(def.dataSize, def.dataAlignment);
> IF (tc <= LAST (initCache)) AND (initCache[tc] # NIL) THEN
> RTMisc.Copy(initCache[tc], res - ADRSIZE(Header),
> def.dataSize + BYTESIZE(Header));
> ELSE
> LOOPHOLE(res - ADRSIZE(Header), RefHeader)^ :=
> Header{typecode := tc, forwarded := FALSE};
> RTMisc.Zero(res, def.dataSize);
> IF def.defaultMethods # NIL THEN
> LOOPHOLE(res, UNTRACED REF ADDRESS)^ := def.defaultMethods;
> END;
> VAR d := def;
> BEGIN
> WHILE d # NIL DO
> IF d.initProc # NIL THEN d.initProc(res); END;
> d := d.parent;
> END;
> END;
> IF (def.dataSize <= BYTESIZE(def^)) AND (tc <= LAST (initCache)) THEN
> initCache[tc] := Malloc(def.dataSize + BYTESIZE(Header));
> RTMisc.Copy(res - ADRSIZE(Header), initCache[tc],
> BYTESIZE(Header) + def.dataSize);
> END;
> END;
> END;
> RTOS.UnlockHeap();
> IF (callback # NIL) THEN callback (LOOPHOLE (res, REFANY)); END;
> RETURN LOOPHOLE(res, REFANY);
> END AllocateTransient;
>
188a239
> <* ASSERT def.traced = 1 *>
194c245
< def.dataAlignment);
---
> def.dataAlignment);
211a263,296
>
> PROCEDURE AllocateTransientOpenArray (defn: ADDRESS; READONLY s: Shape):
> REFANY =
> VAR
> def : RT0.TypeDefn := defn;
> res : ADDRESS;
> nbElems := OpenArrayCount(s);
> nBytes := def.dataSize + nbElems * def.elementSize;
> tc : Typecode := def.typecode;
> BEGIN
> <* ASSERT def.traced = 3 *>
> RTOS.LockHeap();
> BEGIN
> WITH z = RT0u.alloc_cnts[tc] DO z := Word.Plus (z, 1) END;
> WITH z = RT0u.alloc_bytes[tc] DO z := Word.Plus (z, nBytes) END;
> res := AllocForNewTransient(RTMisc.Upper(nBytes, BYTESIZE(Header)),
> def.dataAlignment);
> LOOPHOLE(res - ADRSIZE(Header), RefHeader)^ :=
> Header{typecode := tc, forwarded := FALSE};
> LOOPHOLE(res, UNTRACED REF ADDRESS)^ := res + def.dataSize;
> FOR i := 0 TO NUMBER(s) - 1 DO
> LOOPHOLE(res + ADRSIZE(ADDRESS) + i * ADRSIZE(INTEGER),
> UNTRACED REF INTEGER)^ := s[i];
> END;
> RTMisc.Zero(res + def.dataSize, nbElems * def.elementSize);
> WHILE def # NIL DO
> IF def.initProc # NIL THEN def.initProc(res); END;
> def := def.parent;
> END;
> END;
> RTOS.UnlockHeap();
> IF (callback # NIL) THEN callback (LOOPHOLE (res, REFANY)); END;
> RETURN LOOPHOLE(res, REFANY);
> END AllocateTransientOpenArray;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTBuiltin.c Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTBuiltin.c
68a69,70
> _TYPECELL transient_root;
> _TYPECELL transient_refany;
198,205c200,201
< 0 /* next */
< }
<
< };
<
<
<
<
---
> &SELF.transient_root /* next */
> },
206a203,223
> /*--------- transient root -----------------*/
> /* FP ("$objecttransient") ==> 16_d43028af7d43fb09 => 16_a973d3a6 = -1452026970 */
> { 0, 0, /* typecode */
> -1452026970, /* selfID */
> { 0xd4, 0x30, 0x28, 0xaf, 0x7d, 0x43, 0xfb, 0x09 }, /* fingerprint */
> 3, /* traced, transient */
> 0, WSZ, WSZ, /* data offset, size, alignment */
> 0, WSZ, /* method offset, size */
> 0, 0, /* nDimensions, elementSize */
> 0, /* default methods */
> 0, /* type map */
> 0, /* gc map */
> 0, /* type desc */
> 0, /* initProc */
> 0, /* linkProc */
> 0, /* parent ID */
> 0, 0, 0, /* parent, children, sibling */
> 0, /* brand */
> "TRANSIENT ROOT", /* name */
> &SELF.transient_refany /* next */
> },
207a225,245
> /*--------- transient refany -----------------*/
> /* FP ("$refanytransient") ==> 16_28671e147983a92d => 16_51e4b739 = 1373943609 */
> { 0, 0, /* typecode */
> 1373943609, /* selfID */
> { 0x28, 0x67, 0x1e, 0x14, 0x79, 0x83, 0xa9, 0x2d }, /* fingerprint */
> 3, /* traced, transient */
> 0, WSZ, WSZ, /* data offset, size, alignment */
> 0, 0, /* method offset, size */
> 0, 0, /* nDimensions, elementSize */
> 0, /* default methods */
> 0, /* type map */
> 0, /* gc map */
> 0, /* type desc */
> 0, /* initProc */
> 0, /* linkProc */
> 0, /* parent ID */
> 0, 0, 0, /* parent, children, sibling */
> 0, /* brand */
> "TRANSIENT REFANY", /* name */
> 0 /* next */
> }
208a247
> };
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTBuiltin.m3x Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTBuiltin.m3x
31c31
< I0 1 9 0 0 0 0 0 2 0 0 24 0
---
> I0 1 9 0 0 0 0 0 2 0 0 26 0
70a71,76
>
> /* TRANSIENT ROOT */
> Ta973d3a6
>
> /* TRANSIENT REFANY */
> T51e4b739
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTCollector.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTCollector.m3
5a6
> (* portions Copyright 1998, Purdue Research Foundation *)
15c16
< RTHeapRep, RTWeakRef;
---
> RTHeapRep, RTWeakRef, RTHeapDB;
17c18
< IMPORT RT0, RT0u, RTHeapEvent, RTHeapDep, RTHeapMap, RTMachine;
---
> IMPORT RT0, RT0u, RTIO, RTHeapEvent, RTHeapDep, RTHeapMap, RTMachine;
19a21,22
> IMPORT RTDB, RTTxn, RTTypeMap, RTTypeFP, Fingerprint;
> IMPORT Text, TextF;
22c25,26
< FROM RTIO IMPORT PutText, PutInt;
---
> FROM RTIO IMPORT PutText, PutInt, PutChars;
> IMPORT Cstring;
168a173
> ThreadF.SuspendOthers();
170c175,187
< IF desc[p - p0].protected THEN Unprotect(p); END;
---
> IF ThreadF.myTxn = NIL
> OR map[p - p0] = NIL
> OR map[p - p0].writer = ThreadF.myTxn
> THEN
> IF desc[p - p0].access # Access.ReadWrite THEN
> desc[p - p0].dirty := TRUE;
> Unprotect(p);
> END
> ELSIF map[p - p0].lastReader = ThreadF.myTxn THEN
> IF desc[p - p0].access = Access.None THEN
> Protect(p, Access.ReadOnly);
> END
> END
171a189
> ThreadF.ResumeOthers();
305a324,349
> PROCEDURE OpenArraySize(h: RefHeader; def: TypeDefn): CARDINAL =
> (* the referent is an open array; it has the following layout:
> | pointer to the elements (ADDRESS)
> | size 1
> | ....
> | size n
> | optional padding
> | elements
> | ....
> where n is the number of open dimensions (given by the definition)
> and each size is the number of elements along the dimension *)
> VAR
> res: INTEGER;
> sizes: UNTRACED REF INTEGER := h + ADRSIZE(Header) + ADRSIZE(ADDRESS);
> (* ^ elt pointer*)
> BEGIN
> res := 1;
> FOR i := 0 TO def.nDimensions - 1 DO
> res := res * sizes^;
> INC(sizes, ADRSIZE(sizes^));
> END;
> res := res * def.elementSize;
> res := RTMisc.Upper(res + def.dataSize, BYTESIZE(Header));
> RETURN res;
> END OpenArraySize;
>
322,344c366,367
< (* ELSE, the referent is an open array; it has the following layout:
< | pointer to the elements (ADDRESS)
< | size 1
< | ....
< | size n
< | optional padding
< | elements
< | ....
< where n is the number of open dimensions (given by the definition)
< and each size is the number of elements along the dimension *)
< VAR
< sizes: UNTRACED REF INTEGER := h + ADRSIZE(Header) + ADRSIZE(ADDRESS);
< (* ^ elt pointer*)
< BEGIN
< res := 1;
< FOR i := 0 TO def.nDimensions - 1 DO
< res := res * sizes^;
< INC(sizes, ADRSIZE(sizes^));
< END;
< res := res * def.elementSize;
< END;
< res := RTMisc.Upper(res + def.dataSize, BYTESIZE(Header));
< RETURN res;
---
> (* ELSE, the referent is an open array *)
> RETURN OpenArraySize(h, def);
380a404,424
> PROCEDURE PageToData (p: Page): UNTRACED REF RTHeapDep.PageData =
> BEGIN
> RETURN LOOPHOLE(p * BytesPerPage, UNTRACED REF RTHeapDep.PageData);
> END PageToData;
>
> PROCEDURE RefPageMap (object: REFANY): RTDB.Page =
> VAR p: Page;
> BEGIN
> TRY
> RTOS.LockHeap();
> p := ReferentToPage(LOOPHOLE(object, RefReferent));
> IF p = Nil THEN
> RETURN NIL;
> ELSE
> RETURN map[p - p0];
> END
> FINALLY
> RTOS.UnlockHeap();
> END
> END RefPageMap;
>
383a428,458
> (* The inner-loop collector action is to pick a gray page and completely
> clean it (i.e., make its referents at least gray, so that the page
> becomes black). The current gray page, "impureCopy.page" is
> distinguished; it's the page that newly gray objects are copied to.
>
> To improve locality of referene in the new space, we keep the set of
> gray pages as a stack. This helps approximate a depth-first copy to
> newspace. The current page is not a member of the stack, but will
> become one when it becomes full. The current page is always the page
> that contains new.ptr.
>
> To reduce page faults, we separate the "pure" copy pages (those whose
> objects contain no REFs) from the "impure" ones (those with REFs). Only
> impure pages become gray, since pure pages can have no REFs into the old
> space (since they have no REFs at all). *)
>
> (* By analogy, we also maintain "pureCopy.page" and "pureCopy.stack". These
> are not used, but maintaining them simplifies the code. *)
>
> (* By analogy, we also maintain "new.page" and "new.stack". As with
> pureCopy.page and pureCopy.stack, these are not used, but maintaining them
> simplifies the code. *)
>
> TYPE
> AllocRec = RECORD
> ptr, boundary: RefHeader;
> page: Page := Nil; (* the current page *)
> stack: Page := Nil; (* threaded through the "link" field; ends at Nil *)
> db: RTDB.T;
> END;
>
385,386c460,461
< newPtr, newBoundary: RefHeader;
< (* memory in [newPtr, newBoundary) is available to AllocForNew *)
---
> new: AllocRec;
> (* memory in [new.ptr, new.boundary) is available to AllocForNew *)
388,389c463,468
< pureCopyPtr, pureCopyBoundary: RefHeader;
< (* memory in [pureCopyPtr, pureCopyBoundary) is available to AllocForCopy
---
> newTransient: AllocRec;
> (* memory in [newTransient.ptr, newTransient.boundary) is available to
> AllocForNewTransient *)
>
> pureCopy: AllocRec;
> (* memory in [pureCopy.ptr, pureCopy.boundary) is available to AllocForCopy
392,393c471,472
< impureCopyPtr, impureCopyBoundary: RefHeader;
< (* memory in [impureCopyPtr, impureCopyBoundary) is available to
---
> impureCopy: AllocRec;
> (* memory in [impureCopy.ptr, impureCopy.boundary) is available to
395a475,483
> pureTransientCopy: AllocRec;
> (* memory in [pureTransientCopy.ptr, pureTransientCopy.boundary) is available
> to AllocForCopy for pure objects (objects with no REFs) *)
>
> impureTransientCopy: AllocRec;
> (* memory in [impureTransientCopy.ptr, impureTransientCopy.boundary) is
> available to AllocForCopy for impure objects (objects with
> REFs) *)
>
417c505,525
< IF p + 1 < p1 AND desc[pi + 1].continued THEN
---
> IF map[pi] # NIL THEN
> (* if this is a persistent object, just promote the pages *)
> IF desc[pi].pure THEN
> PromotePage(
> p, Desc{space := Space.Current, generation := copyGeneration,
> pure := TRUE, note := Note.Persistent,
> gray := FALSE, access := desc[pi].access,
> continued := FALSE, resident := desc[pi].resident,
> dirty := FALSE});
> ELSE
> IF desc[pi].access # Access.ReadWrite THEN Unprotect(p) END;
> PromotePage(
> p, Desc{space := Space.Current, generation := copyGeneration,
> pure := FALSE, note := Note.Persistent,
> gray := TRUE, access := Access.ReadWrite,
> continued := FALSE, resident := TRUE,
> dirty := TRUE});
> desc[pi].link := impureCopy.stack;
> impureCopy.stack := p;
> END;
> ELSIF p + 1 < p1 AND desc[pi + 1].continued THEN
423,425c531,534
< p, Desc{space := Space.Current, generation := copyGeneration,
< pure := TRUE, note := Note.Large, gray := FALSE,
< protected := FALSE, continued := FALSE});
---
> p, Desc{space := Space.Current, generation := copyGeneration,
> pure := TRUE, note := Note.Large, gray := FALSE,
> access := Access.ReadWrite, continued := FALSE,
> resident := TRUE, dirty := FALSE});
428,432c537,548
< p, Desc{space := Space.Current, generation := copyGeneration,
< pure := FALSE, note := Note.Large, gray := TRUE,
< protected := FALSE, continued := FALSE});
< desc[pi].link := impureCopyStack;
< impureCopyStack := p;
---
> p, Desc{space := Space.Current, generation := copyGeneration,
> pure := FALSE, note := Note.Large, gray := TRUE,
> access := Access.ReadWrite, continued := FALSE,
> resident := TRUE, dirty := TRUE});
> IF def.traced = 1 THEN
> desc[pi].link := impureCopy.stack;
> impureCopy.stack := p;
> ELSE
> <*ASSERT def.traced = 3*>
> desc[pi].link := impureTransientCopy.stack;
> impureTransientCopy.stack := p;
> END;
446c562,571
< np := AllocForImpureCopy(dataSize, def.dataAlignment);
---
> IF def.traced = 1 THEN
> np := AllocForCopy(dataSize, def.dataAlignment,
> impureCopy,
> pure := FALSE);
> ELSE
> <* ASSERT def.traced = 3 *>
> np := AllocForCopy(dataSize, def.dataAlignment,
> impureTransientCopy,
> pure := FALSE);
> END
448,453c573,582
< np := AllocForPureCopy(dataSize, def.dataAlignment);
< END;
< VAR newHeader := HeaderOf(np);
< BEGIN
< RTMisc.Copy(
< oldHeader, newHeader, BYTESIZE(Header) + dataSize);
---
> IF def.traced = 1 THEN
> np := AllocForCopy(dataSize, def.dataAlignment,
> pureCopy,
> pure := TRUE);
> ELSE
> <* ASSERT def.traced = 3 *>
> np := AllocForCopy(dataSize, def.dataAlignment,
> pureTransientCopy,
> pure := TRUE);
> END
454a584
> RTMisc.Copy(oldHeader, HeaderOf(np), BYTESIZE(Header) + dataSize);
467a598,811
> TYPE TMover = RTHeapMap.Visitor OBJECT OVERRIDES apply := TMove END;
>
> PROCEDURE TMove (<*UNUSED*> self: TMover; cp: ADDRESS) =
> VAR
> refref := LOOPHOLE(cp, UNTRACED REF RefReferent);
> ref := refref^;
> BEGIN
> IF ref = NIL THEN RETURN; END;
> VAR p := ReferentToPage(ref);
> BEGIN
> IF p = Nil THEN RETURN; END;
> VAR
> pi := p - p0;
> oldHeader := HeaderOf(ref);
> BEGIN
> IF desc[pi].space # Space.Previous THEN
> RETURN; (* nothing to do *)
> END;
> IF p + 1 < p1 AND desc[pi + 1].continued THEN
> (* if this is a large object, just promote the pages *)
> VAR def := RTType.Get (oldHeader.typecode);
> BEGIN
> IF def.traced # 3 THEN RETURN END;
> <* ASSERT map[pi] = NIL *>
> IF (def.gc_map = NIL) AND (def.parent = NIL) THEN
> PromotePage(
> p, Desc{space := Space.Current, generation := copyGeneration,
> pure := TRUE, note := Note.Large, gray := FALSE,
> access := Access.ReadWrite, continued := FALSE,
> resident := TRUE, dirty := FALSE});
> ELSE
> PromotePage(
> p, Desc{space := Space.Current, generation := copyGeneration,
> pure := FALSE, note := Note.Large, gray := TRUE,
> access := Access.ReadWrite, continued := FALSE,
> resident := TRUE, dirty := TRUE});
> desc[pi].link := impureTransientCopy.stack;
> impureTransientCopy.stack := p;
> END;
> END;
> ELSIF oldHeader.forwarded THEN
> (* if already moved, just update the reference *)
> refref^ := LOOPHOLE(ref, UNTRACED REF RefReferent)^;
> ELSE
> (* move the object *)
> VAR
> def := RTType.Get(oldHeader.typecode);
> dataSize := ReferentSize(oldHeader);
> np : RefReferent;
> BEGIN
> IF def.traced # 3 THEN RETURN END;
> <* ASSERT map[pi] = NIL *>
> IF (def.gc_map # NIL) OR (def.parent # NIL) THEN
> np := AllocForCopy(dataSize, def.dataAlignment,
> impureTransientCopy,
> pure := FALSE);
> ELSE
> np := AllocForCopy(dataSize, def.dataAlignment,
> pureTransientCopy,
> pure := TRUE);
> END;
> RTMisc.Copy(oldHeader, HeaderOf(np), BYTESIZE(Header) + dataSize);
> IF def.nDimensions # 0 THEN
> (* open array: update the internal pointer *)
> LOOPHOLE(np, UNTRACED REF ADDRESS)^ := np + def.dataSize;
> END;
> oldHeader.forwarded := TRUE;
> LOOPHOLE(ref, UNTRACED REF RefReferent)^ := np;
> refref^ := np;
> END;
> END;
> END;
> END;
> END TMove;
>
> TYPE PMover = RTTypeMap.Visitor OBJECT
> db: RTDB.T
> OVERRIDES
> apply := PMove
> END;
>
> PROCEDURE PMove (self: PMover; cp: ADDRESS; k: RTTypeMap.Kind) =
> VAR
> refref := LOOPHOLE(cp, UNTRACED REF RefReferent);
> ref := refref^;
> text: TEXT;
> BEGIN
> IF ref = NIL THEN RETURN; END;
> <* ASSERT k = RTTypeMap.Kind.Ref *>
> VAR
> p := ReferentToPage(ref);
> oldHeader := HeaderOf(ref);
> BEGIN
> IF p = Nil THEN
> (* Must be statically allocated text constant. *)
> (* Get a copy in the heap *)
> <* ASSERT oldHeader.typecode = RT0.TextTypecode *>
> text := TextF.New(Text.Length(LOOPHOLE(ref, TEXT)));
> text^ := LOOPHOLE(ref, TEXT)^;
> (*
> text := NIL;
> self.db.mapText(LOOPHOLE(ref, TEXT), text);
> *)
> refref^ := LOOPHOLE(text, RefReferent);
> RETURN;
> END;
> VAR pi := p - p0;
> BEGIN
> IF desc[pi].space = Space.Current THEN
> IF map[pi] # NIL THEN
> (* check for cross file reference *)
> <* ASSERT self.db = map[pi].db *>
> ELSE
> (* page must be pinned by ambiguous root, make it persistent *)
> <* ASSERT desc[pi].note = Note.AmbiguousRoot *>
> VAR def := RTType.Get (oldHeader.typecode);
> BEGIN
> IF def.traced = 1 THEN
> WITH d = desc[pi] DO
> IF d.pure THEN
> d.link := pureCopy.stack;
> pureCopy.stack := p;
> ELSE
> d.link := impureCopy.stack;
> impureCopy.stack := p;
> END
> END;
> FOR i := 0 TO PageCount(p) - 1 DO
> VAR page := self.db.newPage();
> BEGIN
> map[pi + i] := page;
> page.p := p + i;
> page.lastReader := ThreadF.myTxn;
> page.writer := ThreadF.myTxn;
> WITH d = desc[pi + i] DO
> d.gray := TRUE;
> END;
> IF perfOn THEN PerfChange(p + i, 1); END;
> END
> END
> END
> END
> END;
> RETURN;
> END;
> <* ASSERT desc[pi].space = Space.Previous *>
> <* ASSERT map[pi] = NIL *>
> IF p + 1 < p1 AND desc[pi + 1].continued THEN
> (* if large, make persistent and promote to current space *)
> VAR def := RTType.Get (oldHeader.typecode);
> BEGIN
> IF def.traced = 1 THEN
> IF (def.gc_map = NIL) AND (def.parent = NIL) THEN
> PromotePage(
> p, Desc{space := Space.Current,
> generation := copyGeneration, pure := TRUE,
> note := Note.Large, gray := TRUE,
> access := Access.ReadWrite, continued := FALSE,
> resident := TRUE, dirty := FALSE});
> desc[pi].link := pureCopy.stack;
> pureCopy.stack := p;
> ELSE
> PromotePage(
> p, Desc{space := Space.Current,
> generation := copyGeneration, pure := FALSE,
> note := Note.Large, gray := TRUE,
> access := Access.ReadWrite, continued := FALSE,
> resident := TRUE, dirty := TRUE});
> desc[pi].link := impureCopy.stack;
> impureCopy.stack := p;
> END;
> FOR i := 0 TO PageCount(p) - 1 DO
> VAR page := self.db.newPage();
> BEGIN
> map[pi + i] := page;
> page.p := p + i;
> page.lastReader := ThreadF.myTxn;
> page.writer := ThreadF.myTxn;
> END
> END
> END
> END
> ELSIF oldHeader.forwarded THEN
> (* if already moved, just update the reference *)
> refref^ := LOOPHOLE(ref, UNTRACED REF RefReferent)^;
> ELSE
> (* move the object *)
> VAR
> def := RTType.Get(oldHeader.typecode);
> dataSize := ReferentSize(oldHeader);
> np : RefReferent;
> BEGIN
> IF def.traced # 1 THEN RETURN END;
> IF (def.gc_map = NIL) AND (def.parent = NIL) THEN
> np := AllocForCopy(dataSize, def.dataAlignment,
> pureCopy, pure := TRUE);
> ELSE
> np := AllocForCopy(dataSize, def.dataAlignment,
> impureCopy, pure := FALSE);
> END;
> RTMisc.Copy(oldHeader, HeaderOf(np), BYTESIZE(Header) + dataSize);
> IF def.nDimensions # 0 THEN
> (* open array: update the internal pointer *)
> LOOPHOLE(np, UNTRACED REF ADDRESS)^ := np + def.dataSize;
> END;
> oldHeader.forwarded := TRUE;
> LOOPHOLE(ref, UNTRACED REF RefReferent)^ := np;
> refref^ := np;
> END
> END
> END
> END
> END PMove;
>
513d856
< <* ASSERT desc[fp - p0].space = Space.Previous *>
516,518c859,864
< note := Note.AmbiguousRoot, gray :=
< FALSE, generation := copyGeneration,
< protected := FALSE, continued := FALSE});
---
> note := Note.AmbiguousRoot, gray := FALSE,
> generation := copyGeneration,
> access := desc[fp - p0].access,
> continued := FALSE,
> resident := desc[fp-p0].resident,
> dirty := FALSE});
519a866,868
> IF desc[fp - p0].access # Access.ReadWrite THEN
> Unprotect(fp);
> END;
521,525c870,877
< note := Note.AmbiguousRoot, gray :=
< TRUE, generation := copyGeneration,
< protected := FALSE, continued := FALSE});
< desc[fp - p0].link := impureCopyStack;
< impureCopyStack := fp;
---
> note := Note.AmbiguousRoot, gray := TRUE,
> generation := copyGeneration,
> access := Access.ReadWrite,
> continued := FALSE,
> resident := TRUE,
> dirty := TRUE});
> desc[fp - p0].link := impureTransientCopy.stack;
> impureTransientCopy.stack := fp;
572a925,979
> PROCEDURE Fill (VAR (*INOUT*) current: AllocRec) =
> BEGIN
> InsertFiller(current.ptr, current.boundary - current.ptr);
> current.page := Nil;
> current.stack := Nil;
> current.ptr := NIL;
> current.boundary := NIL;
> <* ASSERT current.db = NIL *>
> END Fill;
>
> PROCEDURE Close (VAR (*INOUT*) current: AllocRec; gray := FALSE) =
> VAR p := current.page;
> BEGIN
> InsertFiller(current.ptr, current.boundary - current.ptr);
> IF p # Nil THEN
> desc[p - p0].gray := gray;
> IF perfOn THEN PerfChange(p, 1); END;
> IF desc[p - p0].generation = Generation.Older AND NOT desc[p - p0].pure
> THEN
> <* ASSERT desc[p - p0].dirty *>
> <* ASSERT desc[p - p0].space = Space.Current *>
> <* ASSERT map[p - p0] = NIL OR map[p - p0].writer = ThreadF.myTxn *>
> desc[p - p0].dirty := FALSE;
> Protect(p, Access.ReadOnly);
> END;
> current.page := Nil;
> END;
> <* ASSERT current.stack = Nil *>
> current.ptr := NIL;
> current.boundary := NIL;
> END Close;
>
> PROCEDURE Push (VAR (*INOUT*) current: AllocRec; db: RTDB.T) =
> BEGIN
> IF current.db # db THEN
> IF current.page # Nil THEN
> InsertFiller(current.ptr, current.boundary - current.ptr);
> desc[current.page - p0].link := current.stack;
> current.stack := current.page;
> current.page := Nil;
> current.ptr := NIL;
> current.boundary := NIL;
> END;
> current.db := db;
> END;
> END Push;
>
> PROCEDURE SetDB (db: RTDB.T) =
> BEGIN
> pmover.db := db;
> Push(new, db);
> Push(pureCopy, db);
> Push(impureCopy, db);
> END SetDB;
>
599a1007,1617
> TYPE Unswizzler = RTHeapMap.Visitor OBJECT
> page: RTDB.Page;
> data: ADDRESS;
> OVERRIDES
> apply := Unswizzle
> END;
>
> PROCEDURE Unswizzle (self: Unswizzler; cp: ADDRESS) =
> VAR
> refref := LOOPHOLE(cp, UNTRACED REF RefReferent);
> ref := refref^;
> BEGIN
> IF ref = NIL THEN RETURN END;
> VAR
> p := Word.RightShift(LOOPHOLE(refref, INTEGER), LogBytesPerPage);
> pos := Word.And(LOOPHOLE(refref, INTEGER), BytesPerPage - 1);
> BEGIN
> IF p = self.page.p THEN
> LOOPHOLE(self.data + pos, UNTRACED REF RefReferent)^ :=
> UnswizzleRef(self.page.db, ref);
> END
> END;
> END Unswizzle;
>
> PROCEDURE UnswizzleRef (db: RTDB.T; ref: RefReferent): RefReferent =
> VAR p := ReferentToPage(ref);
> BEGIN
> IF p = Nil OR map[p - p0] = NIL THEN RETURN NIL END;
> VAR
> offset := ref - PageToAddress(p);
> targetDB := map[p - p0].db;
> nbPages := PageCount(p);
> page := map[p - p0];
> BEGIN
> <* ASSERT Word.And(offset, 3) = 0 *>
> <* ASSERT db = targetDB *>
> IF nbPages > 1 THEN
> CASE offset OF
> | 4 => offset := 2_0001;
> | 8 => offset := 2_0011;
> | 16 => offset := 2_0101;
> | 32 => offset := 2_0111;
> | 64 => offset := 2_1001;
> | 128 => offset := 2_1011;
> | 256 => offset := 2_1101;
> | 512 => offset := 2_1111;
> ELSE
> <* ASSERT FALSE *>
> END;
> IF nbPages >= Word.RightShift(BytesPerPage, 4) THEN
> nbPages := 0;
> ELSE
> nbPages := Word.LeftShift(nbPages, 4);
> END;
> INC(offset, nbPages);
> END;
> RETURN PageToAddress(page.id) + offset;
> END
> END UnswizzleRef;
>
> PROCEDURE UnswizzlePage(page: RTDB.Page; VAR data: RTHeapDep.PageData) =
> BEGIN
> ThreadF.SuspendOthers();
> VAR
> p := FirstPage(page.p);
> n := PageCount(p);
> d := ADR(data[0]);
> db := page.db;
> h := PageToHeader(p);
> he := PageToHeader(p+1);
> tc: Typecode;
> pos: INTEGER;
> referentSize: CARDINAL;
> def: TypeDefn;
> fpRef: REF Fingerprint.T;
> fpAdr: ADDRESS;
> BEGIN
> <* ASSERT desc[p - p0].space = Space.Current *>
> IF desc[p - p0].access = Access.None THEN
> <* ASSERT desc[p - p0].gray *>
> Unprotect(p);
> END;
> data := PageToData(page.p)^;
>
> unswizzler.page := page;
> unswizzler.data := d;
> IF n = 1 THEN
> WHILE h < he DO
> <* ASSERT NOT h.forwarded *>
> p := Word.RightShift(LOOPHOLE(h, INTEGER), LogBytesPerPage);
> pos := Word.And(LOOPHOLE(h, INTEGER), BytesPerPage - 1);
> tc := h.typecode;
> IF tc = Fill_1_type THEN
> LOOPHOLE(d + pos, UNTRACED REF ADDRESS)^ := LOOPHOLE(0, ADDRESS);
> referentSize := 0;
> ELSIF tc = Fill_N_type THEN
> LOOPHOLE(d + pos, UNTRACED REF ADDRESS)^ := LOOPHOLE(1, ADDRESS);
> referentSize := LOOPHOLE(h + ADRSIZE(Header), UNTRACED REF INTEGER)^;
> DEC(referentSize, ADRSIZE(Header));
> ELSE
> def := RTType.Get(tc);
> <* ASSERT def.traced = 1 *>
> fpRef := NIL;
> fpAdr := NIL;
> db.mapFP(LOOPHOLE(def.fp, Fingerprint.T), fpRef, fpAdr);
> IF fpAdr = NIL THEN
> <* ASSERT fpRef # NIL *>
> fpAdr := UnswizzleRef(db, LOOPHOLE(fpRef, RefReferent));
> db.mapFP(LOOPHOLE(def.fp, Fingerprint.T), fpRef, fpAdr);
> END;
> LOOPHOLE(d + pos, UNTRACED REF ADDRESS)^ := fpAdr;
> IF def.nDimensions = 0 THEN
> referentSize := def.dataSize;
> ELSE
> referentSize := OpenArraySize(h, def);
> END;
> IF stats.print AND desc[p - p0].note # Note.Persistent THEN
> WITH z = stats.objects[tc] DO z := Word.Plus(z, 1); END;
> WITH z = stats.bytes[tc] DO
> z := Word.Plus(z, BYTESIZE(Header) + referentSize)
> END;
> END;
> IF def.gc_map # NIL OR def.parent # NIL THEN
> RTHeapMap.DoWalkRef(def, h + ADRSIZE(Header), unswizzler);
> END
> END;
> INC(h, ADRSIZE(Header) + referentSize);
> END
> ELSE
> WHILE h < he DO
> <* ASSERT NOT h.forwarded *>
> p := Word.RightShift(LOOPHOLE(h, INTEGER), LogBytesPerPage);
> pos := Word.And(LOOPHOLE(h, INTEGER), BytesPerPage - 1);
> tc := h.typecode;
> IF tc = Fill_1_type THEN
> IF p = page.p THEN
> LOOPHOLE(d + pos, UNTRACED REF ADDRESS)^ := LOOPHOLE(0, ADDRESS);
> END;
> referentSize := 0;
> ELSIF tc = Fill_N_type THEN
> IF p = page.p THEN
> LOOPHOLE(d + pos, UNTRACED REF ADDRESS)^ := LOOPHOLE(1, ADDRESS);
> END;
> referentSize :=
> LOOPHOLE(h + ADRSIZE(Header), UNTRACED REF INTEGER)^;
> DEC(referentSize, ADRSIZE(Header));
> ELSE
> def := RTType.Get(tc);
> <* ASSERT def.traced = 1 *>
> IF p = page.p THEN
> fpRef := NIL;
> fpAdr := NIL;
> db.mapFP(LOOPHOLE(def.fp, Fingerprint.T), fpRef, fpAdr);
> IF fpAdr = NIL THEN
> <* ASSERT fpRef # NIL *>
> fpAdr := UnswizzleRef(db, LOOPHOLE(fpRef, RefReferent));
> db.mapFP(LOOPHOLE(def.fp, Fingerprint.T), fpRef, fpAdr);
> END;
> LOOPHOLE(d + pos, UNTRACED REF ADDRESS)^ := fpAdr;
> END;
> IF def.nDimensions = 0 THEN
> referentSize := def.dataSize;
> ELSE
> referentSize := OpenArraySize(h, def);
> END;
> IF stats.print AND desc[p - p0].note # Note.Persistent THEN
> WITH z = stats.objects[tc] DO z := Word.Plus(z, 1); END;
> WITH z = stats.bytes[tc] DO
> z := Word.Plus(z, BYTESIZE(Header) + referentSize)
> END
> END;
> IF def.gc_map # NIL OR def.parent # NIL THEN
> RTHeapMap.DoWalkRef(def, h + ADRSIZE(Header), unswizzler);
> END
> END;
> INC(h, ADRSIZE(Header) + referentSize);
> END
> END;
>
> p := FirstPage(page.p);
> IF desc[p - p0].gray THEN
> Protect(p, Access.None);
> END
> END;
> ThreadF.ResumeOthers();
> END UnswizzlePage;
>
> PROCEDURE Stabilize (bootstrapDB: RTDB.T) =
> BEGIN
> (* compute some costs relative to previous collection *)
> INC(cycleNews, smallNewPages + largeNewPages);
> VAR prefixAvgCost := cycleCost / FLOAT(cycleNews);
> BEGIN
> IF prefixAvgCost < minPrefixAvgCost THEN
> minPrefixAvgCost := prefixAvgCost;
> minCycleL := cycleL;
> END;
> END;
>
> (* we want to do full collection *)
> copyGeneration := Generation.Younger;
> partialCollection := FALSE;
> partialCollectionNext := TRUE;
>
> (* not partial collection *)
> cycleL := 1;
> cycleCost := 0.0;
> cycleNews := 0;
> minPrefixAvgCost := LAST(REAL);
> minCycleL := 0;
>
> InvokeMonitors (before := TRUE);
>
> IF perfOn THEN PerfBegin(); END;
>
> (* fill the rest of the current page *)
> Fill(new);
> Fill(newTransient);
>
> INC(collections);
>
> (* flip spaces; newspace becomes oldspace *)
> FOR p := p0 TO p1 - 1 DO
> IF desc[p - p0].space = Space.Current THEN
> desc[p - p0].space := Space.Previous;
> IF perfOn THEN PerfChange(p, 1); END;
> END;
> END;
>
> IF perfOn THEN PerfFlip(); END;
>
> (* The 'new' nextSpace is empty *)
> smallNewPages := 0;
> largeNewPages := 0;
> smallCopyPages := 0;
> largeCopyPages := 0;
> smallPromotionPages := 0;
> largePromotionPages := 0;
>
> FOR p := p0 TO p1 - 1 DO
> VAR d := desc[p - p0];
> BEGIN
> IF d.space = Space.Previous AND NOT d.continued THEN
> IF map[p - p0] # NIL THEN
> (* Promote ALL persistent pages: stabilize may trigger faults
> when accessing meta-data, which may swizzle references to
> previously unreachable pages, so we need to make sure these
> pages are retained. Also, updates to persistent pages during
> closure copying need to be captured when unswizzling. *)
> IF d.resident AND map[p - p0].writer # NIL THEN
> IF d.access # Access.ReadWrite THEN Unprotect(p) END;
> IF d.pure THEN
> PromotePage(
> p, Desc{space := Space.Current,
> generation := copyGeneration,
> pure := TRUE, note := Note.Persistent,
> gray := TRUE, access := Access.ReadWrite,
> continued := FALSE, resident := TRUE,
> dirty := FALSE});
> desc[p - p0].link := pureCopy.stack;
> pureCopy.stack := p;
> ELSE
> PromotePage(
> p, Desc{space := Space.Current,
> generation := copyGeneration,
> pure := FALSE, note := Note.Persistent,
> gray := TRUE, access := Access.ReadWrite,
> continued := FALSE, resident := TRUE,
> dirty := TRUE});
> desc[p - p0].link := impureCopy.stack;
> impureCopy.stack := p;
> END
> ELSE
> <* ASSERT d.access # Access.ReadWrite *>
> PromotePage(
> p, Desc{space := Space.Current, generation := copyGeneration,
> pure := d.pure, note := Note.Persistent,
> gray := NOT d.pure, access := d.access,
> continued := FALSE, resident := d.resident,
> dirty := FALSE});
> END
> ELSE
> (* non-persistent page *)
> <* ASSERT d.access # Access.None *>
> IF d.generation = Generation.Older THEN
> IF d.access # Access.ReadWrite THEN Unprotect(p) END;
> ELSE
> <* ASSERT d.access = Access.ReadWrite *>
> END
> END
> END
> END
> END;
>
> (* get these in the new space *)
> mover := NEW (Mover);
> unswizzler := NEW (Unswizzler);
> tmover := NEW (TMover);
> pmover := NEW (PMover);
>
> (* mark from roots *)
> ThreadF.SuspendOthers();
> BEGIN
> (* Examine the stacks for possible pointers *)
> ThreadF.ProcessStacks(NoteStackLocations);
>
> <* ASSERT impureTransientCopy.page = Nil *>
> <* ASSERT impureTransientCopy.ptr = NIL *>
> <* ASSERT impureTransientCopy.boundary = NIL *>
>
> <* ASSERT pureTransientCopy.page = Nil *>
> <* ASSERT pureTransientCopy.stack = Nil *>
> <* ASSERT pureTransientCopy.ptr = NIL *>
> <* ASSERT pureTransientCopy.boundary = NIL *>
>
> <* ASSERT impureCopy.page = Nil *>
> <* ASSERT impureCopy.ptr = NIL *>
> <* ASSERT impureCopy.boundary = NIL *>
>
> <* ASSERT pureCopy.page = Nil *>
> <* ASSERT pureCopy.ptr = NIL *>
> <* ASSERT pureCopy.boundary = NIL *>
>
> (* fill current page in preparation for persistent allocations *)
> Fill(new);
>
> (* Create root if this is a new database *)
> IF bootstrapDB # NIL THEN
> SetDB(bootstrapDB);
> bootstrapDB.createRoot();
> WITH ref = LOOPHOLE(bootstrapDB.root, RefReferent) DO
> bootstrapDB.newId(map[ReferentToPage(ref) - p0]);
> END;
> SetDB(NIL);
> END;
>
> (* Copy transient closure from globals and user-level page handles,
> since we may need them to access the database when unswizzling *)
> RTHeapMap.WalkGlobals(tmover);
> FOR p := p0 TO p1 - 1 DO
> WITH m = map[p - p0] DO
> IF m # NIL THEN
> TMove (NIL, ADR(m));
> END
> END
> END;
> WHILE CleanSome(impureTransientCopy, CleanTransient, gray:= TRUE) DO END;
> Close(impureTransientCopy, gray := TRUE);
> tmover := NIL;
>
> (* Copy persistence closure *)
> WHILE CleanSome(impureCopy, CleanPersistent, gray := TRUE) DO END;
> Close(impureCopy, gray := TRUE);
>
> (* now allocate metadata for pure pages *)
> WHILE CleanSome(pureCopy, CleanPersistent) DO END;
> Close(pureCopy);
>
> (* now the metadata itself *)
> WHILE CleanSome(new, CleanPersistent) DO END;
> Close(new);
>
> <* ASSERT impureTransientCopy.stack = Nil *>
> <* ASSERT impureTransientCopy.page = Nil *>
> <* ASSERT impureTransientCopy.ptr = NIL *>
> <* ASSERT impureTransientCopy.boundary = NIL *>
>
> <* ASSERT impureCopy.stack = Nil *>
> <* ASSERT impureCopy.page = Nil *>
> <* ASSERT impureCopy.ptr = NIL *>
> <* ASSERT impureCopy.boundary = NIL *>
>
> <* ASSERT pureCopy.page = Nil *>
> <* ASSERT pureCopy.stack = Nil *>
> <* ASSERT pureCopy.ptr = NIL *>
> <* ASSERT pureCopy.boundary = NIL *>
>
> SetDB(NIL);
> pmover := NIL;
>
> (* All modified persistent pages are in Space.Current *)
> FOR i := 0 TO p1 - p0 - 1 DO
> VAR d := desc[i];
> BEGIN
> IF d.space = Space.Current AND NOT d.continued THEN
> IF d.resident THEN
> IF map[i] # NIL THEN
> IF map[i].writer = ThreadF.myTxn THEN
> <* ASSERT d.access = Access.ReadWrite *>
> VAR p := p0 + i;
> BEGIN
> IF d.note = Note.AmbiguousRoot AND stats.print THEN
> INC(stats.ambiguousPages, PageCount(p));
> ELSIF d.note # Note.Persistent AND stats.print THEN
> INC(stats.accuratePages, PageCount(p));
> END;
> END
> END;
> IF d.gray THEN
> <* ASSERT d.resident AND NOT d.pure *>
> d.link := impureCopy.stack;
> desc[i] := d;
> impureCopy.stack := p0 + i;
> ELSIF ThreadF.myTxn # NIL AND map[i] # NIL THEN
> IF map[i].lastReader = ThreadF.myTxn THEN
> Protect(p0 + i, Access.ReadOnly);
> ELSIF map[i].writer # ThreadF.myTxn THEN
> Protect(p0 + i, Access.None);
> END
> END
> ELSIF d.gray THEN
> <* ASSERT d.resident AND NOT d.pure *>
> d.link := impureTransientCopy.stack;
> desc[i] := d;
> impureTransientCopy.stack := p0 + i;
> END
> ELSE
> <* ASSERT d.pure AND d.access = Access.None *>
> END
> END
> END
> END;
>
> IF stats.print THEN
> PutText("\nAccurate pages: "); PutInt(stats.accuratePages);
> PutText("\nAmbiguous pages: "); PutInt(stats.ambiguousPages);
> PutText("\n");
> stats.accuratePages := 0; stats.ambiguousPages := 0;
> FOR i := 0 TO RT0u.nTypes - 1 DO
> IF stats.objects[i] # 0 THEN
> VAR t := RTType.Get(i);
> str: ADDRESS := t.name;
> BEGIN
> IF str # NIL THEN
> PutChars(str, Cstring.strlen(str));
> ELSE
> PutText("");
> END;
> END;
> PutText(": ");
> PutInt(stats.objects[i]); PutText(" objects ");
> PutInt(stats.bytes[i]); PutText(" bytes\n");
> stats.objects[i] := 0;
> stats.bytes[i] := 0;
> END
> END;
> RTIO.Flush();
> END;
>
> WHILE CleanSome(impureTransientCopy) DO END;
> Close(impureTransientCopy);
>
> (* Examine the global variables for possible pointers *)
> RTHeapMap.WalkGlobals (mover);
> END;
> ThreadF.ResumeOthers();
>
> IF perfOn THEN PerfPromotedRoots(); END;
>
> collectorState := CollectorState.One;
> IF backgroundWaiting THEN signalBackground := TRUE END;
> END Stabilize;
>
> PROCEDURE Transfer(from: RTTxn.T; to: RTTxn.T) =
> BEGIN
> <* ASSERT to # NIL *>
> <* ASSERT from # to *>
> FOR i := 0 TO p1 - p0 - 1 DO
> VAR d := desc[i];
> BEGIN
> IF NOT d.continued THEN
> IF d.space = Space.Current OR d.space = Space.Previous THEN
> IF d.resident THEN
> IF map[i] # NIL THEN
> IF d.gray THEN
> <* ASSERT d.access = Access.None *>
> ELSIF map[i].writer = to THEN
> IF d.generation = Generation.Older THEN
> <* ASSERT d.space = Space.Current *>
> IF (d.dirty OR d.pure) AND d.access # Access.ReadWrite
> THEN
> Unprotect(p0 + i);
> ELSIF d.access = Access.None THEN
> Protect(p0 + i, Access.ReadOnly);
> END
> ELSIF d.access # Access.ReadWrite THEN
> Unprotect(p0 + i);
> END
> ELSIF d.access = Access.None AND map[i].lastReader = to THEN
> Protect(p0 + i, Access.ReadOnly);
> ELSIF d.access # Access.None THEN
> Protect(p0 + i, Access.None);
> END
> END
> ELSE
> <* ASSERT d.pure AND d.access = Access.None AND NOT d.gray *>
> END
> END
> END
> END
> END
> END Transfer;
>
> PROCEDURE Abort() =
> BEGIN
> FOR p := p0 TO p1 - 1 DO
> VAR
> pi := p - p0;
> d := desc[pi];
> BEGIN
> IF NOT d.continued THEN
> IF d.space = Space.Current OR d.space = Space.Previous THEN
> IF d.resident THEN
> IF map[pi] # NIL THEN
> IF map[pi].writer = ThreadF.myTxn THEN
> d.dirty := FALSE;
> d.resident := FALSE;
> d.gray := FALSE;
> d.pure := TRUE;
> desc[pi] := d;
> d.continued := TRUE;
> FOR i := 1 TO PageCount(p) - 1 DO
> desc[pi + i] := d;
> END;
> Protect(p, Access.None);
> ELSIF map[pi].lastReader = ThreadF.myTxn THEN
> Protect(p, Access.None);
> END
> END
> ELSE
> <* ASSERT d.pure AND d.access = Access.None AND NOT d.gray *>
> END
> END
> END
> END
> END
> END Abort;
>
> PROCEDURE Flush (db: RTDB.T)
> RAISES { Disabled, Thread.Aborted } =
> VAR page: RTDB.Page;
> BEGIN
> RTOS.LockHeap();
> IF disableCount + disableMotionCount > 0 THEN
> RTOS.UnlockHeap();
> RAISE Disabled;
> END;
> BEGIN
> CollectorOn();
> WHILE collectorState # CollectorState.Zero DO CollectSome(); END;
> Stabilize(db);
> IF NOT (incremental AND RTHeapDep.VM AND disableVMCount = 0) THEN
> REPEAT CollectSome(); UNTIL collectorState = CollectorState.Zero;
> END;
> CollectorOff();
> END;
> RTOS.UnlockHeap();
> DisableMotion();
> (* First pass to assign IDs *)
> FOR p := p0 TO p1 - 1 DO (* race here is OK *)
> RTOS.LockHeap();
> page := map[p - p0];
> RTOS.UnlockHeap();
> IF page # NIL AND page.id = Nil THEN page.db.newId(page); END
> END;
> (* Second pass to unswizzle *)
> FOR p := p0 TO p1 - 1 DO (* race here is OK *)
> RTOS.LockHeap();
> VAR
> d := desc[p - p0];
> BEGIN
> IF NOT d.continued THEN
> IF d.resident THEN
> page := map[p - p0];
> IF page # NIL AND page.writer = ThreadF.myTxn THEN
> TRY
> RTOS.UnlockHeap();
> Thread.Acquire(page);
> page.write(UnswizzlePage);
> FINALLY
> Thread.Release(page);
> RTOS.LockHeap();
> END;
> FOR i := 1 TO PageCount(p) - 1 DO
> page := map[p - p0 + i];
> TRY
> RTOS.UnlockHeap();
> Thread.Acquire(page);
> page.write(UnswizzlePage);
> FINALLY
> Thread.Release(page);
> RTOS.LockHeap();
> END
> END;
> FOR i := 0 TO PageCount(p) - 1 DO
> page := map[p - p0 + i];
> <* ASSERT page.writer = ThreadF.myTxn *>
> page.writer := NIL;
> END;
> IF NOT desc[p - p0].gray THEN
> Protect(p, Access.ReadOnly);
> END
> END
> END
> END
> END;
> RTOS.UnlockHeap();
> END;
> EnableMotion();
> END Flush;
>
646,649c1664,1672
< IF impureCopyPage # Nil THEN
< <* ASSERT desc[impureCopyPage - p0].gray *>
< <* ASSERT desc[impureCopyPage - p0].protected *>
< Unprotect(impureCopyPage);
---
> IF impureCopy.page # Nil THEN
> <* ASSERT desc[impureCopy.page - p0].gray *>
> <* ASSERT desc[impureCopy.page - p0].access = Access.None *>
> Unprotect(impureCopy.page);
> END;
> IF impureTransientCopy.page # Nil THEN
> <* ASSERT desc[impureTransientCopy.page - p0].gray *>
> <* ASSERT desc[impureTransientCopy.page - p0].access = Access.None *>
> Unprotect(impureTransientCopy.page);
657,660c1680,1692
< IF impureCopyPage # Nil THEN
< <* ASSERT desc[impureCopyPage - p0].gray *>
< <* ASSERT NOT desc[impureCopyPage - p0].protected *>
< Protect(impureCopyPage, readable := FALSE, writable := FALSE);
---
> IF impureCopy.page # Nil THEN
> <* ASSERT desc[impureCopy.page - p0].gray *>
> <* ASSERT desc[impureCopy.page - p0].access = Access.ReadWrite *>
> Protect(impureCopy.page, Access.None);
> END;
> VAR p := impureCopy.stack;
> BEGIN
> WHILE p # Nil DO
> IF desc[p - p0].gray AND desc[p - p0].access # Access.None THEN
> Protect(p, Access.None);
> END;
> p := desc[p - p0].link;
> END;
662c1694,1699
< VAR p := impureCopyStack;
---
> IF impureTransientCopy.page # Nil THEN
> <*ASSERT desc[impureTransientCopy.page - p0].gray *>
> <*ASSERT desc[impureTransientCopy.page - p0].access = Access.ReadWrite *>
> Protect(impureTransientCopy.page, Access.None);
> END;
> VAR p := impureTransientCopy.stack;
665,666c1702,1703
< IF desc[p - p0].gray AND NOT desc[p - p0].protected THEN
< Protect(p, readable := FALSE, writable := FALSE);
---
> IF desc[p - p0].gray AND desc[p - p0].access # Access.None THEN
> Protect(p, Access.None);
705a1743,1745
> tmover : TMover := NIL;
> pmover : PMover := NIL;
> unswizzler : Unswizzler := NIL;
759,763c1799,1800
< InsertFiller(newPtr, newBoundary - newPtr);
< newPage := Nil;
< newStack := Nil;
< newPtr := NIL;
< newBoundary := NIL;
---
> Fill(new);
> Fill(newTransient);
786,798c1823,1831
< IF desc[p - p0].space = Space.Previous
< AND NOT desc[p - p0].continued THEN
< IF desc[p - p0].generation = Generation.Older THEN
< IF partialCollection THEN
< <* ASSERT copyGeneration = Generation.Older *>
< IF desc[p - p0].protected THEN
< <* ASSERT NOT desc[p - p0].pure *>
< PromotePage(p, Desc{space := Space.Current, generation :=
< copyGeneration, pure := FALSE, note :=
< Note.OlderGeneration, gray := FALSE,
< protected := TRUE, continued := FALSE});
< ELSE
< IF desc[p - p0].pure THEN
---
> VAR d := desc[p - p0];
> BEGIN
> IF d.space = Space.Previous AND NOT d.continued THEN
> IF map[p - p0] # NIL THEN
> (* persistent page *)
> IF d.resident AND map[p - p0].writer # NIL THEN
> (* promote modified persistent pages to avoid deleting them *)
> IF d.pure OR partialCollection AND NOT d.dirty THEN
> <* ASSERT NOT d.dirty *>
800,804c1833,1839
< p, Desc{space := Space.Current, generation :=
< copyGeneration, pure := TRUE, note :=
< Note.OlderGeneration, gray := FALSE, protected :=
< FALSE, continued := FALSE});
< ELSE
---
> p, Desc{space := Space.Current,
> generation := copyGeneration, pure := d.pure,
> note := Note.Persistent, gray := FALSE,
> access := d.access, continued := FALSE,
> resident := TRUE, dirty := FALSE});
> ELSE (* impure, neither partial collection nor clean *)
> IF d.access # Access.ReadWrite THEN Unprotect(p) END;
806,813c1841,1880
< p, Desc{space := Space.Current, generation :=
< copyGeneration, pure := FALSE, note :=
< Note.OlderGeneration, gray := TRUE, protected :=
< FALSE, continued := FALSE});
< desc[p - p0].link := impureCopyStack;
< impureCopyStack := p;
< END;
< END;
---
> p, Desc{space := Space.Current,
> generation := copyGeneration, pure := FALSE,
> note := Note.Persistent, gray := TRUE,
> access := Access.ReadWrite, continued := FALSE,
> resident := TRUE, dirty := TRUE});
> desc[p - p0].link := impureCopy.stack;
> impureCopy.stack := p;
> END
> ELSIF d.generation = Generation.Older THEN
> IF partialCollection THEN
> <* ASSERT copyGeneration = Generation.Older *>
> IF d.pure THEN
> PromotePage(
> p, Desc{space := Space.Current,
> generation := copyGeneration, pure := TRUE,
> note := Note.OlderGeneration, gray := FALSE,
> access := d.access, continued := FALSE,
> resident := d.resident, dirty := FALSE});
> ELSIF d.dirty THEN
> <* ASSERT d.resident *>
> IF d.access # Access.ReadWrite THEN Unprotect(p) END;
> PromotePage(
> p, Desc{space := Space.Current,
> generation := copyGeneration, pure := FALSE,
> note := Note.OlderGeneration, gray := TRUE,
> access := Access.ReadWrite, continued := FALSE,
> resident := TRUE, dirty := TRUE});
> desc[p - p0].link := impureCopy.stack;
> impureCopy.stack := p;
> ELSE
> <* ASSERT d.access # Access.ReadWrite *>
> PromotePage(
> p, Desc{space := Space.Current,
> generation := copyGeneration, pure := FALSE,
> note := Note.OlderGeneration, gray := FALSE,
> access := d.access, continued := FALSE,
> resident := d.resident, dirty := FALSE});
> END
> END
> END
815,820c1882,1924
< IF desc[p - p0].protected THEN Unprotect(p); END;
< END;
< ELSE
< <* ASSERT NOT desc[p - p0].protected *>
< END;
< END;
---
> (* non-persistent page *)
> IF d.generation = Generation.Older THEN
> IF partialCollection THEN
> <* ASSERT copyGeneration = Generation.Older *>
> IF d.pure THEN
> <* ASSERT d.access = Access.ReadWrite *>
> PromotePage(
> p, Desc{space := Space.Current,
> generation := copyGeneration,
> pure := TRUE, note := Note.OlderGeneration,
> gray := FALSE, access := Access.ReadWrite,
> continued := FALSE, resident := TRUE,
> dirty := FALSE});
> ELSIF d.dirty THEN
> <* ASSERT d.access = Access.ReadWrite *>
> PromotePage(
> p, Desc{space := Space.Current,
> generation := copyGeneration,
> pure := FALSE, note := Note.OlderGeneration,
> gray := TRUE, access := Access.ReadWrite,
> continued := FALSE, resident := TRUE,
> dirty := TRUE});
> desc[p - p0].link := impureCopy.stack;
> impureCopy.stack := p;
> ELSE
> <* ASSERT d.access = Access.ReadOnly *>
> PromotePage(
> p, Desc{space := Space.Current,
> generation := copyGeneration,
> pure := FALSE, note := Note.OlderGeneration,
> gray := FALSE, access := Access.ReadOnly,
> continued := FALSE, resident := TRUE,
> dirty := FALSE});
> END
> ELSE
> IF d.access # Access.ReadWrite THEN Unprotect(p) END;
> END
> ELSE
> <* ASSERT d.access = Access.ReadWrite *>
> END
> END
> END
> END
825c1929,1931
< mover := NEW (Mover); (* get one in the new space *)
---
> (* get these in the new space *)
> mover := NEW (Mover);
> tmover := NEW(TMover);
832a1939,1950
> (* Copy closure from user-level page handles,
> since we need page information during GC, but drop roots *)
> FOR p := p0 TO p1 - 1 DO
> WITH m = map[p - p0] DO
> IF m # NIL THEN
> m.db.root := NIL;
> Move (NIL, ADR(m));
> END
> END
> END;
> WHILE CopySome() DO END;
>
870a1989,2015
> (* That's the last chance for unmodified persistent pages since
> they may contain WRNNC objects that are about to get finalized.
> Thus, we now unmap them so swizzling can't resurrect them. *)
> ThreadF.SuspendOthers();
> BEGIN
> FOR i := 0 TO p1 - p0 - 1 DO
> VAR
> d := desc[i];
> page := map[i];
> BEGIN
> IF d.space = Space.Previous AND page # NIL THEN
> IF NOT d.continued THEN
> <* ASSERT d.access # Access.ReadWrite *>
> <* ASSERT NOT d.resident OR map[i].writer = NIL *>
> Unprotect(p0 + i);
> END;
> (* unmap pages *)
> page.db.unmapPage(page.id);
> page.p := Nil;
> map[i] := NIL;
> IF perfOn THEN PerfChange(p0 + i, 1); END;
> END
> END
> END
> END;
> ThreadF.ResumeOthers();
>
893c2038
< <* ASSERT NOT desc[i].protected *>
---
> <* ASSERT desc[i].access = Access.ReadWrite *>
901,918c2046,2049
< InsertFiller(pureCopyPtr, pureCopyBoundary - pureCopyPtr);
< InsertFiller(impureCopyPtr, impureCopyBoundary - impureCopyPtr);
< IF impureCopyPage # Nil THEN
< desc[impureCopyPage - p0].gray := FALSE;
< IF perfOn THEN PerfChange(impureCopyPage, 1); END;
< IF desc[impureCopyPage - p0].generation = Generation.Older THEN
< <* ASSERT desc[impureCopyPage - p0].space = Space.Current *>
< Protect(impureCopyPage, readable := TRUE, writable := FALSE);
< END;
< impureCopyPage := Nil;
< END;
< <* ASSERT impureCopyStack = Nil *>
< pureCopyPage := Nil;
< pureCopyStack := Nil;
< impureCopyPtr := NIL;
< impureCopyBoundary := NIL;
< pureCopyPtr := NIL;
< pureCopyBoundary := NIL;
---
> Close(impureCopy);
> Close(impureTransientCopy);
> Fill(pureCopy);
> Fill(pureTransientCopy);
949c2080,2263
< PROCEDURE CopySome (): BOOLEAN =
---
> PROCEDURE CopySome (): BOOLEAN =
> VAR
> originalPage := impureCopy.page;
> originalBoundary := impureCopy.boundary;
> cleanTo := PageToHeader(impureCopy.page);
> originalTransientPage := impureTransientCopy.page;
> originalTransientBoundary := impureTransientCopy.boundary;
> cleanTransientTo := PageToHeader(impureTransientCopy.page);
> p: Page;
> BEGIN
> LOOP
> IF cleanTo < impureCopy.ptr THEN
> VAR ptr := impureCopy.ptr;
> BEGIN
> CleanBetween(cleanTo, ptr);
> cleanTo := ptr;
> END;
> ELSIF cleanTransientTo < impureTransientCopy.ptr THEN
> VAR ptr := impureTransientCopy.ptr;
> BEGIN
> CleanBetween(cleanTransientTo, ptr);
> cleanTransientTo := ptr;
> END;
> ELSE
> IF impureCopy.stack = Nil AND impureTransientCopy.stack = Nil THEN
> RETURN FALSE;
> END;
>
> p := impureCopy.stack;
> IF p # Nil THEN
> impureCopy.stack := desc[p - p0].link;
> IF desc[p - p0].gray THEN
> <* ASSERT desc[p - p0].resident *>
> IF desc[p - p0].access # Access.ReadWrite THEN Unprotect(p); END;
> CleanBetween(PageToHeader(p), PageToHeader(p + 1));
> FOR i := 0 TO PageCount(p) - 1 DO
> desc[p + i - p0].gray := FALSE;
> desc[p + i - p0].dirty := FALSE;
> END;
> IF perfOn THEN PerfChange(p, PageCount(p)) END;
> IF ThreadF.myTxn = NIL
> OR map[p - p0] = NIL
> OR map[p - p0].writer = ThreadF.myTxn
> THEN
> IF desc[p - p0].generation = Generation.Older THEN
> <* ASSERT desc[p - p0].space = Space.Current *>
> Protect(p, Access.ReadOnly);
> END
> ELSIF map[p - p0].lastReader = ThreadF.myTxn THEN
> Protect(p, Access.ReadOnly);
> ELSE
> Protect(p, Access.None);
> END;
> END;
> END;
>
> p := impureTransientCopy.stack;
> IF p # Nil THEN
> impureTransientCopy.stack := desc[p - p0].link;
> IF desc[p - p0].gray THEN
> <* ASSERT desc[p - p0].resident *>
> IF desc[p - p0].access # Access.ReadWrite THEN Unprotect(p); END;
> CleanBetween(PageToHeader(p), PageToHeader(p + 1));
> FOR i := 0 TO PageCount(p) - 1 DO
> desc[p + i - p0].gray := FALSE;
> desc[p + i - p0].dirty := FALSE;
> END;
> IF perfOn THEN PerfChange(p, PageCount(p)) END;
> IF ThreadF.myTxn = NIL
> OR map[p - p0] = NIL
> OR map[p - p0].writer = ThreadF.myTxn
> THEN
> IF desc[p - p0].generation = Generation.Older THEN
> <* ASSERT desc[p - p0].space = Space.Current *>
> Protect(p, Access.ReadOnly);
> END
> ELSIF map[p - p0].lastReader = ThreadF.myTxn THEN
> Protect(p, Access.ReadOnly);
> ELSE
> Protect(p, Access.None);
> END
> END
> END;
>
> END;
> IF impureCopy.page # originalPage
> OR impureTransientCopy.page # originalTransientPage THEN EXIT; END;
> END;
>
> p := originalPage;
> IF p # Nil AND p # impureCopy.page AND desc[p - p0].gray THEN
> (* originalPage is now in the stack; mark it not gray *)
> CleanBetween(cleanTo, originalBoundary);
> desc[p - p0].gray := FALSE;
> desc[p - p0].dirty := FALSE;
> IF perfOn THEN PerfChange(p, 1) END;
> IF ThreadF.myTxn = NIL
> OR map[p - p0] = NIL
> OR map[p - p0].writer = ThreadF.myTxn
> THEN
> IF desc[p - p0].generation = Generation.Older THEN
> <* ASSERT desc[p - p0].space = Space.Current *>
> Protect(p, Access.ReadOnly);
> END
> ELSIF map[p - p0].lastReader = ThreadF.myTxn THEN
> Protect(p, Access.ReadOnly);
> ELSE
> Protect(p, Access.None);
> END;
>
> p := originalTransientPage;
> IF p # Nil AND p # impureTransientCopy.page AND desc[p - p0].gray THEN
> (* originalTransientPage is now in the stack; mark it not gray *)
> CleanBetween(cleanTransientTo, originalTransientBoundary);
> desc[p - p0].gray := FALSE;
> desc[p - p0].dirty := FALSE;
> IF perfOn THEN PerfChange(p, 1) END;
> IF ThreadF.myTxn = NIL
> OR map[p - p0] = NIL
> OR map[p - p0].writer = ThreadF.myTxn
> THEN
> IF desc[p - p0].generation = Generation.Older THEN
> <* ASSERT desc[p - p0].space = Space.Current *>
> Protect(p, Access.ReadOnly);
> END
> ELSIF map[p - p0].lastReader = ThreadF.myTxn THEN
> Protect(p, Access.ReadOnly);
> ELSE
> Protect(p, Access.None);
> END
> END;
> RETURN TRUE;
> END;
>
> p := originalTransientPage;
> IF p # Nil AND p # impureTransientCopy.page AND desc[p - p0].gray THEN
> (* originalTransientPage is now in the stack; mark it not gray *)
> CleanBetween(cleanTransientTo, originalTransientBoundary);
> desc[p - p0].gray := FALSE;
> desc[p - p0].dirty := FALSE;
> IF perfOn THEN PerfChange(p, 1) END;
> IF ThreadF.myTxn = NIL
> OR map[p - p0] = NIL
> OR map[p - p0].writer = ThreadF.myTxn
> THEN
> IF desc[p - p0].generation = Generation.Older THEN
> <* ASSERT desc[p - p0].space = Space.Current *>
> Protect(p, Access.ReadOnly);
> END
> ELSIF map[p - p0].lastReader = ThreadF.myTxn THEN
> Protect(p, Access.ReadOnly);
> ELSE
> Protect(p, Access.None);
> END;
>
> p := originalPage;
> IF p # Nil AND p # impureCopy.page AND desc[p - p0].gray THEN
> (* originalPage is now in the stack; mark it not gray *)
> CleanBetween(cleanTo, originalBoundary);
> desc[p - p0].gray := FALSE;
> desc[p - p0].dirty := FALSE;
> IF perfOn THEN PerfChange(p, 1) END;
> IF ThreadF.myTxn = NIL
> OR map[p - p0] = NIL
> OR map[p - p0].writer = ThreadF.myTxn
> THEN
> IF desc[p - p0].generation = Generation.Older THEN
> <* ASSERT desc[p - p0].space = Space.Current *>
> Protect(p, Access.ReadOnly);
> END
> ELSIF map[p - p0].lastReader = ThreadF.myTxn THEN
> Protect(p, Access.ReadOnly);
> ELSE
> Protect(p, Access.None);
> END
> END;
> RETURN TRUE;
> END;
>
> RETURN TRUE;
> END CopySome;
>
> PROCEDURE CleanSome (VAR current: AllocRec; cleaner := CleanBetween;
> gray := FALSE): BOOLEAN =
951,953c2265,2268
< originalImpureCopyPage := impureCopyPage;
< originalBoundary := impureCopyBoundary;
< cleanTo := PageToHeader(impureCopyPage);
---
> originalPage := current.page;
> originalBoundary := current.boundary;
> cleanTo := PageToHeader(current.page);
> p: Page;
956,957c2271,2272
< IF cleanTo < impureCopyPtr THEN
< VAR ptr := impureCopyPtr;
---
> IF cleanTo < current.ptr THEN
> VAR ptr := current.ptr;
959c2274
< CleanBetween(cleanTo, ptr);
---
> cleaner(cleanTo, ptr);
963,979c2278,2287
< IF impureCopyStack = Nil THEN RETURN FALSE; END;
< VAR p := impureCopyStack;
< BEGIN
< impureCopyStack := desc[p - p0].link;
< <* ASSERT NOT desc[p - p0].pure *>
< IF desc[p - p0].gray THEN
< IF desc[p - p0].protected THEN Unprotect(p); END;
< CleanBetween(PageToHeader(p), PageToHeader(p + 1));
< FOR i := 0 TO PageCount(p) - 1 DO
< desc[p + i - p0].gray := FALSE;
< END;
< IF desc[p - p0].generation = Generation.Older THEN
< <* ASSERT desc[p - p0].space = Space.Current *>
< Protect(p, readable := TRUE, writable := FALSE);
< END;
< IF perfOn THEN PerfChange(p, PageCount(p)); END;
< END;
---
> p := current.stack;
> IF p = Nil THEN RETURN FALSE; END;
> current.stack := desc[p - p0].link;
> <* ASSERT desc[p - p0].gray *>
> <* ASSERT desc[p - p0].resident *>
> <* ASSERT desc[p - p0].access = Access.ReadWrite *>
> cleaner(PageToHeader(p), PageToHeader(p + 1));
> FOR i := 0 TO PageCount(p) - 1 DO
> desc[p + i - p0].gray := gray;
> desc[p + i - p0].dirty := FALSE;
980a2289
> IF perfOn THEN PerfChange(p, PageCount(p)) END;
982c2291
< IF impureCopyPage # originalImpureCopyPage THEN EXIT; END;
---
> IF current.page # originalPage THEN EXIT; END;
984,993c2293,2300
< CleanBetween(cleanTo, originalBoundary);
< (* originalImpureCopyPage is now in the stack; mark it not gray *)
< IF originalImpureCopyPage # Nil THEN
< desc[originalImpureCopyPage - p0].gray := FALSE;
< IF desc[originalImpureCopyPage - p0].generation = Generation.Older THEN
< <* ASSERT desc[originalImpureCopyPage - p0].space = Space.Current *>
< Protect(
< originalImpureCopyPage, readable := TRUE, writable := FALSE);
< END;
< IF perfOn THEN PerfChange(originalImpureCopyPage, 1); END;
---
> cleaner(cleanTo, originalBoundary);
>
> (* originalPage is now in the stack; mark it not gray *)
> p := originalPage;
> IF p # Nil THEN
> desc[p - p0].gray := gray;
> desc[p - p0].dirty := FALSE;
> IF perfOn THEN PerfChange(p, 1) END;
996c2303
< END CopySome;
---
> END CleanSome;
1009a2317,2385
> PROCEDURE CleanTransient (h, he: RefHeader) =
> BEGIN
> WHILE h < he DO
> <* ASSERT Word.And (LOOPHOLE (h, INTEGER), 3) = 0 *>
> <* ASSERT NOT h.forwarded *>
> h.marka := FALSE;
> h.markb := FALSE;
> RTHeapMap.WalkRef (h, tmover);
> INC(h, ADRSIZE(Header) + ReferentSize(h));
> END;
> END CleanTransient;
>
> PROCEDURE CleanPersistent (h, he: RefHeader) =
> VAR
> p: Page;
> pi: INTEGER;
> mapDB: RTDB.T;
> tc: Typecode;
> def: TypeDefn;
> pure: BOOLEAN;
> fpRef: REF Fingerprint.T;
> fpAdr: ADDRESS;
> page: RTDB.Page;
> BEGIN
> IF h < he THEN
> p := HeaderToPage(h);
> <* ASSERT p # Nil *>
> pi := p - p0;
> page := map[pi];
> <* ASSERT page # NIL *>
> IF page.writer # ThreadF.myTxn THEN RETURN END;
> pure := desc[pi].pure;
> mapDB := page.db;
> <* ASSERT mapDB # NIL *>
> SetDB(mapDB);
>
> REPEAT
> <* ASSERT Word.And (LOOPHOLE (h, INTEGER), 3) = 0 *>
> <* ASSERT NOT h.forwarded *>
> h.marka := FALSE;
> h.markb := FALSE;
> tc := h.typecode;
> IF tc = Fill_1_type THEN
> INC(h, ADRSIZE(Header));
> ELSIF tc = Fill_N_type THEN
> INC(h, LOOPHOLE(h + ADRSIZE(Header), UNTRACED REF INTEGER)^);
> ELSE
> def := RTType.Get(tc);
> <* ASSERT def.traced = 1 *>
> fpRef := NIL;
> fpAdr := NIL;
> mapDB.mapFP(LOOPHOLE(def.fp, Fingerprint.T), fpRef, fpAdr);
> IF NOT pure THEN
> <* FATAL ANY *>
> BEGIN
> RTTypeMap.DoWalkRef(def, h + ADRSIZE(Header),
> RTTypeMap.Mask{RTTypeMap.Kind.Ref}, pmover);
> END;
> END;
> IF def.nDimensions = 0 THEN
> INC(h, ADRSIZE(Header) + def.dataSize);
> ELSE
> INC(h, ADRSIZE(Header) + OpenArraySize(h, def));
> END;
> END;
> UNTIL NOT h < he;
> END;
> END CleanPersistent;
>
1035,1036c2411,2416
< InsertFiller(impureCopyPtr, impureCopyBoundary - impureCopyPtr);
< InsertFiller(pureCopyPtr, pureCopyBoundary - pureCopyPtr);
---
> InsertFiller(impureCopy.ptr, impureCopy.boundary - impureCopy.ptr);
> InsertFiller(pureCopy.ptr, pureCopy.boundary - pureCopy.ptr);
> InsertFiller(impureTransientCopy.ptr,
> impureTransientCopy.boundary - impureTransientCopy.ptr);
> InsertFiller(pureTransientCopy.ptr,
> pureTransientCopy.boundary - pureTransientCopy.ptr);
1132,1133c2512,2517
< InsertFiller(impureCopyPtr, impureCopyBoundary - impureCopyPtr);
< InsertFiller(pureCopyPtr, pureCopyBoundary - pureCopyPtr);
---
> InsertFiller(impureCopy.ptr, impureCopy.boundary - impureCopy.ptr);
> InsertFiller(pureCopy.ptr, pureCopy.boundary - pureCopy.ptr);
> InsertFiller(impureTransientCopy.ptr,
> impureTransientCopy.boundary - impureTransientCopy.ptr);
> InsertFiller(pureTransientCopy.ptr,
> pureTransientCopy.boundary - pureTransientCopy.ptr);
1228c2612
< data : REF ARRAY OF RefReferent;
---
> data : <*TRANSIENT*> REF ARRAY OF RefReferent;
1245c2629
< s.data := NEW(REF ARRAY OF RefReferent, 100);
---
> s.data := NEW(<*TRANSIENT*> REF ARRAY OF RefReferent, 100);
1268,1269c2652
< newStack: REF ARRAY OF RefReferent := NEW(REF ARRAY OF RefReferent,
< newStackN);
---
> newStack := NEW(<*TRANSIENT*> REF ARRAY OF RefReferent, newStackN);
1316c2699
< nextNewPtr: RefHeader;
---
> nextPtr : RefHeader;
1320,1321c2703,2704
< newPtr? *)
< VAR referentTry := newPtr + ADRSIZE(Header);
---
> new.ptr? *)
> VAR referentTry := new.ptr + ADRSIZE(Header);
1326c2709
< | nextNewPtr := LOOPHOLE (a + dataSize, RefHeader); END;
---
> | nextPtr := LOOPHOLE (a + dataSize, RefHeader); END;
1331c2714
< nextNewPtr := referentTry + (alignment + dataSize);
---
> nextPtr := referentTry + (alignment + dataSize);
1334,1335c2717,2718
< IF nextNewPtr > newBoundary THEN
< nextNewPtr := NIL; (* clear in case of GC *)
---
> IF nextPtr > new.boundary THEN
> nextPtr := NIL; (* clear in case of GC *)
1337,1339c2720
< res := LongAlloc(dataSize, dataAlignment, currentPtr := newPtr,
< currentBoundary := newBoundary,
< currentPage := newPage, stack := newStack,
---
> res := LongAlloc(dataSize, dataAlignment, new,
1348,1349c2729,2730
< InsertFiller(newPtr, alignment);
< newPtr := newPtr + alignment;
---
> InsertFiller(new.ptr, alignment);
> new.ptr := new.ptr + alignment;
1351c2732
< VAR res := LOOPHOLE(newPtr + ADRSIZE(Header), RefReferent);
---
> VAR res := LOOPHOLE(new.ptr + ADRSIZE(Header), RefReferent);
1353c2734
< newPtr := nextNewPtr;
---
> new.ptr := nextPtr;
1359,1360c2740
< (* AllocForPureCopy and AllocForImpureCopy allocate space to copy an object
< from oldspace; they have the same logic as AllocForNew. *)
---
> (* AllocForNewTransient allocates space for a NEW. *)
1362,1363c2742,2743
< PROCEDURE AllocForPureCopy (dataSize, dataAlignment: CARDINAL):
< RefReferent =
---
> PROCEDURE AllocForNewTransient (dataSize, dataAlignment: CARDINAL)
> : RefReferent =
1365,1367c2745,2746
< alignment : INTEGER;
< nextPureCopyPtr : RefHeader;
< res, referentTry: RefReferent;
---
> alignment : INTEGER;
> nextPtr : RefHeader;
1369d2747
< <* ASSERT collectorOn *>
1372,1380c2750,2751
< pureCopyPtr? *)
< referentTry := pureCopyPtr + ADRSIZE(Header);
<
< (* ---------------- see CheckTypes ---------------------------------
< | WITH a = RTMisc.Align (referentTry, dataAlignment) DO
< | alignment := a - referentTry;
< | nextPureCopyPtr := LOOPHOLE (a + dataSize, RefHeader); END;
< ------------------------------------------------------------------ *)
< VAR tmp := Word.And(LOOPHOLE(referentTry, INTEGER), MaxAlignMask);
---
> newTransient.ptr? *)
> VAR referentTry := newTransient.ptr + ADRSIZE(Header);
1382,1383c2753,2761
< alignment := align[tmp, dataAlignment];
< nextPureCopyPtr := referentTry + (alignment + dataSize);
---
> (* ---------------- see CheckTypes ---------------------------------
> | WITH a = RTMisc.Align (referentTry, dataAlignment) DO
> | alignment := a - referentTry;
> | nextPtr := LOOPHOLE (a + dataSize, RefHeader); END;
> ------------------------------------------------------------------ *)
> alignment :=
> align[Word.And(LOOPHOLE(referentTry, INTEGER), MaxAlignMask),
> dataAlignment];
> nextPtr := referentTry + (alignment + dataSize);
1385d2762
<
1387,1393c2764,2772
< IF nextPureCopyPtr > pureCopyBoundary THEN
< res := LongAlloc(dataSize, dataAlignment, currentPtr := pureCopyPtr,
< currentBoundary := pureCopyBoundary,
< currentPage := pureCopyPage, stack := pureCopyStack,
< allocMode := AllocMode.Copy, pure := TRUE);
< RTOS.UnlockHeap();
< RETURN res;
---
> IF nextPtr > newTransient.boundary THEN
> nextPtr := NIL; (* clear in case of GC *)
> VAR
> res := LongAlloc(dataSize, dataAlignment, newTransient,
> allocMode := AllocMode.New, pure := FALSE);
> BEGIN
> RTOS.UnlockHeap();
> RETURN res;
> END;
1395d2773
<
1398,1399c2776,2783
< InsertFiller(pureCopyPtr, alignment);
< pureCopyPtr := pureCopyPtr + alignment;
---
> InsertFiller(newTransient.ptr, alignment);
> newTransient.ptr := newTransient.ptr + alignment;
> END;
> VAR res := LOOPHOLE(newTransient.ptr + ADRSIZE(Header), RefReferent);
> BEGIN
> newTransient.ptr := nextPtr;
> RTOS.UnlockHeap();
> RETURN res;
1400a2785
> END AllocForNewTransient;
1402,1406c2787,2788
< res := LOOPHOLE(pureCopyPtr + ADRSIZE(Header), RefReferent);
< pureCopyPtr := nextPureCopyPtr;
< RTOS.UnlockHeap();
< RETURN res;
< END AllocForPureCopy;
---
> (* AllocForCopy allocates space to copy an object from oldspace; it has the
> same logic as AllocForNew. *)
1408,1409c2790,2792
< PROCEDURE AllocForImpureCopy (dataSize, dataAlignment: CARDINAL):
< RefReferent =
---
> PROCEDURE AllocForCopy (dataSize, dataAlignment: CARDINAL;
> VAR current: AllocRec;
> pure: BOOLEAN) : RefReferent =
1411,1413c2794,2796
< alignment : INTEGER;
< nextImpureCopyPtr: RefHeader;
< res, referentTry : RefReferent;
---
> alignment : INTEGER;
> nextPtr : RefHeader;
> res, referentTry: RefReferent;
1418,1419c2801,2802
< ImpureCopyPtr? *)
< referentTry := impureCopyPtr + ADRSIZE(Header);
---
> current.ptr? *)
> referentTry := current.ptr + ADRSIZE(Header);
1424c2807
< | nextImpureCopyPtr := LOOPHOLE (a + dataSize, RefHeader); END;
---
> | nextPtr := LOOPHOLE (a + dataSize, RefHeader); END;
1429c2812
< nextImpureCopyPtr := referentTry + (alignment + dataSize);
---
> nextPtr := referentTry + (alignment + dataSize);
1433,1438c2816,2818
< IF nextImpureCopyPtr > impureCopyBoundary THEN
< res :=
< LongAlloc(dataSize, dataAlignment, currentPtr := impureCopyPtr,
< currentBoundary := impureCopyBoundary,
< currentPage := impureCopyPage, stack := impureCopyStack,
< allocMode := AllocMode.Copy, pure := FALSE);
---
> IF nextPtr > current.boundary THEN
> res := LongAlloc(dataSize, dataAlignment, current,
> allocMode := AllocMode.Copy, pure := pure);
1445,1446c2825,2826
< InsertFiller(impureCopyPtr, alignment);
< impureCopyPtr := impureCopyPtr + alignment;
---
> InsertFiller(current.ptr, alignment);
> current.ptr := current.ptr + alignment;
1449,1450c2829,2830
< res := LOOPHOLE(impureCopyPtr + ADRSIZE(Header), RefReferent);
< impureCopyPtr := nextImpureCopyPtr;
---
> res := LOOPHOLE(current.ptr + ADRSIZE(Header), RefReferent);
> current.ptr := nextPtr;
1453c2833
< END AllocForImpureCopy;
---
> END AllocForCopy;
1457,1463c2837,2841
< PROCEDURE LongAlloc ( dataSize, dataAlignment : CARDINAL;
< VAR (*INOUT*) currentPtr, currentBoundary: RefHeader;
< VAR (*INOUT*) currentPage : Page;
< VAR (*INOUT*) stack : Page;
< allocMode : AllocMode;
< pure : BOOLEAN ):
< RefReferent =
---
> PROCEDURE LongAlloc ( dataSize, dataAlignment : CARDINAL;
> VAR (*INOUT*) current : AllocRec;
> allocMode : AllocMode;
> pure : BOOLEAN)
> : RefReferent =
1483c2861,2862
< gray := allocMode = AllocMode.Copy AND NOT pure;
---
> persistent := current.db # NIL;
> gray := persistent OR allocMode = AllocMode.Copy AND NOT pure;
1499,1500c2878
< IF generation = Generation.Older THEN <* ASSERT gray OR pure *>
< END;
---
> IF generation = Generation.Older THEN <* ASSERT gray OR pure *> END;
1504,1506c2882,2894
< Desc{space := Space.Current, generation := generation, pure :=
< pure, note := note, gray := gray, protected := FALSE,
< continued := FALSE};
---
> Desc{space := Space.Current, generation := generation,
> pure := pure, note := note, gray := gray,
> access := Access.ReadWrite, continued := FALSE,
> resident := TRUE, dirty := NOT pure};
> IF persistent THEN
> VAR page := current.db.newPage();
> BEGIN
> map[thisPage - p0] := page;
> page.p := thisPage;
> page.lastReader := ThreadF.myTxn;
> page.writer := ThreadF.myTxn;
> END
> END;
1519,1522c2907,2920
< Desc{space := Space.Current, generation := generation, pure :=
< pure, note := note, gray := gray, protected := FALSE,
< continued := TRUE};
< END;
---
> Desc{space := Space.Current, generation := generation,
> pure := pure, note := note, gray := gray,
> access := Access.ReadWrite, continued := TRUE,
> resident := TRUE, dirty := NOT pure};
> IF persistent THEN
> VAR page := current.db.newPage();
> BEGIN
> map[thisPage + i - p0] := page;
> page.p := thisPage;
> page.lastReader := ThreadF.myTxn;
> page.writer := ThreadF.myTxn;
> END
> END
> END
1527c2925
< IF thisBoundary - thisPtr > currentBoundary - currentPtr THEN
---
> IF thisBoundary - thisPtr > current.boundary - current.ptr THEN
1530,1534c2928,2932
< InsertFiller(currentPtr, currentBoundary - currentPtr);
< IF currentPage # Nil THEN
< <* ASSERT desc[currentPage - p0].space = Space.Current *>
< desc[currentPage - p0].link := stack;
< stack := currentPage;
---
> InsertFiller(current.ptr, current.boundary - current.ptr);
> IF current.page # Nil THEN
> <* ASSERT desc[current.page - p0].space = Space.Current *>
> desc[current.page - p0].link := current.stack;
> current.stack := current.page;
1536,1537c2934,2935
< <* ASSERT desc[currentPage - p0].gray
< OR desc[currentPage - p0].pure *>
---
> <* ASSERT desc[current.page - p0].gray
> OR desc[current.page - p0].pure *>
1540,1542c2938,2940
< currentPtr := thisPtr;
< currentBoundary := thisBoundary;
< currentPage := thisPage;
---
> current.ptr := thisPtr;
> current.boundary := thisBoundary;
> current.page := thisPage;
1547,1548c2945,2946
< desc[thisPage - p0].link := stack;
< stack := thisPage;
---
> desc[thisPage - p0].link := current.stack;
> current.stack := thisPage;
1552,1553c2950,2951
< desc[thisPage - p0].link := stack;
< stack := thisPage;
---
> desc[thisPage - p0].link := current.stack;
> current.stack := thisPage;
1622c3020
< IF desc[p - p0].protected THEN Unprotect(p); END;
---
> IF desc[p - p0].access # Access.ReadWrite THEN Unprotect(p); END;
1631c3029
<
---
>
1652c3050,3051
< | Space.Previous => <* ASSERT FALSE *>
---
> | Space.Previous =>
> <* ASSERT FALSE *>
1654,1677c3053,3059
< <* ASSERT NOT desc[p - p0].gray *>
< <* ASSERT NOT desc[p - p0].continued *>
< IF desc[p - p0].protected THEN
< <* ASSERT desc[p - p0].generation = Generation.Older *>
< END;
< (* visit the objects on the page *)
< VAR
< h := PageToHeader(p);
< he := PageToHeader(p + 1);
< BEGIN
< IF p = newPage THEN he := newPtr; END;
< WHILE h < he DO
< (* check the references in the object *)
< IF desc[p - p0].protected THEN
< RTHeapMap.WalkRef (h, protectedCheck);
< ELSE
< RTHeapMap.WalkRef (h, refCheck);
< END;
< INC(h, ADRSIZE(Header) + ReferentSize(h));
< END;
< IF h > he THEN
< <* ASSERT HeaderToPage(h - 1) = p + PageCount(p) - 1 *>
< ELSE
< <* ASSERT PageCount(p) = 1 *>
---
> <* ASSERT NOT desc[p - p0].gray *>
> <* ASSERT NOT desc[p - p0].continued *>
> IF desc[p - p0].resident THEN
> IF desc[p - p0].access # Access.None THEN
> IF map[p - p0] = NIL AND desc[p - p0].access = Access.ReadOnly THEN
> <* ASSERT NOT desc[p - p0].dirty *>
> <* ASSERT desc[p - p0].generation = Generation.Older *>
1679,1693c3061,3076
< END;
< VAR
< n := PageCount(p);
< d := desc[p - p0];
< BEGIN
< d.continued := TRUE;
< d.link := Nil;
< LOOP
< INC(p);
< DEC(n);
< IF n = 0 THEN EXIT; END;
< VAR dd := desc[p - p0];
< BEGIN
< dd.link := Nil;
< <* ASSERT dd = d *>
---
> (* visit the objects on the page *)
> VAR
> h := PageToHeader(p);
> he := PageToHeader(p + 1);
> BEGIN
> IF p = new.page THEN he := new.ptr;
> ELSIF p = newTransient.page THEN he := newTransient.ptr; END;
> WHILE h < he DO
> (* check the references in the object *)
> IF map[p - p0] = NIL AND desc[p - p0].access = Access.ReadOnly
> THEN
> RTHeapMap.WalkRef (h, protectedCheck);
> ELSE
> RTHeapMap.WalkRef (h, refCheck);
> END;
> INC(h, ADRSIZE(Header) + ReferentSize(h));
1695,1696c3078,3117
< END;
< END;
---
> IF h > he THEN
> <* ASSERT HeaderToPage(h - 1) = p + PageCount(p) - 1 *>
> ELSE
> <* ASSERT PageCount(p) = 1 *>
> END
> END
> ELSE
> (* don't visit objects since the page is protected *)
> END
> ELSE
> <* ASSERT desc[p - p0].access = Access.None *>
> <* ASSERT desc[p - p0].pure *>
> <* ASSERT map[p - p0].writer = NIL *>
> END;
>
> VAR
> n := PageCount(p);
> d := desc[p - p0];
> BEGIN
> <* ASSERT NOT d.continued *>
> LOOP
> INC(p);
> DEC(n);
> IF n = 0 THEN EXIT; END;
> VAR dd := desc[p - p0];
> BEGIN
> <* ASSERT dd.space = d.space *>
> <* ASSERT dd.generation = d.generation *>
> <* ASSERT dd.pure = d.pure *>
> <* ASSERT dd.note = d.note *>
> <* ASSERT dd.gray = d.gray *>
> <* ASSERT dd.access = d.access *>
> <* ASSERT dd.continued *>
> <* ASSERT dd.resident = d.resident *>
> (* ASSERT dd.dirty = d.dirty *)
> (* ASSERT dd.link = d.link *)
> <* ASSERT map[p - p0] = NIL OR map[p - p0].db # NIL *>
> END
> END
> END;
1698,1699c3119,3120
< <* ASSERT NOT desc[p - p0].continued *>
< INC(p);
---
> <* ASSERT NOT desc[p - p0].continued *>
> INC(p);
1710,1712c3131,3132
< p := ReferentToPage(ref);
< h := HeaderOf(ref);
< tc := h.typecode;
---
> p := ReferentToPage(ref);
> h := HeaderOf(ref);
1717,1723c3137,3147
< <* ASSERT (0 < tc AND tc < RT0u.nTypes)
< OR tc = Fill_1_type
< OR tc = Fill_N_type *>
< ELSE
< (* the compiler generates Text.T that are not in the traced
< heap *)
< <* ASSERT tc = 1 *>
---
> IF desc[p - p0].access # Access.None THEN
> VAR tc := h.typecode;
> BEGIN
> <* ASSERT (0 < tc AND tc < RT0u.nTypes)
> OR tc = Fill_1_type
> OR tc = Fill_N_type *>
> END
> END
> ELSE
> (* the compiler generates Text.T that are not in the traced heap *)
> <* ASSERT h.typecode = RT0.TextTypecode *>
1735,1737c3159,3160
< p := ReferentToPage(ref);
< h := HeaderOf(ref);
< tc := h.typecode;
---
> p := ReferentToPage(ref);
> h := HeaderOf(ref);
1743,1749c3166,3176
< <* ASSERT (0 < tc AND tc < RT0u.nTypes)
< OR tc = Fill_1_type
< OR tc = Fill_N_type *>
< ELSE
< (* the compiler generates Text.T that are not in the traced
< heap *)
< <* ASSERT tc = 1 *>
---
> IF desc[p - p0].access # Access.None THEN
> VAR tc := h.typecode;
> BEGIN
> <* ASSERT (0 < tc AND tc < RT0u.nTypes)
> OR tc = Fill_1_type
> OR tc = Fill_N_type *>
> END
> END;
> ELSE
> (* the compiler generates Text.T that are not in the traced heap *)
> <* ASSERT h.typecode = RT0.TextTypecode *>
1770c3197,3199
< WHILE h < he AND (p # newPage OR h < newPtr) DO
---
> IF p = new.page THEN he := new.ptr;
> ELSIF p = newTransient.page THEN he := newTransient.ptr; END;
> WHILE h < he DO
1791,1792c3220,3221
< tcs : REF ARRAY OF Typecode;
< counts : REF ARRAY OF CARDINAL;
---
> tcs : <*TRANSIENT*> REF ARRAY OF Typecode;
> counts : <*TRANSIENT*> REF ARRAY OF CARDINAL;
1800c3229
< counts : REF ARRAY OF CARDINAL;
---
> counts : <*TRANSIENT*> REF ARRAY OF CARDINAL;
2064,2075c3493,3506
< WITH entry = weakTable[ab.a] DO
< (* check the weak ref there *)
< IF entry.t = ab THEN
< <* ASSERT entry.r # NIL *>
< IF collectorState # CollectorState.Zero THEN
< VAR p := ReferentToPage(entry.r);
< BEGIN
< <* ASSERT p # Nil *>
< IF desc[p - p0].space = Space.Previous THEN
< CollectorOn();
< Move(NIL, ADR(entry.r));
< CollectorOff();
---
> IF ab.a < NUMBER(weakTable^) THEN
> WITH entry = weakTable[ab.a] DO
> (* check the weak ref there *)
> IF entry.t = ab THEN
> <* ASSERT entry.r # NIL *>
> IF collectorState # CollectorState.Zero THEN
> VAR p := ReferentToPage(entry.r);
> BEGIN
> <* ASSERT p # Nil *>
> IF desc[p - p0].space = Space.Previous THEN
> CollectorOn();
> Move(NIL, ADR(entry.r));
> CollectorOff();
> END;
2077a3509
> r := LOOPHOLE(entry.r, REFANY);
2079d3510
< r := LOOPHOLE(entry.r, REFANY);
2170,2171c3601,3603
< PROCEDURE Protect (p: Page; readable, writable: BOOLEAN) =
< VAR n := PageCount(p);
---
> PROCEDURE Protect (p: Page; access: Access) =
> VAR
> n := PageCount(p);
2173c3605
< <* ASSERT collectorOn OR (readable AND writable) *>
---
> <* ASSERT collectorOn OR access = Access.ReadWrite OR map[p-p0] # NIL *>
2176,2179c3608,3612
< RTHeapDep.Protect(p, n, readable, writable);
< VAR protected := NOT (readable AND writable);
< BEGIN
< FOR i := 0 TO n - 1 DO desc[p + i - p0].protected := protected; END;
---
> RTHeapDep.Protect(p, n,
> access # Access.None,
> access = Access.ReadWrite);
> FOR i := 0 TO n - 1 DO
> desc[p + i - p0].access := access;
2186c3619
< Protect(p, readable := TRUE, writable := TRUE);
---
> Protect(p, Access.ReadWrite);
2189,2199c3622,3650
< PROCEDURE Fault (addr: ADDRESS): BOOLEAN =
< VAR p := LOOPHOLE(addr, INTEGER) DIV BytesPerPage;
< BEGIN
< ThreadF.SuspendOthers();
< <* ASSERT RTHeapDep.VM *>
< <* NOWARN *><* ASSERT TRUE *>
< cycleCost :=
< cycleCost + RTHeapDep.VMFaultTime(); (* otherwise unaccounted for *)
< IF NOT (p0 <= p AND p < p1) OR desc[p - p0].space = Space.Unallocated THEN
< ThreadF.ResumeOthers();
< RETURN FALSE; (* not in heap *)
---
> TYPE Swizzler = RTTypeMap.Visitor OBJECT
> db: RTDB.T;
> page: RTDB.Page;
> METHODS
> swizzleRef(db: RTDB.T; ref: RefReferent): RefReferent RAISES {Thread.Aborted}
> := SwizzleRef;
> map(page: RTDB.Page; nbPages: CARDINAL) RAISES {Thread.Aborted} := Map;
> swizzleType(db: RTDB.T; ref: RefReferent): TypeDefn RAISES {Thread.Aborted}
> := SwizzleType;
> swizzlePage(): BOOLEAN RAISES {Thread.Aborted} := SwizzlePage;
> OVERRIDES
> apply := Swizzle
> END;
>
> PROCEDURE Swizzle (self: Swizzler; cp: ADDRESS; k: RTTypeMap.Kind)
> RAISES {Thread.Aborted} =
> VAR refref := LOOPHOLE(cp, UNTRACED REF RefReferent);
> BEGIN
> CASE k OF
> | RTTypeMap.Kind.UntracedRef, RTTypeMap.Kind.TransientRef =>
> refref^ := NIL;
> | RTTypeMap.Kind.Ref =>
> VAR ref := refref^;
> BEGIN
> IF ref # NIL THEN
> refref^ := self.swizzleRef(self.db, ref);
> END
> END
> ELSE
2201,2203c3652,3690
< IF NOT desc[p - p0].protected THEN
< ThreadF.ResumeOthers();
< RETURN TRUE; (* was protected, but not any more *)
---
> END Swizzle;
>
> PROCEDURE SwizzleRef (self: Swizzler; db: RTDB.T; ref: RefReferent)
> : RefReferent
> RAISES {Thread.Aborted} =
> VAR
> id: RTDB.Id := Word.RightShift(LOOPHOLE(ref, INTEGER), LogBytesPerPage);
> offset := Word.And(LOOPHOLE(ref, INTEGER), BytesPerPage - 1);
> nbPages := 1;
> p: Page;
> BEGIN
> (*
> Small object PID:
> +----------------+----------------+
> | page id | byte offset 00|
> +----------------+----------------+
>
> Large object PID:
> +----------------+-----------+----+
> | page id | # pages |xxx1|
> +----------------+-----------+----+
> The offset is encoded by the value of xxx.
> If # pages = 0 then object size can only be inferred from its type.
> *)
> IF Word.And(offset, 1) # 0 THEN
> (* large object *)
> nbPages := Word.RightShift(offset, 4);
> CASE Word.And(offset, 2_1111) OF
> | 2_0001 => offset := 4;
> | 2_0011 => offset := 8;
> | 2_0101 => offset := 16;
> | 2_0111 => offset := 32;
> | 2_1001 => offset := 64;
> | 2_1011 => offset := 128;
> | 2_1101 => offset := 256;
> | 2_1111 => offset := 512;
> ELSE
> <* ASSERT FALSE *>
> END;
2205,2210c3692,3710
< <* ASSERT NOT desc[p - p0].pure *>
< IF desc[p - p0].gray THEN
< CollectorOn();
< IF p = impureCopyPage THEN
< IF CopySome() THEN
< <* ASSERT NOT desc[p - p0].gray *>
---
>
> VAR page: RTDB.Page := db.mapPage(id);
> BEGIN
> IF page.p = Nil THEN
> self.map(page, nbPages);
> END;
> p := page.p;
> END;
>
> VAR pi := p - p0;
> BEGIN
> IF desc[pi].space = Space.Previous THEN
> IF desc[pi].pure THEN
> PromotePage(
> p, Desc{space := Space.Current, generation := copyGeneration,
> pure := TRUE, note := Note.Persistent,
> gray := FALSE, access := desc[pi].access,
> continued := FALSE, resident := desc[pi].resident,
> dirty := FALSE});
2212,2224c3712,3835
< IF desc[p - p0].gray THEN
< <* ASSERT p = impureCopyPage AND impureCopyStack = Nil *>
< InsertFiller(impureCopyPtr, impureCopyBoundary - impureCopyPtr);
< impureCopyPage := Nil;
< impureCopyStack := Nil;
< impureCopyPtr := NIL;
< impureCopyBoundary := NIL;
< FOR i := 0 TO PageCount(p) - 1 DO
< desc[p + i - p0].gray := FALSE;
< END;
< IF desc[p - p0].generation = Generation.Older THEN
< <* ASSERT desc[p - p0].space = Space.Current *>
< Protect(p, readable := TRUE, writable := FALSE);
---
> IF collectorOn THEN
> IF desc[pi].access # Access.ReadWrite THEN Unprotect(p) END;
> ELSE
> Protect(p, Access.None);
> END;
> PromotePage(
> p, Desc{space := Space.Current, generation := copyGeneration,
> pure := FALSE, note := Note.Persistent,
> gray := TRUE, access := desc[pi].access,
> continued := FALSE, resident := TRUE,
> dirty := TRUE});
> desc[pi].link := impureCopy.stack;
> impureCopy.stack := p;
> END
> END
> END;
> RETURN PageToAddress(p) + offset;
> END SwizzleRef;
>
> PROCEDURE Map (self: Swizzler; page: RTDB.Page; nbPages: CARDINAL)
> RAISES {Thread.Aborted} =
> (* page has not yet been mapped *)
> VAR
> p: Page;
> notAfter: SET OF Note := SET OF Note{Note.Allocated};
> d := Desc{space := Space.Current, generation := copyGeneration,
> pure := TRUE, note := Note.Persistent, gray := FALSE,
> access := Access.ReadWrite, continued := FALSE,
> resident := FALSE, dirty := FALSE};
> PROCEDURE PeekPageCount(page: RTDB.Page;
> READONLY data: RTHeapDep.PageData) =
> <*FATAL Thread.Aborted*>
> VAR
> h: RefHeader;
> type: ADDRESS;
> def: TypeDefn;
> dataSize, nbBytes: CARDINAL;
> BEGIN
> TRY
> ThreadF.SuspendOthers();
> h := LOOPHOLE(ADR(data[0]), RefHeader);
> type := LOOPHOLE(h, UNTRACED REF ADDRESS)^;
> IF type = LOOPHOLE(0, ADDRESS) THEN
> INC(h, ADRSIZE(Header));
> type := LOOPHOLE(h, UNTRACED REF ADDRESS)^;
> ELSIF type = LOOPHOLE(1, ADDRESS) THEN
> INC(h, LOOPHOLE(h + ADRSIZE(Header), UNTRACED REF INTEGER)^);
> type := LOOPHOLE(h, UNTRACED REF ADDRESS)^;
> END;
> def := self.swizzleType(page.db, type);
> IF def.nDimensions = 0 THEN
> dataSize := def.dataSize;
> ELSE
> dataSize := OpenArraySize(h, def);
> END;
> nbBytes := RTMisc.Upper(ADRSIZE(Header), def.dataAlignment) + dataSize;
> nbPages := (nbBytes + AdrPerPage - 1) DIV AdrPerPage;
> FINALLY
> ThreadF.ResumeOthers();
> END
> END PeekPageCount;
> BEGIN
> IF nbPages = 0 THEN
> (* large object of unknown size: get size from first page *)
> TRY
> IF self.page # NIL THEN
> Protect(self.page.p, Access.None);
> END;
> ThreadF.ResumeOthers();
> Thread.Acquire(page);
> page.peek(PeekPageCount);
> FINALLY
> Thread.Release(page);
> ThreadF.SuspendOthers();
> IF self.page # NIL THEN
> Unprotect(self.page.p);
> END
> END;
> END;
> p := FindFreePages(nbPages, notAfter := notAfter);
> desc[p - p0] := d;
> map[p - p0] := page;
> page.p := p;
> IF nbPages > 1 THEN
> d.continued := TRUE;
> FOR i := 1 TO nbPages - 1 DO
> desc[p + i - p0] := d;
> page := page.db.mapPage(page.id + 1);
> map[p + i - p0] := page;
> page.p := p + i;
> END
> END;
> Protect(p, Access.None);
> END Map;
>
> PROCEDURE SwizzleType (self: Swizzler; db: RTDB.T; ref: RefReferent): TypeDefn
> RAISES {Thread.Aborted} =
> VAR
> fpRef := LOOPHOLE(self.swizzleRef(db, ref), REF Fingerprint.T);
> fpAdr := ref;
> p: Page := Word.RightShift(LOOPHOLE(fpRef, INTEGER), LogBytesPerPage);
> fp: Fingerprint.T;
> PROCEDURE PeekType(page: RTDB.Page; READONLY data: RTHeapDep.PageData) =
> VAR p := page.p;
> BEGIN
> ThreadF.SuspendOthers();
> Unprotect(p);
> PageToData(p)^ := data;
> fp := fpRef^;
> Protect(p, Access.None);
> desc[p - p0].dirty := TRUE;
> ThreadF.ResumeOthers();
> END PeekType;
> BEGIN
> IF desc[p - p0].access # Access.ReadWrite THEN
> IF desc[p - p0].pure THEN
> (* don't fault page, just get fingerprint *)
> VAR page := map[p - p0];
> BEGIN
> <* ASSERT page # NIL *>
> <* ASSERT page # self.page *>
> TRY
> IF self.page # NIL THEN
> Protect(self.page.p, Access.None);
2226c3837,3908
< IF perfOn THEN PerfChange(p, 1); END;
---
> ThreadF.ResumeOthers();
> Thread.Acquire(page);
> ThreadF.SuspendOthers();
> IF desc[p - p0].resident THEN
> fp := fpRef^;
> <* ASSERT desc[p - p0].access = Access.ReadOnly *>
> ELSIF desc[p - p0].dirty THEN
> Unprotect(p);
> fp := fpRef^;
> Protect(p, Access.None);
> ELSE
> TRY
> ThreadF.ResumeOthers();
> page.peek(PeekType);
> FINALLY
> ThreadF.SuspendOthers();
> END
> END
> FINALLY
> ThreadF.ResumeOthers();
> Thread.Release(page);
> ThreadF.SuspendOthers();
> IF self.page # NIL THEN
> Unprotect(self.page.p);
> END
> END
> END
> ELSIF desc[p - p0].gray THEN
> (* don't clean page, just get fingerprint *)
> Unprotect(p);
> fp := fpRef^;
> Protect(p, Access.None);
> ELSE
> fp := fpRef^;
> <* ASSERT desc[p - p0].access = Access.ReadOnly *>
> END
> ELSE
> fp := fpRef^;
> END;
> db.mapFP(fp, fpRef, fpAdr);
> RETURN RTType.Get(RTTypeFP.FromFingerprint(fp));
> END SwizzleType;
>
> PROCEDURE SwizzlePage (self: Swizzler): BOOLEAN RAISES {Thread.Aborted} =
> VAR
> pure := TRUE;
> type: RefReferent;
> def: TypeDefn;
> referentSize: CARDINAL;
> p := self.page.p;
> h := PageToHeader(p);
> he := PageToHeader(p + 1);
> BEGIN
> WHILE h < he DO
> type := LOOPHOLE(h, UNTRACED REF ADDRESS)^;
> IF type = LOOPHOLE(0, ADDRESS) THEN
> h^ := Header{typecode := Fill_1_type};
> referentSize := 0;
> ELSIF type = LOOPHOLE(1, ADDRESS) THEN
> h^ := Header{typecode := Fill_N_type};
> referentSize := LOOPHOLE(h + ADRSIZE(Header), UNTRACED REF INTEGER)^;
> DEC(referentSize, ADRSIZE(Header));
> ELSE
> def := self.swizzleType(self.db, type);
> <* ASSERT def.traced = 1 *>
> h^ := Header{typecode := def.typecode};
> IF def.nDimensions = 0 THEN
> referentSize := def.dataSize;
> IF def.defaultMethods # NIL THEN
> (* object: set up methods pointer *)
> LOOPHOLE(h + ADRSIZE(Header), UNTRACED REF RT0.MethodSuite)^ :=
> def.defaultMethods;
2227a3910,3914
> ELSE
> (* open array: set up the internal pointer *)
> LOOPHOLE(h + ADRSIZE(Header), UNTRACED REF ADDRESS)^ :=
> h + ADRSIZE(Header) + def.dataSize;
> referentSize := OpenArraySize(h, def);
2229,2231c3916,3959
< ELSE
< p := FirstPage(p);
< Unprotect(p);
---
> IF def.gc_map # NIL OR def.parent # NIL THEN
> pure := FALSE;
> RTTypeMap.DoWalkRef(def, <*NOWARN*> (* Thread.Aborted *)
> h + ADRSIZE(Header),
> RTTypeMap.Mask{RTTypeMap.Kind.Ref,
> RTTypeMap.Kind.UntracedRef,
> RTTypeMap.Kind.TransientRef},
> self);
> END
> END;
> INC(h, ADRSIZE(Header) + referentSize);
> END;
> RETURN pure;
> END SwizzlePage;
>
> PROCEDURE SwizzleRoot (db: RTDB.T): REFANY =
> (* root should be first object on page 1 *)
> <*FATAL Thread.Aborted*>
> VAR
> rootId := LOOPHOLE(BytesPerPage, ADDRESS) + ADRSIZE(Header);
> swizzler := NEW(Swizzler, db := db, page := NIL);
> BEGIN
> TRY
> ThreadF.SuspendOthers();
> RETURN LOOPHOLE(swizzler.swizzleRef(db, rootId), REFANY);
> FINALLY
> ThreadF.ResumeOthers();
> END
> END SwizzleRoot;
>
> PROCEDURE GrayFault (p: Page) =
> BEGIN
> <* ASSERT desc[p - p0].resident *>
> <* ASSERT desc[p - p0].access = Access.None *>
> <* ASSERT NOT desc[p - p0].pure *>
> CollectorOn();
> IF p = impureCopy.page THEN
> EVAL CopySome();
> IF desc[p - p0].gray THEN
> <* ASSERT p = impureCopy.page *>
> InsertFiller(impureCopy.ptr, impureCopy.boundary - impureCopy.ptr);
> impureCopy.page := Nil;
> impureCopy.ptr := NIL;
> impureCopy.boundary := NIL;
2233,2238c3961,3975
< FOR i := 0 TO PageCount(p) - 1 DO
< desc[p + i - p0].gray := FALSE;
< END;
< IF desc[p - p0].generation = Generation.Older THEN
< <* ASSERT desc[p - p0].space = Space.Current *>
< Protect(p, readable := TRUE, writable := FALSE);
---
> desc[p - p0].gray := FALSE;
> desc[p - p0].dirty := FALSE;
> IF perfOn THEN PerfChange(p, 1) END;
> IF ThreadF.myTxn = NIL
> OR map[p - p0] = NIL
> OR map[p - p0].writer = ThreadF.myTxn
> THEN
> IF desc[p - p0].generation = Generation.Older THEN
> <* ASSERT desc[p - p0].space = Space.Current *>
> Protect(p, Access.ReadOnly);
> END
> ELSIF map[p - p0].lastReader = ThreadF.myTxn THEN
> Protect(p, Access.ReadOnly);
> ELSE
> Protect(p, Access.None);
2240d3976
< IF perfOn THEN PerfChange(p, PageCount(p)); END;
2242c3978,4005
< CollectorOff();
---
> ELSIF p = impureTransientCopy.page THEN
> EVAL CopySome();
> IF desc[p - p0].gray THEN
> <* ASSERT p = impureTransientCopy.page *>
> InsertFiller(
> impureTransientCopy.ptr,
> impureTransientCopy.boundary - impureTransientCopy.ptr);
> impureTransientCopy.page := Nil;
> impureTransientCopy.ptr := NIL;
> impureTransientCopy.boundary := NIL;
> CleanBetween(PageToHeader(p), PageToHeader(p + 1));
> desc[p - p0].gray := FALSE;
> desc[p - p0].dirty := FALSE;
> IF perfOn THEN PerfChange(p, 1); END;
> IF ThreadF.myTxn = NIL
> OR map[p - p0] = NIL
> OR map[p - p0].writer = ThreadF.myTxn
> THEN
> IF desc[p - p0].generation = Generation.Older THEN
> <* ASSERT desc[p - p0].space = Space.Current *>
> Protect(p, Access.ReadOnly);
> END
> ELSIF map[p - p0].lastReader = ThreadF.myTxn THEN
> Protect(p, Access.ReadOnly);
> ELSE
> Protect(p, Access.None);
> END
> END
2245d4007
< <* ASSERT desc[p - p0].generation = Generation.Older *>
2246a4009,4027
> CleanBetween(PageToHeader(p), PageToHeader(p + 1));
> FOR i := 0 TO PageCount(p) - 1 DO
> desc[p + i - p0].gray := FALSE;
> desc[p + i - p0].dirty := FALSE;
> END;
> IF perfOn THEN PerfChange(p, PageCount(p)) END;
> IF ThreadF.myTxn = NIL
> OR map[p - p0] = NIL
> OR map[p - p0].writer = ThreadF.myTxn
> THEN
> IF desc[p - p0].generation = Generation.Older THEN
> <* ASSERT desc[p - p0].space = Space.Current *>
> Protect(p, Access.ReadOnly);
> END
> ELSIF map[p - p0].lastReader = ThreadF.myTxn THEN
> Protect(p, Access.ReadOnly);
> ELSE
> Protect(p, Access.None);
> END
2248,2263c4029,4030
< ThreadF.ResumeOthers();
< RETURN TRUE; (* was protected, protection cleared *)
< END Fault;
<
< (* ----------------------------------------------------------------------- *)
<
< (* The inner-loop collector action is to pick a gray page and completely
< clean it (i.e., make its referents at least gray, so that the page
< becomes black). The current gray page, "impureCopyPage" is
< distinguished; it's the page that newly gray objects are copied to.
<
< To improve locality of referene in the new space, we keep the set of
< gray pages as a stack. This helps approximate a depth-first copy to
< newspace. The current page is not a member of the stack, but will
< become one when it becomes full. The current page is always the page
< that contains newPtr.
---
> CollectorOff();
> END GrayFault;
2265,2268c4032,4041
< To reduce page faults, we separate the "pure" copy pages (those whose
< objects contain no REFs) from the "impure" ones (those with REFs). Only
< impure pages become gray, since pure pages can have no REFs into the old
< space (since they have no REFs at all). *)
---
> PROCEDURE OlderFault (p: Page) =
> BEGIN
> <* ASSERT desc[p - p0].resident *>
> <* ASSERT NOT desc[p - p0].pure *>
> p := FirstPage(p);
> <* ASSERT NOT desc[p - p0].dirty *>
> <* ASSERT desc[p - p0].generation = Generation.Older *>
> desc[p - p0].dirty := TRUE;
> Unprotect(p);
> END OlderFault;
2270,2273c4043,4054
< VAR
< impureCopyPage: Page := Nil; (* the current impure copy page *)
< impureCopyStack: Page := Nil; (* threaded through the "link" field; ends
< at Nil *)
---
> PROCEDURE CopyPage (page: RTDB.Page; READONLY data: RTHeapDep.PageData) =
> VAR
> p := page.p;
> q := FirstPage(p);
> BEGIN
> ThreadF.SuspendOthers();
> Unprotect(q);
> PageToData(p)^ := data;
> desc[p - p0].dirty := TRUE;
> Protect(q, Access.None);
> ThreadF.ResumeOthers();
> END CopyPage;
2275,2276c4056,4097
< (* By analogy, we also maintain "pureCopyPage" and "pureCopyStack". These
< are not used, but maintaining them simplifies the code. *)
---
> PROCEDURE PersistentFault (p: Page) RAISES { Thread.Aborted } =
> VAR page: RTDB.Page;
> BEGIN
> p := FirstPage(p);
> page := map[p - p0];
> <*ASSERT desc[p - p0].space = Space.Current*>
> IF desc[p - p0].resident THEN
> IF desc[p - p0].access = Access.None THEN
> IF page.lastReader # ThreadF.myTxn THEN
> TRY
> ThreadF.ResumeOthers();
> Thread.Acquire(page);
> page.readAccess();
> FINALLY
> Thread.Release(page);
> ThreadF.SuspendOthers();
> END;
> IF NOT desc[p - p0].resident THEN RETURN END;
> IF desc[p - p0].access # Access.None THEN RETURN END;
> page.lastReader := ThreadF.myTxn;
> END;
> Protect(p, Access.ReadOnly);
> ELSE
> <* ASSERT desc[p - p0].access = Access.ReadOnly *>
> IF page.writer # ThreadF.myTxn THEN
> TRY
> ThreadF.ResumeOthers();
> Thread.Acquire(page);
> page.writeAccess();
> FINALLY
> Thread.Release(page);
> ThreadF.SuspendOthers();
> END;
> IF NOT desc[p - p0].resident THEN RETURN END;
> IF desc[p - p0].access # Access.ReadOnly THEN RETURN END;
> page.writer := ThreadF.myTxn;
> END;
> desc[p - p0].dirty := NOT desc[p - p0].pure;
> Unprotect(p);
> END;
> RETURN;
> END;
2278,2281c4099,4131
< VAR
< pureCopyPage: Page; (* the current pure copy page *)
< pureCopyStack: Page; (* threaded through the "link" field; ends
< at Nil *)
---
> (* non-resident, so fault the page(s) *)
> <* ASSERT desc[p - p0].pure *>
> desc[p - p0].dirty := FALSE;
> FOR pp := p TO p + PageCount(p) - 1 DO
> IF desc[pp - p0].resident THEN RETURN END;
> IF desc[pp - p0].dirty THEN RETURN END;
> page := map[pp - p0];
> TRY
> ThreadF.ResumeOthers();
> Thread.Acquire(page);
> page.readAccess();
> page.read(CopyPage);
> FINALLY
> Thread.Release(page);
> ThreadF.SuspendOthers();
> END
> END;
>
> <* ASSERT NOT desc[p - p0].resident *>
> <* ASSERT desc[p - p0].dirty *>
> page := map[p - p0];
> <* ASSERT p = page.p *>
> VAR swizzler := NEW(Swizzler, db := page.db, page := page);
> BEGIN
> TRY
> Unprotect(p);
> desc[p - p0].pure := swizzler.swizzlePage();
> EXCEPT
> | Thread.Aborted =>
> Protect(p, Access.None);
> RAISE Thread.Aborted;
> END
> END;
2283,2285c4133,4144
< (* By analogy, we also maintain "newPage" and "newStack". As with
< pureCopyPage and pureCopyStack, these are not used, but maintaining them
< simplifies the code. *)
---
> desc[p - p0].resident := TRUE;
> desc[p - p0].dirty := FALSE;
> VAR d := desc[p - p0];
> BEGIN
> d.continued := TRUE;
> FOR pp := p+1 TO p + PageCount(p) - 1 DO
> desc[pp - p0] := d;
> END
> END;
> map[p - p0].lastReader := ThreadF.myTxn;
> Protect(p, Access.ReadOnly);
> END PersistentFault;
2287,2294c4146,4183
< VAR
< newPage: Page; (* the current new page *)
< newStack: Page; (* threaded through the "link" field; ends
< at Nil *)
<
< (* Minimum number of bytes by which to grow the heap. Setting it higher
< reduces the number of system calls; setting it lower keeps the heap a
< little smaller. *)
---
> PROCEDURE Fault (addr: ADDRESS): BOOLEAN =
> VAR p := LOOPHOLE(addr, INTEGER) DIV BytesPerPage;
> BEGIN
> TRY
> ThreadF.SuspendOthers();
> <* ASSERT RTHeapDep.VM *>
> <* NOWARN *><* ASSERT TRUE *>
> cycleCost :=
> cycleCost + RTHeapDep.VMFaultTime(); (* otherwise unaccounted for *)
> IF NOT (p0 <= p AND p < p1)
> OR desc[p - p0].space = Space.Unallocated THEN
> RETURN FALSE; (* not in heap *)
> END;
> IF desc[p - p0].access = Access.ReadWrite THEN
> RETURN TRUE; (* was protected, but not any more *)
> END;
>
> IF desc[p - p0].gray THEN
> GrayFault(p);
> ELSIF map[p - p0] # NIL THEN
> IF ThreadF.myTxn = NIL THEN
> IF desc[p - p0].resident THEN
> desc[p - p0].dirty := NOT desc[p - p0].pure;
> Unprotect(p);
> ELSE
> RETURN FALSE
> END
> ELSE
> PersistentFault(p); <*NOWARN*> (* Thread.Aborted *)
> END
> ELSE
> OlderFault(p);
> END;
> RETURN TRUE; (* was protected, now cleared *)
> FINALLY
> ThreadF.ResumeOthers();
> END
> END Fault;
2601c4490,4491
< WITH newDesc = NEW(UNTRACED REF ARRAY OF Desc, newSideSpan) DO
---
> WITH newDesc = NEW(UNTRACED REF ARRAY OF Desc, newSideSpan) DO
> WITH newMap = NEW(UNTRACED REF ARRAY OF RTDB.Page, newSideSpan) DO
2602a4493
> <* ASSERT map # NIL *>
2604c4495,4496
< newDesc[i + p0 - newP0] := desc[i];
---
> newDesc [i + p0 - newP0] := desc[i];
> newMap [i + p0 - newP0] := map[i];
2607c4499,4500
< newDesc[i - newP0].space := Space.Unallocated;
---
> newDesc [i - newP0].space := Space.Unallocated;
> newMap [i - newP0] := NIL;
2610c4503,4504
< newDesc[i - newP0].space := Space.Unallocated;
---
> newDesc [i - newP0].space := Space.Unallocated;
> newMap [i - newP0] := NIL;
2612a4507
> DISPOSE(map);
2615c4510,4512
< END;
---
> map := newMap;
> END
> END
2674a4572,4578
> VAR
> stats: RECORD
> print := FALSE;
> accuratePages, ambiguousPages := 0;
> objects, bytes: UNTRACED REF ARRAY OF INTEGER;
> END;
>
2680a4585,4589
> IF RTParams.IsPresent("stats") THEN
> stats.print := TRUE;
> stats.objects := NEW(UNTRACED REF ARRAY OF INTEGER, RT0u.nTypes);
> stats.bytes := NEW(UNTRACED REF ARRAY OF INTEGER, RT0u.nTypes);
> END;
Only in Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common: RTDB.i3
Only in Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common: RTHeapDB.i3
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTHeapDebug.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTHeapDebug.m3
25,27c25,27
< Map = REF ARRAY OF Word.T;
< IntList = REF ARRAY OF INTEGER;
< WRList = REF ARRAY OF WeakRef.T;
---
> Map = <*TRANSIENT*> REF ARRAY OF Word.T;
> IntList = <*TRANSIENT*> REF ARRAY OF INTEGER;
> WRList = <*TRANSIENT*> REF ARRAY OF WeakRef.T;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTHeapDep.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTHeapDep.i3
25c25,28
< TYPE Page = [0 .. Word.Divide(-1, AdrPerPage)];
---
> TYPE
> Page = [0 .. Word.Divide(-1, AdrPerPage)];
> Byte = BITS 8 FOR [0..16_FF];
> PageData = ARRAY [0..BytesPerPage-1] OF Byte;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTHeapEvent.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTHeapEvent.i3
27,30c27,31
< space := RTHeapRep.Space.Unallocated, generation :=
< RTHeapRep.Generation.Younger, pure := FALSE, note :=
< RTHeapRep.Note.Allocated, gray := FALSE, protected :=
< FALSE, continued := FALSE};
---
> space := RTHeapRep.Space.Unallocated,
> generation := RTHeapRep.Generation.Younger,
> pure := FALSE, note := RTHeapRep.Note.Allocated,
> gray := FALSE, access := RTHeapRep.Access.ReadWrite,
> continued := FALSE, resident := TRUE, dirty := TRUE};
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTHeapMap.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTHeapMap.i3
15c15,16
< TYPE Visitor <: V_; V_ = OBJECT METHODS apply (a: ADDRESS) END;
---
> TYPE Visitor <: V_;
> V_ = <*TRANSIENT*> ROOT OBJECT METHODS apply (a: ADDRESS) END;
21a23,24
> PROCEDURE DoWalkRef (t: RT0.TypeDefn; A: ADDRESS; v: Visitor);
>
30d32
<
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTHeapMap.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTHeapMap.m3
10a11
> IMPORT RTParams;
187c188
< | Op.Ref =>
---
> | Op.Ref, Op.TransientRef =>
229a231
> IF RTParams.IsPresent("debugmaps") THEN DEBUG := TRUE; END;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTHeapRep.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTHeapRep.i3
18c18
< IMPORT RT0, RTHeapDep;
---
> IMPORT RT0, RTHeapDep, RTDB;
56c56,58
< VAR desc: UNTRACED REF ARRAY OF Desc;
---
> VAR
> desc: UNTRACED REF ARRAY OF Desc;
> map : UNTRACED REF ARRAY OF RTDB.Page;
65c67
< protected : BITS 1 FOR BOOLEAN;
---
> access : BITS 2 FOR Access;
66a69,70
> resident : BITS 1 FOR BOOLEAN;
> dirty : BITS 1 FOR BOOLEAN;
69a74,75
> TYPE Access = {None, ReadOnly, ReadWrite};
>
85a92,93
> Persistent, (* page promoted to current space because
> it is persistent *)
156a165,168
> PROCEDURE AllocForNewTransient (size, alignment: CARDINAL): ADDRESS;
> (* Return the address of "size" bytes of traced transientstorage on an
> "alignment" byte boundary. The storage is not zeroed. *)
>
209c221
< MonitorClosure <: OBJECT
---
> MonitorClosure <: <*TRANSIENT*> ROOT OBJECT
243c255
< RefVisitor = OBJECT
---
> RefVisitor = <*TRANSIENT*> ROOT OBJECT
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTHeapRep.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTHeapRep.m3
28c28
< PublicMonitorClosure = OBJECT
---
> PublicMonitorClosure = <*TRANSIENT*> ROOT OBJECT
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTHooks.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTHooks.i3
58a59,60
> PROCEDURE AllocateTransient (t: ADDRESS(*RT0.TypeDefn*)): REFANY;
>
60c62,65
< READONLY sizes: ArrayShape): REFANY;
---
> READONLY sizes: ArrayShape): REFANY;
>
> PROCEDURE AllocateTransientOpenArray (t: ADDRESS(*RT0.TypeDefn*);
> READONLY sizes: ArrayShape): REFANY;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTMapOp.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTMapOp.i3
32c32,33
< (*50*) SkipB_1, SkipB_2, SkipB_3, SkipB_4, SkipB_5, SkipB_6, SkipB_7, SkipB_8
---
> (*50*) SkipB_1, SkipB_2, SkipB_3, SkipB_4, SkipB_5, SkipB_6, SkipB_7, SkipB_8,
> (*58*) TransientRef
102c103,104
< Kind.Proc (* SkipB_8 *)
---
> Kind.Proc, (* SkipB_8 *)
> Kind.TransientRef (* TransientRef *)
166c168,169
< 8 (* SkipB_8 *)
---
> 8, (* SkipB_8 *)
> 0 (* TransientRef *)
228c231,232
< 0 (* SkipB_8 -> -n * Byte *)
---
> 0, (* SkipB_8 -> -n * Byte *)
> ADRSIZE(ADDRESS) (* TransientRef *)
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTTipe.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTTipe.i3
12c12
< T = OBJECT kind: Kind; size, align: INTEGER := 0; END;
---
> T = <*TRANSIENT*> ROOT OBJECT kind: Kind; size, align: INTEGER := 0; END;
39c39,41
< Field = REF RECORD type: T; next: Field; offset: INTEGER := 0; END;
---
> Field = <*TRANSIENT*> REF RECORD
> type: T; next: Field; offset: INTEGER := 0;
> END;
Only in Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common: RTTxn.i3
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTType.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTType.m3
118a119
> troot : RT0.TypeDefn;
381a383
> troot := FindType (16_ffffffffa973d3a6);
397a400
> AssignObjectTypecode (troot, next_typecode);
479a483
> FixObjectSizes (troot);
529a534
> SetupObject (troot);
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTTypeMap.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTTypeMap.i3
8a9,10
> IMPORT RT0;
>
27c29,30
< Set (* bit set *)
---
> Set, (* bit set *)
> TransientRef (* transient ref *)
31c34,35
< V_ = OBJECT METHODS apply (field: ADDRESS; k: Kind) RAISES ANY END;
---
> V_ = <*TRANSIENT*> ROOT OBJECT METHODS apply (field: ADDRESS; k: Kind)
> RAISES ANY END;
38c42,43
< END RTTypeMap.
---
> PROCEDURE DoWalkRef (t: RT0.TypeDefn; a: ADDRESS; m: Mask; v: Visitor)
> RAISES ANY;
39a45
> END RTTypeMap.
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTTypeMap.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTTypeMap.m3
103c103
< | Op.Ref, Op.UntracedRef, Op.Proc,
---
> | Op.Ref, Op.UntracedRef, Op.TransientRef, Op.Proc,
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTutils.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/common/RTutils.m3
26,28c26,28
< R = REF ARRAY OF TypeDesc;
< Map = REF ARRAY OF INTEGER;
< StatList = REF ARRAY OF Stat;
---
> R = <*TRANSIENT*> REF ARRAY OF TypeDesc;
> Map = <*TRANSIENT*> REF ARRAY OF INTEGER;
> StatList = <*TRANSIENT*> REF ARRAY OF Stat;
266a267
> p : INTEGER := LOOPHOLE(ref, INTEGER) DIV RTHeapRep.BytesPerPage;
277,285c278,288
< (* totals for this type on a per-site basis *)
< n_sites := RTAllocStats.NSites (tc);
< IF (n_sites >= 0) THEN
< IF (zz.sites = NIL) THEN zz.sites := NEW (StatList, n_sites+1); END;
< addr := LOOPHOLE (ref, ADDRESS);
< hdr := LOOPHOLE (addr - BYTESIZE(RT0.RefHeader), RTHeapRep.RefHeader);
< site := hdr.spare;
< INC (zz.sites[site].count);
< INC (zz.sites[site].size, size);
---
> IF NOT RTHeapRep.map[p - RTHeapRep.p0] # NIL THEN
> (* totals for this type on a per-site basis *)
> n_sites := RTAllocStats.NSites (tc);
> IF (n_sites >= 0) THEN
> IF (zz.sites = NIL) THEN zz.sites := NEW (StatList, n_sites+1); END;
> addr := LOOPHOLE (ref, ADDRESS);
> hdr := LOOPHOLE (addr - BYTESIZE(RT0.RefHeader), RTHeapRep.RefHeader);
> site := hdr.spare;
> INC (zz.sites[site].count);
> INC (zz.sites[site].size, size);
> END;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/FreeBSD/DEFS.h Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/FreeBSD/DEFS.h
38c38
< * $Id: DEFS.h,v 1.1.1.1 1997/01/16 21:29:56 ldd Exp $
---
> * $Id: DEFS.h,v 1.1.1.1 1998/10/28 21:39:58 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/FreeBSD2/DEFS.h Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/FreeBSD2/DEFS.h
38c38
< * $Id: DEFS.h,v 1.1.1.1 1997/01/16 21:29:56 ldd Exp $
---
> * $Id: DEFS.h,v 1.1.1.1 1998/10/28 21:39:58 hosking Exp $
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/LINUXELF/RTHeapDep.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/LINUXELF/RTHeapDep.m3
51,53c51,55
< sa_handler := newHandler, sa_mask :=
< Word.LeftShift(1, Usignal.SIGVTALRM - 1),
< sa_flags := Usignal.SA_RESTART,
---
> sa_handler := newHandler,
> sa_mask :=
> Word.Or(Word.LeftShift(1, Usignal.SIGVTALRM - 1),
> Word.LeftShift(1, Usignal.SIGINT - 1)),
> sa_flags := Word.Or(Usignal.SA_RESTART, Usignal.SA_NODEFER),
149c151
< VAR ret := Uresource.getrusage(Uresource.RUSAGE_SELF, ADR(usage));
---
> VAR ret := Uresource.getrusage(Uresource.RUSAGE_SELF, usage);
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/LINUXLIBC6/RTHeapDepC.c Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/LINUXLIBC6/RTHeapDepC.c
567c567
< int getitimer(enum __itimer_which which, struct itimerval *value)
---
> int getitimer(int which, struct itimerval *value)
613c613
< int getrlimit(enum __rlimit_resource resource, struct rlimit *rlp)
---
> int getrlimit(int resource, struct rlimit *rlim)
617,618c617,618
< MAKE_WRITABLE(rlp);
< result = syscall(SYS_getrlimit, resource, rlp);
---
> MAKE_WRITABLE(rlim);
> result = syscall(SYS_getrlimit, resource, rlim);
1275,1276c1275,1277
< int setitimer(enum __itimer_which which, const struct itimerval *value,
< struct itimerval *ovalue)
---
> int setitimer(int which,
> const struct itimerval *value,
> struct itimerval *ovalue)
1302c1303
< int setrlimit(enum __rlimit_resource resource, const struct rlimit *rlp)
---
> int setrlimit(int resource, const struct rlimit *rlim)
1306,1307c1307,1308
< MAKE_READABLE(rlp);
< result = syscall(SYS_setrlimit, resource, rlp);
---
> MAKE_READABLE(rlim);
> result = syscall(SYS_setrlimit, resource, rlim);
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/LINUXLIBC6/RTHeapDep.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/LINUXLIBC6/RTHeapDep.m3
53c53
< sa_flags := Usignal.SA_RESTART,
---
> sa_flags := Word.Or(Usignal.SA_RESTART, Usignal.SA_NODEFER),
59c59,60
< vec.sa_mask.val[0] := Word.LeftShift(1, Usignal.SIGVTALRM - 1);
---
> vec.sa_mask.val[0] := Word.Or(Word.LeftShift(1, Usignal.SIGVTALRM - 1),
> Word.LeftShift(1, Usignal.SIGINT - 1));
152c153
< VAR ret := Uresource.getrusage(Uresource.RUSAGE_SELF, ADR(usage));
---
> VAR ret := Uresource.getrusage(Uresource.RUSAGE_SELF, usage);
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/SOLgnu/RTHeapDep.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/SOLgnu/RTHeapDep.m3
54c54,55
< vec.sa_flags := Word.Or(Usignal.SA_RESTART, Usignal.SA_SIGINFO);
---
> vec.sa_flags := Word.Or(Usignal.SA_NODEFER,
> Word.Or(Usignal.SA_RESTART, Usignal.SA_SIGINFO));
58a60
> EVAL Usignal.sigaddset(vec.sa_mask, Usignal.SIGINT);
169c171
< ret := Uresource.getrusage(Uresource.RUSAGE_SELF, ADR(usage));
---
> ret := Uresource.getrusage(Uresource.RUSAGE_SELF, usage);
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/runtime/SOLsun/RTHeapDep.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/runtime/SOLsun/RTHeapDep.m3
54c54,55
< vec.sa_flags := Word.Or(Usignal.SA_RESTART, Usignal.SA_SIGINFO);
---
> vec.sa_flags := Word.Or(Usignal.SA_NODEFER,
> Word.Or(Usignal.SA_RESTART, Usignal.SA_SIGINFO));
58a60
> EVAL Usignal.sigaddset(vec.sa_mask, Usignal.SIGINT);
169c171
< ret := Uresource.getrusage(Uresource.RUSAGE_SELF, ADR(usage));
---
> ret := Uresource.getrusage(Uresource.RUSAGE_SELF, usage);
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/thread/Common/Thread.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/thread/Common/Thread.i3
13c13
< T <: ROOT;
---
> T <: <*TRANSIENT*> ROOT;
15c15
< Condition <: ROOT;
---
> Condition <: <*TRANSIENT*> ROOT;
23c23
< TYPE Closure = OBJECT METHODS apply(): REFANY END;
---
> TYPE Closure = <*TRANSIENT*> ROOT OBJECT METHODS apply(): REFANY END;
58a59,61
>
> EXCEPTION Aborted;
> (* Used to signal transaction abort. *)
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/thread/POSIX/ThreadF.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/thread/POSIX/ThreadF.i3
12c12
< IMPORT FloatMode, Thread;
---
> IMPORT FloatMode, Thread, RTTxn;
62c62
< Hooks = OBJECT METHODS
---
> Hooks = <*TRANSIENT*> ROOT OBJECT METHODS
78a79,86
>
> VAR (* READONLY *)
> myTxn: RTTxn.T;
> (* The txn of the currently running thread *)
>
> PROCEDURE TxnBegin(txn: RTTxn.T);
> PROCEDURE TxnCommit();
> PROCEDURE TxnAbort();
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/thread/POSIX/ThreadPosix.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/thread/POSIX/ThreadPosix.m3
18c18
< RTThread, RTIO, ThreadEvent, Time, TimePosix,
---
> RTThread, RTIO, RTTxn, RTHeapDB, ThreadEvent, Time, TimePosix,
29c29
< MUTEX = BRANDED "Mutex Posix-1.0" OBJECT
---
> MUTEX = <*TRANSIENT*> ROOT BRANDED "Mutex Posix-1.0" OBJECT
39c39
< Condition = BRANDED "Thread.Condition Posix-1.0" OBJECT
---
> Condition = <*TRANSIENT*> ROOT BRANDED "Thread.Condition Posix-1.0" OBJECT
69c69
< T = BRANDED "Thread.T Posix-1.6" OBJECT
---
> T = <*TRANSIENT*> ROOT BRANDED "Thread.T Posix-1.6" OBJECT
75c75
< result : REFANY := NIL;
---
> <*TRANSIENT*> result : REFANY := NIL;
101a102,104
> (* true if somebody aborted us and we did not TestAbort *)
> abortPending : BOOLEAN := FALSE;
>
114a118,120
>
> (* transaction support *)
> txn: RTTxn.T;
263a270,272
> (* and link into transaction *)
> t.txn := self.txn;
>
571c580
< FDS = REF ARRAY OF FDSet;
---
> FDS = <*TRANSIENT*> REF ARRAY OF FDSet;
816a826
> do_abort : BOOLEAN;
838c848,849
< IF t.alertable AND t.alertPending THEN
---
> IF t.alertable AND t.alertPending
> OR t.abortPending THEN
850a862,864
> IF t.abortPending THEN
> CanRun (t);
> EXIT; END;
853c867,868
< IF t.alertable AND t.alertPending THEN
---
> IF t.alertable AND t.alertPending
> OR t.abortPending THEN
869c884,885
< IF t.alertable AND t.alertPending THEN
---
> IF t.alertable AND t.alertPending
> OR t.abortPending THEN
938a955
> t.txn := NIL;
967,969c984,993
< do_alert := self.alertable AND self.alertPending;
< self.alertable := FALSE;
< IF do_alert THEN self.alertPending := FALSE END;
---
> do_abort := self.abortPending;
> IF do_abort THEN
> self.abortPending := FALSE;
> self.alertable := FALSE;
> self.alertPending := FALSE;
> ELSE
> do_alert := self.alertable AND self.alertPending;
> self.alertable := FALSE;
> IF do_alert THEN self.alertPending := FALSE END;
> END;
970a995
> IF do_abort THEN RAISE Aborted END; <*NOWARN*>
1210a1236,1238
> IF new_self.txn # NIL AND self.txn # new_self.txn THEN
> RTHeapDB.Transfer(self.txn, new_self.txn);
> END;
1212a1241
> myTxn := new_self.txn;
1267c1296
< OutT (" A* waiting for\n");
---
> OutT (" X A* waiting for\n");
1323a1353,1358
> (* abort status *)
> IF (t.abortPending)
> THEN OutT ("x ");
> ELSE OutT (" ");
> END;
>
1451c1486
< t := t.next;
---
> t := t.next;
1462a1498,1549
> (*------------------------------------------------------------- Txn hooks ---*)
>
> PROCEDURE TxnBegin(txn: RTTxn.T) =
> BEGIN
> INC (RT0u.inCritical);
> BEGIN
> txn.parent := self.txn;
> self.txn := txn;
> myTxn := self.txn;
> END;
> RTHeapDB.Transfer(txn.parent, txn);
> DEC (RT0u.inCritical);
> END TxnBegin;
>
> PROCEDURE TxnCommit() =
> VAR t: T;
> BEGIN
> INC (RT0u.inCritical);
> BEGIN
> t := self.next;
> WHILE t # self DO
> IF t.txn = self.txn THEN
> t.txn := t.txn.parent;
> END;
> t := t.next;
> END;
> self.txn := self.txn.parent;
> myTxn := self.txn;
> END;
> DEC (RT0u.inCritical);
> END TxnCommit;
>
> PROCEDURE TxnAbort() =
> VAR t: T;
> BEGIN
> INC (RT0u.inCritical);
> BEGIN
> t := self.next;
> WHILE t # self DO
> IF t.txn = self.txn THEN
> t.txn := t.txn.parent;
> t.abortPending := TRUE;
> END;
> t := t.next;
> END;
> self.txn := self.txn.parent;
> myTxn := self.txn;
> END;
> RTHeapDB.Abort();
> DEC (RT0u.inCritical);
> END TxnAbort;
>
1467a1555
> BEGIN
1476a1565
> myTxn := self.txn;
1481a1571
> END;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/thread/WIN32/ThreadWin32.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/thread/WIN32/ThreadWin32.m3
32c32
< Mutex = BRANDED "MUTEX Win32-1.0" OBJECT
---
> Mutex = <*TRANSIENT*> ROOT BRANDED "MUTEX Win32-1.0" OBJECT
39c39
< Condition = BRANDED "Thread.Condition Win32-1.0" OBJECT
---
> Condition = <*TRANSIENT*> BRANDED "Thread.Condition Win32-1.0" OBJECT
45c45
< T = BRANDED "Thread.T Win32-1.0" OBJECT
---
> T = <*TRANSIENT*> BRANDED "Thread.T Win32-1.0" OBJECT
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/time/WIN32/DateWin32.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/time/WIN32/DateWin32.m3
16c16,17
< REVEAL TimeZone = BRANDED OBJECT METHODS fromTime(t: Time.T): T END;
---
> REVEAL TimeZone
> = <*TRANSIENT*> ROOT BRANDED OBJECT METHODS fromTime(t: Time.T): T END;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/aix-3-2/Udir.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/aix-3-2/Udir.i3
15,16c15,16
< UdirRCSHeader = "$Header: /home/cvsroot/m3/pm3/libs/m3core/src/unix/aix-3-2/Udir.i3,v 1.1.1.1 1997/01/16 21:30:03 ldd Exp $";
< UdirDate = "$Date: 1997/01/16 21:30:03 $";
---
> UdirRCSHeader = "$Header: /u/u84/hosking/CVS/pm3/libs/m3core/src/unix/aix-3-2/Udir.i3,v 1.1.1.1 1998/10/28 21:40:21 hosking Exp $";
> UdirDate = "$Date: 1998/10/28 21:40:21 $";
67a68,70
> Revision 1.1.1.1 1998/10/28 21:40:21 hosking
> Polytechnique de Montreal Modula-3
>
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/aix-3-2/Udir.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/aix-3-2/Udir.m3
10,11c10,11
< UdirImplRCSHeader = "$Header: /home/cvsroot/m3/pm3/libs/m3core/src/unix/aix-3-2/Udir.m3,v 1.1.1.1 1997/01/16 21:30:03 ldd Exp $";
< UdirImplDate = "$Date: 1997/01/16 21:30:03 $";
---
> UdirImplRCSHeader = "$Header: /u/u84/hosking/CVS/pm3/libs/m3core/src/unix/aix-3-2/Udir.m3,v 1.1.1.1 1998/10/28 21:40:21 hosking Exp $";
> UdirImplDate = "$Date: 1998/10/28 21:40:21 $";
29a30,32
> Revision 1.1.1.1 1998/10/28 21:40:21 hosking
> Polytechnique de Montreal Modula-3
>
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/aix-3-2/Uresource.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/aix-3-2/Uresource.i3
78c78
< <*EXTERNAL*> PROCEDURE getrusage (who: int; rus: struct_rusage_star): int;
---
> <*EXTERNAL*> PROCEDURE getrusage (who: int; VAR rus: struct_rusage): int;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/aix-ps2-1-2/Udir.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/aix-ps2-1-2/Udir.i3
14,15c14,15
< UdirRCSHeader = "$Header: /home/cvsroot/m3/pm3/libs/m3core/src/unix/aix-ps2-1-2/Udir.i3,v 1.1.1.1 1997/01/16 21:30:04 ldd Exp $";
< UdirDate = "$Date: 1997/01/16 21:30:04 $";
---
> UdirRCSHeader = "$Header: /u/u84/hosking/CVS/pm3/libs/m3core/src/unix/aix-ps2-1-2/Udir.i3,v 1.1.1.1 1998/10/28 21:40:23 hosking Exp $";
> UdirDate = "$Date: 1998/10/28 21:40:23 $";
61a62,64
> Revision 1.1.1.1 1998/10/28 21:40:23 hosking
> Polytechnique de Montreal Modula-3
>
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/aix-ps2-1-2/Udir.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/aix-ps2-1-2/Udir.m3
10,11c10,11
< UdirImplRCSHeader = "$Header: /home/cvsroot/m3/pm3/libs/m3core/src/unix/aix-ps2-1-2/Udir.m3,v 1.1.1.1 1997/01/16 21:30:04 ldd Exp $";
< UdirImplDate = "$Date: 1997/01/16 21:30:04 $";
---
> UdirImplRCSHeader = "$Header: /u/u84/hosking/CVS/pm3/libs/m3core/src/unix/aix-ps2-1-2/Udir.m3,v 1.1.1.1 1998/10/28 21:40:23 hosking Exp $";
> UdirImplDate = "$Date: 1998/10/28 21:40:23 $";
29a30,32
> Revision 1.1.1.1 1998/10/28 21:40:23 hosking
> Polytechnique de Montreal Modula-3
>
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/aix-ps2-1-2/Uresource.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/aix-ps2-1-2/Uresource.i3
85c85
< <*EXTERNAL*> PROCEDURE getrusage (who: int; rus: struct_rusage_star): int;
---
> <*EXTERNAL*> PROCEDURE getrusage (who: int; VAR rus: struct_rusage): int;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/fbsd-alpha/Uresource.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/fbsd-alpha/Uresource.i3
94c94
< <*EXTERNAL*> PROCEDURE getrusage (who: int; rus: struct_rusage_star): int;
---
> <*EXTERNAL*> PROCEDURE getrusage (who: int; VAR rus: struct_rusage): int;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/freebsd-1/Uresource.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/freebsd-1/Uresource.i3
95c95
< <*EXTERNAL*> PROCEDURE getrusage (who: int; rus: struct_rusage_star): int;
---
> <*EXTERNAL*> PROCEDURE getrusage (who: int; VAR rus: struct_rusage): int;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/freebsd-2/Uresource.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/freebsd-2/Uresource.i3
94c94
< <*EXTERNAL*> PROCEDURE getrusage (who: int; rus: struct_rusage_star): int;
---
> <*EXTERNAL*> PROCEDURE getrusage (who: int; VAR rus: struct_rusage): int;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/freebsd-3/Uresource.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/freebsd-3/Uresource.i3
94c94
< <*EXTERNAL*> PROCEDURE getrusage (who: int; rus: struct_rusage_star): int;
---
> <*EXTERNAL*> PROCEDURE getrusage (who: int; VAR rus: struct_rusage): int;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/hpux-7-0/Uresource.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/hpux-7-0/Uresource.i3
83c83
< <*EXTERNAL*> PROCEDURE getrusage (who: int; rus: struct_rusage_star): int;
---
> <*EXTERNAL*> PROCEDURE getrusage (who: int; VAR rus: struct_rusage): int;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/ibm-4-3/Uresource.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/ibm-4-3/Uresource.i3
87c87
< <*EXTERNAL*> PROCEDURE getrusage (who: int; rus: struct_rusage_star): int;
---
> <*EXTERNAL*> PROCEDURE getrusage (who: int; VAR rus: struct_rusage): int;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/irix-5.2/Uresource.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/irix-5.2/Uresource.i3
90c90
< <*EXTERNAL*> PROCEDURE getrusage (who: int; rus: struct_rusage_star): int;
---
> <*EXTERNAL*> PROCEDURE getrusage (who: int; VAR rus: struct_rusage): int;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/linux/Uresource.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/linux/Uresource.i3
96c96
< <*EXTERNAL*> PROCEDURE getrusage (who: int; rus: struct_rusage_star): int;
---
> <*EXTERNAL*> PROCEDURE getrusage (who: int; VAR rus: struct_rusage): int;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/linux/Usignal.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/linux/Usignal.i3
122a123
> SA_NODEFER = SA_NOMASK;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/linux-libc6/Uresource.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/linux-libc6/Uresource.i3
96c96
< <*EXTERNAL*> PROCEDURE getrusage (who: int; rus: struct_rusage_star): int;
---
> <*EXTERNAL*> PROCEDURE getrusage (who: int; VAR rus: struct_rusage): int;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/linux-libc6/Usignal.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/linux-libc6/Usignal.i3
132a133
> SA_NODEFER = SA_NOMASK;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/osf-1.ALPHA_OSF/Usignal.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/osf-1.ALPHA_OSF/Usignal.i3
13c13
< IMPORT Utypes;
---
> FROM Utypes IMPORT caddr_t, size_t;
18,20c18,20
< SIGHUP = 1; (* hangup *)
< SIGINT = 2; (* interrupt *)
< SIGQUIT = 3; (* quit *)
---
> SIGHUP = 1; (* hangup, generated when terminal disconnects *)
> SIGINT = 2; (* interrupt, generated from terminal special char *)
> SIGQUIT = 3; (* quit, generated from terminal special char *)
25c25,26
< (* CHME, CHMS, CHMU are not yet given back to users reasonably *)
---
> ILL_INST_FAULT = 3; (* Illegal instruction *)
> ILL_MODE_FAULT = 4; (* Illegal mode - VMSPAL only *)
27c28
< SIGIOT = 6; (* IOT instruction *)
---
> SIGABRT = 6; (* abort process *)
30,39c31,47
< FPE_INTOVF_TRAP = 1; (* integer overflow *)
< FPE_INTDIV_TRAP = 2; (* integer divide by zero *)
< FPE_FLTOVF_TRAP = 3; (* floating overflow *)
< FPE_FLTDIV_TRAP = 4; (* floating/decimal divide by zero *)
< FPE_FLTUND_TRAP = 5; (* floating underflow *)
< FPE_DECOVF_TRAP = 6; (* decimal overflow *)
< FPE_SUBRNG_TRAP = 7; (* subscript out of range *)
< FPE_FLTOVF_FAULT = 8; (* floating overflow fault *)
< FPE_FLTDIV_FAULT = 9; (* divide by zero floating fault *)
< FPE_FLTUND_FAULT = 10; (* floating underflow fault *)
---
> FPE_INTOVF_TRAP = 16_1; (* integer overflow *)
> FPE_INTDIV_TRAP = 16_2; (* integer divide by zero *)
> FPE_FLTOVF_TRAP = 16_3; (* floating overflow *)
> FPE_FLTDIV_TRAP = 16_4; (* floating/decimal divide by zero *)
> FPE_FLTUND_TRAP = 16_5; (* floating underflow *)
> FPE_DECOVF_TRAP = 16_6; (* decimal overflow *)
> FPE_SUBRNG_TRAP = 16_7; (* subscript out of range *)
> FPE_FLTOVF_FAULT = 16_8; (* floating overflow fault *)
> FPE_FLTDIV_FAULT = 16_9; (* divide by zero floating fault *)
> FPE_FLTUND_FAULT = 16_a; (* floating underflow fault *)
> FPE_UNIMP_FAULT = 16_b; (* Unimplemented FPU instruction *)
> FPE_INVALID_FAULT = 16_c; (* Invalid operation *)
> FPE_INEXACT_FAULT = 16_d; (* Inexact result *)
> FPE_HPARITH_TRAP = 16_e; (* High performance trap *)
> FPE_INTOVF_FAULT = 16_f; (* Integer Overflow fault *)
> FPE_ILLEGAL_SHADOW_TRAP = 16_10; (* Illegal Trap Shadow Trap *)
> FPE_GENTRAP = 16_11; (* *)
41c49
< SIGBUS = 10; (* bus error *)
---
> SIGBUS = 10; (* bus error (specification exception) *)
45,46c53,54
< SIGALRM = 14; (* alarm clock *)
< SIGTERM = 15; (* software termination signal from kill *)
---
> SIGALRM = 14; (* alarm clock timeout *)
> SIGTERM = 15; (* software termination signal *)
48,59c56,67
< SIGSTOP = 17; (* sendable stop signal not from tty *)
< SIGTSTP = 18; (* stop signal from tty *)
< SIGCONT = 19; (* continue a stopped process *)
< SIGCHLD = 20; (* to parent on child stop or exit *)
< SIGTTIN = 21; (* to readers pgrp upon background tty read *)
< SIGTTOU = 22; (* like TTIN for output if (tp->t_local<OSTOP) *)
< SIGIO = 23; (* input/output possible signal *)
< SIGXCPU = 24; (* exceeded CPU time limit *)
< SIGXFSZ = 25; (* exceeded file size limit *)
< SIGVTALRM = 26; (* virtual time alarm *)
< SIGPROF = 27; (* profiling time alarm *)
< SIGWINCH = 28; (* window size changes *)
---
> SIGSTOP = 17; (* stop (cannot be caught or ignored) *)
> SIGTSTP = 18; (* interactive stop *)
> SIGCONT = 19; (* continue if stopped *)
> SIGCHLD = 20; (* sent to parent on child stop or exit *)
> SIGTTIN = 21; (* background read attempted from control terminal *)
> SIGTTOU = 22; (* background write attempted to control terminal *)
> SIGPOLL = 23; (* I/O possible, or completed *)
> SIGXCPU = 24; (* cpu time limit exceeded (see setrlimit()) *)
> SIGXFSZ = 25; (* file size limit exceeded (see setrlimit()) *)
> SIGVTALRM = 26; (* virtual time alarm (see setitimer) *)
> SIGPROF = 27; (* profiling time alarm (see setitimer) *)
> SIGWINCH = 28; (* window size changed *)
61,62c69,80
< SIGUSR1 = 30; (* User signal 1 (from SysV) *)
< SIGUSR2 = 31; (* User signal 2 (from SysV) *)
---
> SIGUSR1 = 30; (* user defined signal 1 *)
> SIGUSR2 = 31; (* user defined signal 2 *)
> SIGRESV = 32; (* reserved by Digital for future use *)
>
> (* additional signal names supplied for compatibility, only *)
> SIGIOINT = SIGURG; (* printer to backend error signal *)
> SIGIO = SIGPOLL; (* STREAMS version of this signal *)
> SIGAIO = SIGIO; (* base lan i/o *)
> SIGPTY = SIGIO; (* pty i/o *)
> SIGIOT = SIGABRT; (* abort (terminate) process *)
> SIGLOST = SIGIOT; (* old BSD signal ?? *)
> SIGPWR = SIGINFO; (* Power Fail/Restart -- SVID3/SVR4 *)
64d81
< (* System V definitions *)
66c83,87
< SIGABRT = SIGIOT;
---
>
> (* values of "how" argument to sigprocmask() call *)
> SIG_BLOCK = 1;
> SIG_UNBLOCK = 2;
> SIG_SETMASK = 3;
71,79c92,104
< SignalHandler =
< PROCEDURE (sig, code: int; scp: UNTRACED REF struct_sigcontext);
<
< sigset_t = int;
<
< struct_sigvec = RECORD
< sv_handler: SignalHandler; (* signal handler *)
< sv_mask: sigset_t; (* signal mask to apply *)
< sv_flags: int; (* see signal options below *)
---
> SignalHandler = PROCEDURE (sig: int;
> sip: UNTRACED REF siginfo_t;
> scp: UNTRACED REF struct_sigcontext);
>
> pid_t = int;
>
> sigset_t = unsigned_long;
>
> struct_sigaction = RECORD
> sa_handler : SignalHandler; (* signal handler *)
> sa_mask : sigset_t; (* signals to block while in handler *)
> sa_flags : int; (* signal action flags *)
> sa_signo : int; (* signal number *)
83,84c108,116
< empty_sigset_t : sigset_t = 0;
< empty_sv_mask : sigset_t = 0;
---
> (* valid flags define for sa_flag field of sigaction structure *)
> SA_ONSTACK = 16_0001; (* run on special signal stack *)
> SA_RESTART = 16_0002; (* restart system calls on sigs *)
> SA_NOCLDSTOP = 16_0004; (* do not set SIGCHLD for child stops *)
> SA_NODEFER = 16_0008; (* don't block while handling *)
> SA_RESETHAND = 16_0010; (* old sys5 style behavior *)
> SA_NOCLDWAIT = 16_0020; (* no zombies *)
> SA_SIGINFO = 16_0040; (* deliver siginfo to handler *)
> SA_CLDNOTIFY = 16_0080; (* deliver siginfo when exiting *)
86,95c118,121
< CONST
< SV_ONSTACK = 16_0001; (* take signal on signal stack *)
< SV_INTERRUPT = 16_0002; (* do not restart system on signal return *)
< SA_NOCLDSTOP = 16_0004; (* Don't generate SIGCLD when children stop *)
< SV_OLDSIG = 16_1000; (* Emulate old signal() for POSIX *)
<
< (* Defines for "how" argument of sigprocmask() call. POSIX. *)
< SIG_BLOCK = 1; (* Add these signals to block mask *)
< SIG_UNBLOCK = 2; (* Remove these signals from block mask *)
< SIG_SETMASK = 3; (* Set block mask to this mask *)
---
>
> (* Max siginfo size -- 128 bytes altogether (used to pad siginfo) *)
> SI_MAX_SIZE = 128;
> SI_PAD_SIZE = (SI_MAX_SIZE DIV BYTESIZE(int)) - 4;
98,100c124,128
< struct_sigstack = RECORD
< ss_sp: ADDRESS; (* signal stack pointer *)
< ss_onstack: int; (* current status *)
---
> siginfo_t = RECORD
> si_signo: int; (* signal number *)
> si_errno: int; (* error number *)
> si_code : int; (* signal code *)
> si_pad : ARRAY [1..SI_PAD_SIZE] OF int; (* reserve space for fields *)
103,115c131,137
< (*
< * Information pushed on stack when a signal is delivered.
< * This is used by the kernel to restore state following
< * execution of the signal handler. It is also made available
< * to the handler to allow it to properly restore state if
< * a non-standard exit is performed.
< *
< * WARNING: THE sigcontext MUST BE KEPT CONSISTENT WITH /usr/include/setjmp.h
< * AND THE LIBC ROUTINES setjmp() AND longjmp()
< *
< *)
< TYPE
< longV = ARRAY [0..31] OF long; (* room for 32 registers *)
---
> (* SIGILL, SIGFPE, SIGSEGV, SIGBUS *)
> siginfo_t_fault = RECORD
> si_signo: int; (* signal number *)
> si_errno: int; (* error number *)
> si_code : int; (* signal code *)
> si_addr : caddr_t; (* faulting instruction/memory ref. *)
> END;
117d138
< TYPE
119,152c140,164
< (*-----------------------------------------------------------------------
< * BEGIN REGION THAT MUST AGREE WITH jmp_buf REGION IN setjmp.h
< *)
< sc_onstack : long; (* sigstack state to restore *)
< sc_mask : long; (* signal mask to restore *)
< sc_pc : long; (* pc at time of signal *)
< sc_ps : long; (* psl to restore *)
<
< (*
< * General purpose registers
< *)
< sc_regs : longV; (* processor regs 0 to 31 *)
< sc_ownedfp : long; (* fp has been used *)
< sc_fpregs : longV; (* fp regs 0 to 31 *)
< sc_fpcr : unsigned_long; (* floating point control register *)
< sc_fp_control : unsigned_long; (* software fpcr *)
<
< (* END OF REGION THAT MUST AGREE WITH jmp_buf REGION IN setjmp.h
< -----------------------------------------------------------------------*)
<
< sc_reserved1 : long; (* reserved for kernel *)
< sc_kreserved1 : int; (* reserved for kernel *)
< sc_kreserved2 : int; (* reserved for kernel *)
<
< sc_ssize : Utypes.size_t; (* stack size *)
< sc_sbase : Utypes.caddr_t; (* stack start *)
<
< sc_traparg_a0 : unsigned_long; (* a0 argument to trap on exception *)
< sc_traparg_a1 : unsigned_long; (* a1 argument to trap on exception *)
< sc_traparg_a2 : unsigned_long; (* a2 argument to trap on exception *)
<
< sc_fp_trap_pc : unsigned_long; (* imprecise pc *)
< sc_fp_trigger_sum : unsigned_long; (* exception summary at trigger pc *)
< sc_fp_trigger_inst : unsigned_long; (* instruction at trigger pc *)
---
> sc_onstack : long; (* sigstack state to restore *)
> sc_mask : long; (* signal mask to restore *)
> sc_pc : long; (* pc at time of signal *)
> sc_ps : long; (* psl to restore *)
> sc_regs : ARRAY [0..31] OF long; (* processor regs 0 to 31 *)
> sc_ownedfp : long; (* fp has been used *)
> sc_fpregs : ARRAY [0..31] OF long; (* fp regs 0 to 31 *)
> sc_fpcr : unsigned_long; (* floating point control register *)
> sc_fp_control: unsigned_long; (* software fpcr *)
> sc_reserved1 : long; (* reserved for kernel *)
> sc_kreserved1: int; (* reserved for kernel *)
> sc_kreserved2: int; (* reserved for kernel *)
> sc_ssize : size_t; (* stack size *)
> sc_sbase : caddr_t; (* stack start *)
> sc_traparg_a0: unsigned_long; (* a0 argument to trap on exception *)
> sc_traparg_a1: unsigned_long; (* a1 argument to trap on exception *)
> sc_traparg_a2: unsigned_long; (* a2 argument to trap on exception *)
> sc_fp_trap_pc: unsigned_long; (* imprecise pc *)
> sc_fp_trigger_sum: unsigned_long; (* Exception summary at trigger pc *)
> sc_fp_trigger_inst: unsigned_long; (* Instruction at trigger pc *)
> END;
>
> struct_sigstack = RECORD
> ss_sp: ADDRESS; (* signal stack pointer *)
> ss_onstack: int; (* current status *)
155,156d166
< CONST
< R_SP = 30; (* index of stack pointer in sc_regs above *)
161,166c171
< BADSIG, SIG_ERR, SIG_DFL, SIG_IGN: SignalHandler;
<
<
< (* Convert a signal number to a mask suitable for sigblock(). *)
< <*INLINE*>
< PROCEDURE sigmask (n: int): int;
---
> BADSIG, SIG_ERR, SIG_DFL, SIG_IGN, SIG_HOLD, SIG_CATCH: SignalHandler;
172c177
< PROCEDURE kill (pid, sig: int): int;
---
> PROCEDURE kill (pid: pid_t; sig: int): int;
178c183
< PROCEDURE killpg (pgrp, sig: int): int;
---
> PROCEDURE killpg (pgrp: pid_t; sig: int): int;
181c186
< (*** sigblock(2) - block signals ***)
---
> (*** sigaction(2) - Specifies the action to take upon delivery of a signal ***)
184c189,191
< PROCEDURE sigblock (mask: int): int;
---
> PROCEDURE sigaction (sig: int;
> READONLY new: struct_sigaction;
> VAR old: struct_sigaction): int;
187,188c194
< (*** sigpause(2) - atomically release blocked signals and wait for
< interrupt ***)
---
> (*** sigprocmask(2) - Sets the current signal mask ***)
191c197,199
< PROCEDURE sigpause (sigmask: int): int;
---
> PROCEDURE sigprocmask (how: int;
> READONLY new: sigset_t;
> old: UNTRACED REF sigset_t := NIL): int;
194c202,203
< (*** sigpending(2) - examine pending signals ***)
---
> (*** sigsuspend(2) - Atomically changes the set of blocked signals and waits
> for a signal ***)
197c206
< PROCEDURE sigpending (VAR set: sigset_t): int;
---
> PROCEDURE sigsuspend (READONLY mask: sigset_t): int;
200c209
< (*** sigsetmask(2) - set current signal mask ***)
---
> (*** sigpending(2) - Examines pending signals ***)
203c212,213
< PROCEDURE sigsetmask (mask: int): int;
---
> PROCEDURE sigpending (VAR set: sigset_t): int;
>
204a215,216
> (*** sigemptyset, sigfillset, sigaddset, sigdelset, sigismember(3) - Creates
> and manipulates signal masks ***)
206c218,219
< (*** sigstack(2) - set and/or get signal stack context ***)
---
> <*EXTERNAL*>
> PROCEDURE sigemptyset (VAR set: sigset_t): int;
209c222
< PROCEDURE sigstack (VAR ss, oss: struct_sigstack): int;
---
> PROCEDURE sigfillset (VAR set: sigset_t): int;
210a224,225
> <*EXTERNAL*>
> PROCEDURE sigaddset (VAR set: sigset_t; signo: int): int;
212c227,228
< (*** sigvec(2) - software signal facilities ***)
---
> <*EXTERNAL*>
> PROCEDURE sigdelset (VAR set: sigset_t; signo: int): int;
215c231
< PROCEDURE sigvec (sig: int; VAR vec, ovec: struct_sigvec): int;
---
> PROCEDURE sigismember (VAR set: sigset_t; signo: int): int;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/osf-1.ALPHA_OSF/Usignal.m3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/osf-1.ALPHA_OSF/Usignal.m3
9,12d8
< IMPORT Word, Ctypes;
< FROM Ctypes IMPORT int;
<
< PROCEDURE sigmask (n: int): int =
14,21c10,15
< RETURN Word.Shift (1, n-1);
< END sigmask;
<
< BEGIN
< BADSIG := LOOPHOLE (-1, SignalHandler);
< SIG_ERR := LOOPHOLE (-1, SignalHandler);
< SIG_DFL := LOOPHOLE ( 0, SignalHandler);
< SIG_IGN := LOOPHOLE ( 1, SignalHandler);
---
> BADSIG := LOOPHOLE (-1, SignalHandler);
> SIG_ERR := LOOPHOLE (-1, SignalHandler);
> SIG_DFL := LOOPHOLE ( 0, SignalHandler);
> SIG_IGN := LOOPHOLE ( 1, SignalHandler);
> SIG_HOLD := LOOPHOLE ( 2, SignalHandler);
> SIG_CATCH := LOOPHOLE ( 3, SignalHandler);
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/osf-1.generic/Uresource.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/osf-1.generic/Uresource.i3
90c90
< <*EXTERNAL*> PROCEDURE getrusage (who: int; rus: struct_rusage_star): int;
---
> <*EXTERNAL*> PROCEDURE getrusage (who: int; VAR rus: struct_rusage): int;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/solaris-2-x/Uresource.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/solaris-2-x/Uresource.i3
87c87
< <*EXTERNAL*> PROCEDURE getrusage (who: int; rus: struct_rusage_star): int;
---
> <*EXTERNAL*> PROCEDURE getrusage (who: int; VAR rus: struct_rusage): int;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/sunos-4-x/Uresource.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/sunos-4-x/Uresource.i3
85c85
< <*EXTERNAL*> PROCEDURE getrusage (who: int; rus: struct_rusage_star): int;
---
> <*EXTERNAL*> PROCEDURE getrusage (who: int; VAR rus: struct_rusage): int;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/sysv-4.0/Uresource.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/sysv-4.0/Uresource.i3
87c87
< <*EXTERNAL*> PROCEDURE getrusage (who: int; rus: struct_rusage_star): int;
---
> <*EXTERNAL*> PROCEDURE getrusage (who: int; VAR rus: struct_rusage): int;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/unix/ultrix-3-1.generic/Uresource.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/unix/ultrix-3-1.generic/Uresource.i3
85c85
< <*EXTERNAL*> PROCEDURE getrusage (who: int; rus: struct_rusage_star): int;
---
> <*EXTERNAL*> PROCEDURE getrusage (who: int; VAR rus: struct_rusage): int;
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/m3core/src/weakref/WeakRef.i3 Persistent_M3/pm3-1.1.15-unpacked/libs/m3core/src/weakref/WeakRef.i3
79a80,81
> CONST Brand = "WeakRef";
>
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/set/src/m3makefile Persistent_M3/pm3-1.1.15-unpacked/libs/set/src/m3makefile
16,19d15
< MkSet("Atom", "Atom")
< MkSetDef("Atom", "Atom")
< MkSetList("Atom", "Atom")
<
23a20,23
> MkTransientSet("Int", "Integer")
> MkTransientSetDef("Int", "Integer")
> MkTransientSetList("Int", "Integer")
>
27a28,31
> MkTransientSet("Text", "Text")
> MkTransientSetDef("Text", "Text")
> MkTransientSetList("Text", "Text")
>
29a34,36
>
> MkTransientSet("Ref", "RefanyTransient")
> MkTransientSetList("Ref", "RefanyTransient")
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/set/src/SetDef.mg Persistent_M3/pm3-1.1.15-unpacked/libs/set/src/SetDef.mg
6,7c6,7
< GENERIC MODULE SetDef(Elem, ElemSet, ElemRefTable);
< (* WHERE "ElemSet = Set(Elem)" and "ElemRefTable = Table(Elem, Refany)". *)
---
> GENERIC MODULE SetDef(Elem, ElemSet, ElemRefTable, Ref);
> (* WHERE "ElemSet = Set(Elem)" and "ElemRefTable = Table(Elem, Ref)". *)
55c55
< VAR dummy: REFANY; BEGIN
---
> VAR dummy: Ref.T; BEGIN
63c63
< VAR dummy: REFANY; BEGIN
---
> VAR dummy: Ref.T; BEGIN
110c110
< dummy: REFANY;
---
> dummy: Ref.T;
129c129
< VAR dummy: REFANY; BEGIN
---
> VAR dummy: Ref.T; BEGIN
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/set/src/Set.ig Persistent_M3/pm3-1.1.15-unpacked/libs/set/src/Set.ig
9c9
< GENERIC INTERFACE Set(Elem);
---
> GENERIC INTERFACE Set(Super, Elem);
28c28
< Public = OBJECT METHODS
---
> Public = Super.T OBJECT METHODS
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/set/src/set.tmpl Persistent_M3/pm3-1.1.15-unpacked/libs/set/src/set.tmpl
12c12
< readonly proc MkSet (nm, elem) is
---
> readonly proc MkSet(nm, elem) is
14c14
< build_generic_intf (set, "Set", [elem], VISIBLE)
---
> build_generic_intf (set, "Set", ["Root", elem], VISIBLE)
18c18
< readonly proc mkSet (nm, elem) is
---
> readonly proc mkSet(nm, elem) is
20c20,32
< build_generic_intf (set, "Set", [elem], HIDDEN)
---
> build_generic_intf (set, "Set", ["Root", elem], HIDDEN)
> build_generic_impl (set, "Set", [elem])
> end
>
> readonly proc MkTransientSet(nm, elem) is
> local set = nm & "TransientSet"
> build_generic_intf (set, "Set", ["RootTransient", elem], VISIBLE)
> build_generic_impl (set, "Set", [elem])
> end
>
> readonly proc mkTransientSet(nm, elem) is
> local set = nm & "TransientSet"
> build_generic_intf (set, "Set", ["RootTransient", elem], HIDDEN)
33c45
< build_generic_impl (setDef, "SetDef", [elem, set, elemRefTbl])
---
> build_generic_impl (setDef, "SetDef", [elem, set, elemRefTbl, "Refany"])
41c53,69
< build_generic_impl (setDef, "SetDef", [elem, set, elemRefTbl])
---
> build_generic_impl (setDef, "SetDef", [elem, set, elemRefTbl, "Refany"])
> end
>
> readonly proc MkTransientSetDef (nm, elem) is
> local set = nm & "TransientSet"
> local setDef = nm & "TransientSetDef"
> local elemRefTbl = nm & "RefTransientTbl"
> build_generic_intf (setDef, "SetDef", [set], VISIBLE)
> build_generic_impl (setDef, "SetDef", [elem, set, elemRefTbl, "RefanyTransient"])
> end
>
> readonly proc mkTransientSetDef (nm, elem) is
> local set = nm & "TransientSet"
> local setDef = nm & "TransientSetDef"
> local elemRefTbl = nm & "RefTransientTbl"
> build_generic_intf (setDef, "SetDef", [set], HIDDEN)
> build_generic_impl (setDef, "SetDef", [elem, set, elemRefTbl, "RefanyTransient"])
59a88,103
> build_generic_intf (setList, "SetList", [set], HIDDEN)
> build_generic_impl (setList, "SetList", [elem, set, elemList])
> end
>
> readonly proc MkTransientSetList (nm, elem) is
> local set = nm & "TransientSet"
> local setList = nm & "TransientSetList"
> local elemList = nm & "TransientList"
> build_generic_intf (setList, "SetList", [set], VISIBLE)
> build_generic_impl (setList, "SetList", [elem, set, elemList])
> end
>
> readonly proc mkTransientSetList (nm, elem) is
> local set = nm & "TransientSet"
> local setList = nm & "TransientSetList"
> local elemList = nm & "TransientList"
diff -r PolyMTL/pm3-1.1.15-unpacked/libs/sortedtableextras/src/m3makefile Persistent_M3/pm3-1.1.15-unpacked/libs/sortedtableextras/src/m3makefile
7d6
< m3_option ("-O") % compile optimized code
40,49c39,48
< if (AT_SRC)
< include ("tex.quake")
< local_frag ("Intro")
< local_ig ("RedBlackTbl")
< local_ig ("SkipListTbl")
< local_frag ("Memory")
< local_frag ("Performance")
< local_frag ("Conclusions")
< Document ("SortedTableExtras")
< end
---
> %if (AT_SRC)
> % include ("tex.quake")
> % local_frag ("Intro")
> % local_ig ("RedBlackTbl")
> % local_ig ("SkipListTbl")
> % local_frag ("Memory")
> % local_frag ("Performance")
> % local_frag ("Conclusions")
> % Document ("SortedTableExtras")
> %end
Only in Persistent_M3/pm3-1.1.15-unpacked/libs/sortedtableextras/src: SortedTableExtras.pdf
diff -r PolyMTL/pm3-1.1.15-unpacked/m3config/src/SOLgnu Persistent_M3/pm3-1.1.15-unpacked/m3config/src/SOLgnu
29a30
> SONAME_OPTION = ["-h"]
diff -r PolyMTL/pm3-1.1.15-unpacked/m3config/src/SOLsun Persistent_M3/pm3-1.1.15-unpacked/m3config/src/SOLsun
29a30
> SONAME_OPTION = ["-h"]
Only in Persistent_M3/pm3-1.1.15-unpacked/m3config/src: VERSION
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/NetObjMon.i3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/NetObjMon.i3
12c12
< IMPORT NetObj, RefList, Thread;
---
> IMPORT NetObj, RefTransientList AS RefList, Thread;
20c20
< dump (): REFANY (* NGCMonitor.Dump *)
---
> dump (): <*TRANSIENT*> REFANY (* NGCMonitor.Dump *)
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/NetObjMon.m3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/NetObjMon.m3
10c10,11
< IMPORT NetObj, NGCMonitor, Fmt, Params, Process, RefList, Thread;
---
> IMPORT NetObj, NGCMonitor, Fmt, Params, Process, RefTransientList AS RefList,
> Thread;
32c33
< PROCEDURE Dump(<*UNUSED*>m: TT) : REFANY =
---
> PROCEDURE Dump(<*UNUSED*>m: TT) : <*TRANSIENT*> REFANY =
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/NetObjMon_T_v1.i3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/NetObjMon_T_v1.i3
6c6
< IMPORT RefList, Wr, Thread, StubLib, NetObj, Rd, NetObjMon;
---
> IMPORT RefTransientList AS RefList, Wr, Thread, StubLib, NetObj, Rd, NetObjMon;
14,15c14,15
< PROCEDURE Surrogate_dump(self: NetObjMon.T): REFANY RAISES {NetObj.Error,
< Thread.Alerted};
---
> PROCEDURE Surrogate_dump(self: NetObjMon.T): <*TRANSIENT*> REFANY
> RAISES {NetObj.Error, Thread.Alerted};
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/NetObjMon_T_v1.m3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/NetObjMon_T_v1.m3
6c6
< IMPORT RefList, Wr, Thread, StubLib, NetObj, Rd, NetObjMon;
---
> IMPORT RefTransientList AS RefList, Wr, Thread, StubLib, NetObj, Rd, NetObjMon;
13,14c13,14
< PROCEDURE Surrogate_dump(self: NetObjMon.T): REFANY RAISES {NetObj.Error,
< Thread.Alerted} =
---
> PROCEDURE Surrogate_dump(self: NetObjMon.T): <*TRANSIENT*> REFANY
> RAISES {NetObj.Error, Thread.Alerted} =
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/AgentStubs.m3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/AgentStubs.m3
240c240
< varVList: REF VersionList;
---
> varVList: <*TRANSIENT*> REF VersionList;
247c247
< varVList := NEW(REF VersionList, inVListLen);
---
> varVList := NEW(<*TRANSIENT*> REF VersionList, inVListLen);
276c276
< varBatch: REF CleanBatch;
---
> varBatch: <*TRANSIENT*> REF CleanBatch;
281c281
< varBatch := NEW(REF CleanBatch, inBatchLen);
---
> varBatch := NEW(<*TRANSIENT*> REF CleanBatch, inBatchLen);
Only in PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt: DirtyTbl.i3
Only in PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt: DirtyTbl.m3
Only in PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt: FPRefTbl.i3
Only in PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt: FPRefTbl.m3
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/m3makefile Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/m3makefile
36,38c36,38
< module ("ObjTbl")
< module ("DirtyTbl")
< module ("FPRefTbl")
---
> transientTable ("Obj", "WireRep", "ObjElem")
> transientTable ("Dirty", "WireRep", "DirtyElem")
> transientTable ("FPRef", "Fingerprint", "RefanyTransient")
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/NetObj.i3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/NetObj.i3
60,61c60,61
< T <: ROOT;
< Address <: REFANY;
---
> T <: <*TRANSIENT*> ROOT;
> Address <: <*TRANSIENT*> REFANY;
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/NetObjNotifier.i3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/NetObjNotifier.i3
21c21
< NotifierClosure = OBJECT METHODS
---
> NotifierClosure = <*TRANSIENT*> ROOT OBJECT METHODS
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/NetObjRep.i3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/NetObjRep.i3
14c14
< NetObj.T = BRANDED "NetObj.T" OBJECT
---
> NetObj.T = <*TRANSIENT*> ROOT BRANDED "NetObj.T" OBJECT
16c16
< r: REFANY;
---
> r: <*TRANSIENT*> REFANY;
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/NetObjRT.m3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/NetObjRT.m3
17,19c17,19
< IMPORT IntRefTbl, TextRefTbl, ObjTbl, ObjElem,
< FPRefTbl, DirtyTbl, DirtyElem;
< IMPORT Thread, RefList;
---
> IMPORT IntRefTransientTbl AS IntRefTbl, TextRefTransientTbl AS TextRefTbl,
> ObjTbl, ObjElem, FPRefTbl, DirtyTbl, DirtyElem;
> IMPORT Thread, RefTransientList AS RefList;
58c58
< TypeInfo = REF RECORD
---
> TypeInfo = <*TRANSIENT*> REF RECORD
108c108
< Notifier = REF RECORD
---
> Notifier = <*TRANSIENT*> REF RECORD
138c138
< locs: REF ARRAY OF Transport.Location := NIL;
---
> locs: <*TRANSIENT*> REF ARRAY OF Transport.Location := NIL;
150c150
< ExportInfo = BRANDED OBJECT
---
> ExportInfo = <*TRANSIENT*> ROOT BRANDED OBJECT
265c265
< VAR r: REFANY; loc: Transport.Location;
---
> VAR r: <*TRANSIENT*> REFANY; loc: Transport.Location;
409c409
< CleanQElem = REF RECORD
---
> CleanQElem = <*TRANSIENT*> REF RECORD
501c501
< r: REFANY;
---
> r: <*TRANSIENT*> REFANY;
526c526
< r: REFANY;
---
> r: <*TRANSIENT*> REFANY;
581c581
< VAR r: REFANY;
---
> VAR r: <*TRANSIENT*> REFANY;
604c604
< VAR r: REFANY;
---
> VAR r: <*TRANSIENT*> REFANY;
644c644
< VAR r: REFANY; res: ExportInfo;
---
> VAR r: <*TRANSIENT*> REFANY; res: ExportInfo;
694c694
< name: TEXT;
---
> <*TRANSIENT*> name: TEXT;
701c701
< VAR r: REFANY;
---
> VAR r: <*TRANSIENT*> REFANY;
712c712
< VAR r: REFANY;
---
> VAR r: <*TRANSIENT*> REFANY;
733c733
< VAR r: REFANY;
---
> VAR r: <*TRANSIENT*> REFANY;
754c754
< rti: REFANY := NIL;
---
> rti: <*TRANSIENT*> REFANY := NIL;
959c959
< key: TEXT; r: REFANY;
---
> key: TEXT; r: <*TRANSIENT*> REFANY;
997c997
< locTbl.locs := NEW(REF ARRAY OF Transport.Location, 10);
---
> locTbl.locs := NEW(<*TRANSIENT*> REF ARRAY OF Transport.Location, 10);
1003c1003,1004
< locTbl.locs := NEW(REF ARRAY OF Transport.Location, NUMBER(ol^) * 2);
---
> locTbl.locs := NEW(<*TRANSIENT*> REF ARRAY OF Transport.Location,
> NUMBER(ol^) * 2);
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/NGCMonitor.i3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/NGCMonitor.i3
12c12
< IMPORT WireRep, DirtyElem, Fingerprint, Transport, RefList;
---
> IMPORT WireRep, DirtyElem, Fingerprint, Transport, RefTransientList AS RefList;
18c18
< Dump = REF RECORD
---
> Dump = <*TRANSIENT*> REF RECORD
24c24
< ODump = OBJECT
---
> ODump = <*TRANSIENT*> ROOT OBJECT
27c27
< typeName: TEXT;
---
> <*TRANSIENT*> typeName: TEXT;
35c35
< owner: Transport.Endpoint;
---
> <*TRANSIENT*> owner: Transport.Endpoint;
38,40c38,40
< LDump = REF RECORD
< info: TEXT;
< ep: Transport.Endpoint;
---
> LDump = <*TRANSIENT*> REF RECORD
> <*TRANSIENT*> info: TEXT;
> <*TRANSIENT*> ep: Transport.Endpoint;
44c44
< DDump = REF RECORD
---
> DDump = <*TRANSIENT*> REF RECORD
49,50c49,50
< NDump = REF RECORD
< name: TEXT; (* in export table *)
---
> NDump = <*TRANSIENT*> REF RECORD
> <*TRANSIENT*> name: TEXT; (* in export table *)
Only in PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt: ObjTbl.i3
Only in PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt: ObjTbl.m3
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/SpecialObj.i3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/SpecialObj.i3
21c21
< FpTower = REF ARRAY OF Fingerprint.T;
---
> FpTower = <*TRANSIENT*> REF ARRAY OF Fingerprint.T;
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/StubConn.i3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/StubConn.i3
32c32
< Public = OBJECT rd: MsgRd.T; wr: MsgWr.T END;
---
> Public = <*TRANSIENT*> ROOT OBJECT rd: MsgRd.T; wr: MsgWr.T END;
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/StubLib.i3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/StubLib.i3
53c53
< Conn <: ROOT;
---
> Conn <: <*TRANSIENT*> ROOT;
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/StubLib.m3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/StubLib.m3
29c29
< objs: REF ARRAY OF NetObj.T := NIL;
---
> objs: <*TRANSIENT*> REF ARRAY OF NetObj.T := NIL;
643c643
< stream: REFANY;
---
> stream: <*TRANSIENT*> REFANY;
760c760
< s := NEW(REF ARRAY OF NetObj.T, DefaultObjStackSize);
---
> s := NEW(<*TRANSIENT*> REF ARRAY OF NetObj.T, DefaultObjStackSize);
763c763
< s := NEW(REF ARRAY OF NetObj.T, 2 * c.objStack.pos);
---
> s := NEW(<*TRANSIENT*> REF ARRAY OF NetObj.T, 2 * c.objStack.pos);
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/StubProt.m3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/StubProt.m3
30c30
< objs: REF ARRAY OF NetObj.T := NIL;
---
> objs: <*TRANSIENT*> REF ARRAY OF NetObj.T := NIL;
215c215
< VAR s: REF ARRAY OF NetObj.T;
---
> VAR s: <*TRANSIENT*> REF ARRAY OF NetObj.T;
223c223
< s := NEW(REF ARRAY OF NetObj.T, DefaultObjStackSize);
---
> s := NEW(<*TRANSIENT*> REF ARRAY OF NetObj.T, DefaultObjStackSize);
226c226
< s := NEW(REF ARRAY OF NetObj.T, 2 * c.objStack.pos);
---
> s := NEW(<*TRANSIENT*> REF ARRAY OF NetObj.T, 2 * c.objStack.pos);
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/Transport.i3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/Transport.i3
21c21
< Public = OBJECT METHODS
---
> Public = <*TRANSIENT*> ROOT OBJECT METHODS
29c29
< LocationP = OBJECT METHODS
---
> LocationP = <*TRANSIENT*> ROOT OBJECT METHODS
39c39
< NetObj.Address = BRANDED REF ARRAY OF Endpoint;
---
> NetObj.Address = <*TRANSIENT*> BRANDED REF <*TRANSIENT*> ARRAY OF Endpoint;
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/TransportRegistry.i3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/netobjrt/TransportRegistry.i3
34c34
< IteratorPublic = OBJECT METHODS
---
> IteratorPublic = <*TRANSIENT*> ROOT OBJECT METHODS
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobj/src/tcpnetobj/TCPNetObj.m3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobj/src/tcpnetobj/TCPNetObj.m3
12c12,13
< IMPORT AtomList, Convert, Fmt, TextRefTbl, Thread, Text, Time;
---
> IMPORT AtomList, Convert, Fmt, TextRefTransientTbl AS TextRefTbl, Thread,
> Text, Time;
49c50
< e: Transport.Endpoint;
---
> <*TRANSIENT*> e: Transport.Endpoint;
94c95
< WR = REF WeakRef.T;
---
> WR = <*TRANSIENT*> REF WeakRef.T;
154c155
< VAR r: REFANY;
---
> VAR r: <*TRANSIENT*> REFANY;
182c183
< x: REFANY;
---
> x: <*TRANSIENT*> REFANY;
216c217
< r: REFANY;
---
> r: <*TRANSIENT*> REFANY;
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/netobjd/src/NMonRegistrySvr.m3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/netobjd/src/NMonRegistrySvr.m3
13c13
< IMPORT TextRefTbl;
---
> IMPORT TextRefTransientTbl AS TextRefTbl;
30c30
< id: TEXT;
---
> <*TRANSIENT*> id: TEXT;
43c43
< VAR r: REFANY;
---
> VAR r: <*TRANSIENT*> REFANY;
68c68
< r: REFANY;
---
> r: <*TRANSIENT*> REFANY;
79c79
< res: REFANY;
---
> res: <*TRANSIENT*> REFANY;
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/stubgen/src/CodeForType.i3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/stubgen/src/CodeForType.i3
12c12
< IMPORT Atom, Formatter, AtomRefTbl, StubCode, Type;
---
> IMPORT Atom, Formatter, AtomRefTransientTbl AS AtomRefTbl, StubCode, Type;
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/stubgen/src/CodeForType.m3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/stubgen/src/CodeForType.m3
12,13c12,13
< IMPORT Atom, Fmt, Formatter, AtomRefTbl, StubCode, StubUtils,
< Text, Type, Value, ValueProc, Wr;
---
> IMPORT Atom, Fmt, Formatter, AtomRefTransientTbl AS AtomRefTbl, StubCode,
> StubUtils, Text, Type, Value, ValueProc, Wr;
387c387
< VAR key: Atom.T; value: REFANY;
---
> VAR key: Atom.T; value: <*TRANSIENT*> REFANY;
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/stubgen/src/IntfStubCode.i3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/stubgen/src/IntfStubCode.i3
12c12
< IMPORT Atom, Formatter, Type, AtomRefTbl, StubCode;
---
> IMPORT Atom, Formatter, Type, AtomRefTransientTbl AS AtomRefTbl, StubCode;
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/stubgen/src/IntfStubCode.m3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/stubgen/src/IntfStubCode.m3
12,13c12,13
< IMPORT Atom, CodeForType, Formatter, AtomRefTbl, StubCode,
< StubUtils, Type, Wr;
---
> IMPORT Atom, CodeForType, Formatter, AtomRefTransientTbl AS AtomRefTbl,
> StubCode, StubUtils, Type, Wr;
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/stubgen/src/ModuleStubCode.i3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/stubgen/src/ModuleStubCode.i3
11c11,12
< IMPORT Atom, Formatter, RefList, AtomRefTbl, StubCode, StubUtils, Type;
---
> IMPORT Atom, Formatter, RefList, AtomRefTransientTbl AS AtomRefTbl, StubCode,
> StubUtils, Type;
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/stubgen/src/ModuleStubCode.m3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/stubgen/src/ModuleStubCode.m3
12c12,13
< IMPORT Atom, CodeForType, Fmt, Formatter, RefList, Protocol, AtomRefTbl,
---
> IMPORT Atom, CodeForType, Fmt, Formatter, RefList, Protocol,
> AtomRefTransientTbl AS AtomRefTbl,
diff -r PolyMTL/pm3-1.1.15-unpacked/network/netobjects/stubgen/src/StubCode.m3 Persistent_M3/pm3-1.1.15-unpacked/network/netobjects/stubgen/src/StubCode.m3
13c13,14
< ModuleStubCode, OSError, Protocol, AtomRefTbl, StubUtils, Type, Wr;
---
> ModuleStubCode, OSError, Protocol, AtomRefTransientTbl AS AtomRefTbl,
> StubUtils, Type, Wr;
diff -r PolyMTL/pm3-1.1.15-unpacked/network/tcplibs/tcp/src/common/ConnMsgRW.m3 Persistent_M3/pm3-1.1.15-unpacked/network/tcplibs/tcp/src/common/ConnMsgRW.m3
126c126
< buff := NEW(REF ARRAY OF CHAR, BufferSize),
---
> buff := NEW(<*TRANSIENT*> REF ARRAY OF CHAR, BufferSize),
139c139
< buff := NEW(REF ARRAY OF CHAR, BufferSize),
---
> buff := NEW(<*TRANSIENT*> REF ARRAY OF CHAR, BufferSize),
206c206
< buff: REF ARRAY OF CHAR) : INTEGER
---
> buff: <*TRANSIENT*> REF ARRAY OF CHAR) : INTEGER
diff -r PolyMTL/pm3-1.1.15-unpacked/network/tcplibs/tcp/src/common/ConnRW.m3 Persistent_M3/pm3-1.1.15-unpacked/network/tcplibs/tcp/src/common/ConnRW.m3
34c34
< buff := NEW(REF ARRAY OF CHAR, BufferSize),
---
> buff := NEW(<*TRANSIENT*> REF ARRAY OF CHAR, BufferSize),
47c47
< buff := NEW(REF ARRAY OF CHAR, BufferSize),
---
> buff := NEW(<*TRANSIENT*> REF ARRAY OF CHAR, BufferSize),
diff -r PolyMTL/pm3-1.1.15-unpacked/network/tcplibs/tcp/src/common/TCP.i3 Persistent_M3/pm3-1.1.15-unpacked/network/tcplibs/tcp/src/common/TCP.i3
31c31
< Connector <: ROOT;
---
> Connector <: <*TRANSIENT*> ROOT;
diff -r PolyMTL/pm3-1.1.15-unpacked/network/www/webvbt/src/HTMLVBTGRep.i3 Persistent_M3/pm3-1.1.15-unpacked/network/www/webvbt/src/HTMLVBTGRep.i3
12c12
< HeaderBox <: ROOT;
---
> HeaderBox <: <*TRANSIENT*> ROOT;
diff -r PolyMTL/pm3-1.1.15-unpacked/README Persistent_M3/pm3-1.1.15-unpacked/README
1c1,5
< The Polytechnique Montreal Distribution of Modula-3
---
> The PM3 Distribution of orthogonal persistence for Modula-3.
>
> PM3 version 1.1.15 dated Wed Nov 14 01:38:45 EST 2001
>
> based on
5,9c9,18
< This distribution is based on the DEC SRC Modula-3 release 3.6. Local
< enhancements by Louis Dubeau, Jerome Collin and myself (Michel Dagenais)
< were added, and several packages (libraries, programs, and documentation)
< from other sources were added as well. The online documentation may be
< accessed before the build by pointing your favourite WWW browser to
---
> This distribution is based on the Polytechnique Montreal Distribution of
> Modula-3, with local enhancements by Antony Hosking, Jiawan Chen and Adam
> Welc, plus packages (libraries, programs and documentation) from other
> sources.
>
> The Polytechnique Montreal Distribution of Modula-3 is based on DEC SRC
> Modula-3 release 3.6. Local enhancements by Louis Dubeau, Jerome Collin and
> Michel Dagenais were added, and several packages (libraries, programs, and
> documentation) from other sources were added as well. The online documentation
> may be accessed before the build by pointing your favourite WWW browser to
diff -r PolyMTL/pm3-1.1.15-unpacked/src/m3makefile Persistent_M3/pm3-1.1.15-unpacked/src/m3makefile
226a227
> if defined("SHORE") capabilities{"SHORE"} = "" end
diff -r PolyMTL/pm3-1.1.15-unpacked/src/PACKAGES Persistent_M3/pm3-1.1.15-unpacked/src/PACKAGES
161a162,173
> PkgInfo("bag","libs","","bag",tLib,"T",3,[],["ALL"],[],
> "A simple, generic Bag interface.")
>
> PkgInfo("libpm3common","database/persistence","","pm3",tLib,"T",3,[],["ALL"],
> [],"ODMG-style interface for orthogonal persistence")
>
> PkgInfo("m3shore","database/persistence","","pm3",tLib,"T",3,[],["ALL"],
> ["SHORE"],"Persistent Modula-3 interface to the Shore object store")
>
> PkgInfo("libpm3shore","database/persistence","","pm3",tLib,"T",3,[],["ALL"],
> ["SHORE"],"libpm3 implementation using SHORE")
>
200a213,242
>
> PkgInfo("daemon","database/GRAS3/Tools","","pm3",tLib,"T",3,[],["ALL"],[],
> "Basic procedure to fork daemon processes")
>
> PkgInfo("GrasCommon","database/GRAS3","","pm3",tLib,"T",3,[],["ALL"],[],
> "Common GRAS3 library components")
>
> PkgInfo("GrasParams","database/GRAS3/Tools","","pm3",tLib,"T",3,[],["ALL"],[],
> "Utilities for reading GRAS3 configuration options")
>
> PkgInfo("PageServer","database/GRAS3","","pm3",tProg,"T",3,[],["ALL"],[],
> "GRAS3 transactional page server")
>
> PkgInfo("RuleEngine","database/GRAS3","","pm3",tLib,"T",3,[],["ALL"],[],
> "GRAS3 rule engine")
>
> PkgInfo("PageClient","database/GRAS3","","pm3",tLib,"T",3,[],["ALL"],[],
> "GRAS3 client interface to the transactional page server")
>
> PkgInfo("ServerShutdown","database/GRAS3","","pm3",tProg,"T",3,[],["ALL"],[],
> "Shut down idle page server")
>
> PkgInfo("GrasNameServer","database/GRAS3","","pm3",tProg,"T",3,[],["ALL"],[],
> "GRAS3 name server")
>
> PkgInfo("libpm3","database/persistence","","pm3",tLib,"T",3,[],["ALL"],[],
> "Default libpm3 implementation using GRAS3")
>
> PkgInfo("primes","database/persistence","","pm3",tProg,"T",3,[],["ALL"],[],
> "A simple persistent application that generates prime numbers")
diff -r PolyMTL/pm3-1.1.15-unpacked/text/sgmltools/sgml/src/dtd/HTML4.dtd Persistent_M3/pm3-1.1.15-unpacked/text/sgmltools/sgml/src/dtd/HTML4.dtd
11c11
< Draft: $Date: 1998/01/17 14:26:50 $
---
> Draft: $Date: 1998/10/28 21:41:53 $
diff -r PolyMTL/pm3-1.1.15-unpacked/text/sgmltools/sgmlconv/src/Main.m3 Persistent_M3/pm3-1.1.15-unpacked/text/sgmltools/sgmlconv/src/Main.m3
25,26c25,27
< TextWr, TextRd, Fmt, Lex, OSError, FileRd, FileWr, TextSeq, IntSeq,
< Pathname, Process, FS, File, RegularFile;
---
> TextWr, TextRd, Fmt, Lex, OSError, FileRd, FileWr,
> TextTransientSeq AS TextSeq, IntSeq, Pathname, Process, FS, File,
> RegularFile;
diff -r PolyMTL/pm3-1.1.15-unpacked/text/sgmltools/sgmllinear/src/Main.m3 Persistent_M3/pm3-1.1.15-unpacked/text/sgmltools/sgmllinear/src/Main.m3
28c28
< TextConv, TextSeq, TextTextTbl, TextWr, Pathname;
---
> TextConv, TextTransientSeq AS TextSeq, TextTextTbl, TextWr, Pathname;