From 2861f0a0ec0baaefef2b95cac2470175a01f2b97 Mon Sep 17 00:00:00 2001 From: Max Horn Date: Wed, 15 Jan 2020 15:58:23 +0100 Subject: [PATCH 01/19] kernel: add OBJ_FLAG_IMMUTABLE MakeImmutableNoRecurse sets the new flag in addition to the IMMUTABLE bit of the tnum, so that the code can move over to the flag before the bit goes away. The flag is only meant for lists, records, object sets and object maps; for other objects their type decides. Assisted-by: Claude Code (Opus 5.5) --- src/objects.h | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/objects.h b/src/objects.h index f8145453b1..efc1f372a5 100644 --- a/src/objects.h +++ b/src/objects.h @@ -326,6 +326,11 @@ enum { #ifdef HPCGAP OBJ_FLAG_TESTED = (1 << 1), #endif + + // OBJ_FLAG_IMMUTABLE marks immutable objects with a tnum between + // FIRST_IMM_MUT_TNUM and LAST_IMM_MUT_TNUM. For any other object it + // has no meaning, see IS_MUTABLE_OBJ. + OBJ_FLAG_IMMUTABLE = (1 << 2), }; @@ -528,6 +533,7 @@ EXPORT_INLINE void MakeImmutableNoRecurse(Obj obj) UInt type = TNUM_OBJ(obj); GAP_ASSERT((FIRST_IMM_MUT_TNUM <= type) && (type <= LAST_IMM_MUT_TNUM)); RetypeBag(obj, type | IMMUTABLE); + SET_OBJ_FLAG(obj, OBJ_FLAG_IMMUTABLE); } From 81f6d2c892823e4d0f0ad28148b6b6878e74ce5c Mon Sep 17 00:00:00 2001 From: Max Horn Date: Sun, 6 Jan 2019 23:47:24 +0100 Subject: [PATCH 02/19] kernel: remove MakeBagTypePublic calls for IMMUTABLE tnums --- src/blister.c | 7 ------- src/plist.c | 6 ------ src/precord.c | 5 ----- src/range.c | 6 ------ src/stringobj.c | 3 --- 5 files changed, 27 deletions(-) diff --git a/src/blister.c b/src/blister.c index 995affab5e..4b8b10168a 100644 --- a/src/blister.c +++ b/src/blister.c @@ -1902,13 +1902,6 @@ static Int InitKernel ( } // Make immutable blists public -#ifdef HPCGAP - for ( t1 = T_BLIST; t1 <= T_BLIST_SSORT; t1 += 2 ) { - MakeBagTypePublic( t1 + IMMUTABLE ); - } -#endif - - // install the type methods TypeObjFuncs[ T_BLIST ] = TypeBlist; TypeObjFuncs[ T_BLIST +IMMUTABLE ] = TypeBlist; TypeObjFuncs[ T_BLIST_NSORT ] = TypeBlistNSort; diff --git a/src/plist.c b/src/plist.c index a96f0735e3..eac2a7d3b7 100644 --- a/src/plist.c +++ b/src/plist.c @@ -3588,12 +3588,6 @@ static Int InitKernel ( // mutable tables may have mutable rows MakeImmutableObjFuncs[T_PLIST_TAB] = MakeImmutablePlistInHom; -#ifdef HPCGAP - for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1 += 2 ) { - MakeBagTypePublic(t1 +IMMUTABLE); - } -#endif - return 0; } diff --git a/src/precord.c b/src/precord.c index 57b5b9dc58..e6c2239e68 100644 --- a/src/precord.c +++ b/src/precord.c @@ -794,11 +794,6 @@ static Int InitKernel ( InitMarkFuncBags( T_PREC , MarkPRecSubBags ); InitMarkFuncBags( T_PREC +IMMUTABLE , MarkPRecSubBags ); -#ifdef HPCGAP - // Immutable records are public - MakeBagTypePublic( T_PREC +IMMUTABLE ); -#endif - // init filters and functions InitHdlrFuncsFromTable( GVarFuncs ); diff --git a/src/range.c b/src/range.c index 02d0550400..290d9e2967 100644 --- a/src/range.c +++ b/src/range.c @@ -1142,12 +1142,6 @@ static Int InitKernel ( InitMarkFuncBags( T_RANGE_SSORT , MarkAllSubBags ); InitMarkFuncBags( T_RANGE_SSORT +IMMUTABLE , MarkAllSubBags ); -#ifdef HPCGAP - // Make immutable bags public - MakeBagTypePublic( T_RANGE_NSORT + IMMUTABLE ); - MakeBagTypePublic( T_RANGE_SSORT + IMMUTABLE ); -#endif - // install the type function ImportGVarFromLibrary( "TYPE_RANGE_NSORT_MUTABLE", &TYPE_RANGE_NSORT_MUTABLE ); diff --git a/src/stringobj.c b/src/stringobj.c index 8ed81dceab..044e7d1f37 100644 --- a/src/stringobj.c +++ b/src/stringobj.c @@ -2041,9 +2041,6 @@ static Int InitKernel ( } #ifdef HPCGAP - for ( t1 = T_STRING; t1 <= T_STRING_SSORT; t1 += 2 ) { - MakeBagTypePublic( t1 + IMMUTABLE ); - } MakeBagTypePublic(T_CHAR); #endif From 9bd966254597622a98d48d2cd1efff13bde985a2 Mon Sep 17 00:00:00 2001 From: Max Horn Date: Sun, 6 Jan 2019 23:47:24 +0100 Subject: [PATCH 03/19] kernel: remove IMMUTABLE from FiltListTNums handling --- src/lists.c | 41 ++++------------------------------------- src/modules.c | 6 ------ 2 files changed, 4 insertions(+), 43 deletions(-) diff --git a/src/lists.c b/src/lists.c index 9eeaf30344..90873da0ce 100644 --- a/src/lists.c +++ b/src/lists.c @@ -2416,12 +2416,11 @@ static Int CheckInit ( // fix unknown list types - for ( i = FIRST_LIST_TNUM; i <= LAST_LIST_TNUM; i +=2 ) { + for ( i = FIRST_LIST_TNUM; i <= LAST_LIST_TNUM; i++ ) { GAP_ASSERT( TNAM_TNUM(i) ); - GAP_ASSERT( TNAM_TNUM(i + IMMUTABLE) ); } - for (i = FIRST_LIST_TNUM; i <= LAST_LIST_TNUM; i += 2) { + for (i = FIRST_LIST_TNUM; i <= LAST_LIST_TNUM; i++) { GAP_ASSERT(UnbListFuncs[i]); GAP_ASSERT(AssListFuncs[i]); } @@ -2439,7 +2438,7 @@ static Int CheckInit ( // check that all relevant `ClearFiltListTNums' are installed for ( i = FIRST_LIST_TNUM; i <= LAST_LIST_TNUM; i++ ) { if ( ClearFiltsTNums[i] == 0 ) { - Pr( "#W ClearFiltsListTNums [%s] missing\n", + Pr( "#W ClearFiltsTNums [%s] missing\n", (Int)TNAM_TNUM(i), 0); success = FALSE; } @@ -2521,39 +2520,7 @@ static Int CheckInit ( // check implications for ( i = FIRST_LIST_TNUM; i <= LAST_LIST_TNUM; i++ ) { - if ( (i & IMMUTABLE) == 0 ) { - if ( ClearFiltsTNums[i]+IMMUTABLE != ClearFiltsTNums[i+IMMUTABLE]) { - Pr( "#W ClearFiltsTNums [%s] mismatch between mutable and immutable\n", - (Int)TNAM_TNUM(i), 0 ); - success = FALSE; - } - for ( j = 0; j < ARRAY_SIZE(fnums); j++ ) { - - if ( HasFiltListTNums[i][fnums[j]] != - HasFiltListTNums[i+IMMUTABLE][fnums[j]]) { - Pr( "#W HasFiltListTNums [%s] [%s] mismatch between mutable and immutable\n", - (Int)TNAM_TNUM(i), (Int)fnams[j] ); - success = FALSE; - } - - if ( (SetFiltListTNums[i][fnums[j]] | IMMUTABLE) != - SetFiltListTNums[i+IMMUTABLE][fnums[j]]) { - Pr( "#W SetFiltListTNums [%s] [%s] mismatch between mutable and immutable\n", - (Int)TNAM_TNUM(i), (Int)fnams[j] ); - success = FALSE; - } - - if ( (ResetFiltListTNums[i][fnums[j]] | IMMUTABLE) != - ResetFiltListTNums[i+IMMUTABLE][fnums[j]]) { - Pr( "#W ResetFiltListTNums [%s] [%s] mismatch between mutable and immutable\n", - (Int)TNAM_TNUM(i), (Int)fnams[j] ); - success = FALSE; - } - - } - } - - if ( i == T_PLIST_EMPTY || i == T_PLIST_EMPTY+IMMUTABLE ) { + if ( i == T_PLIST_EMPTY ) { if ( ! HasFiltListTNums[i][FN_IS_DENSE] ) { Pr( "#W HasFiltListTNums [%s] [ empty -> dense ] missing\n", diff --git a/src/modules.c b/src/modules.c index 557d239f22..aa2a83ef1a 100644 --- a/src/modules.c +++ b/src/modules.c @@ -465,7 +465,6 @@ void InitClearFiltsTNumsFromTable(const Int * tab) for (i = 0; tab[i] != -1; i += 2) { ClearFiltsTNums[tab[i]] = tab[i + 1]; - ClearFiltsTNums[tab[i] | IMMUTABLE] = tab[i + 1] | IMMUTABLE; } } @@ -480,7 +479,6 @@ void InitHasFiltListTNumsFromTable(const Int * tab) for (i = 0; tab[i] != -1; i += 3) { HasFiltListTNums[tab[i]][tab[i + 1]] = tab[i + 2]; - HasFiltListTNums[tab[i] | IMMUTABLE][tab[i + 1]] = tab[i + 2]; } } @@ -495,8 +493,6 @@ void InitSetFiltListTNumsFromTable(const Int * tab) for (i = 0; tab[i] != -1; i += 3) { SetFiltListTNums[tab[i]][tab[i + 1]] = tab[i + 2]; - SetFiltListTNums[tab[i] | IMMUTABLE][tab[i + 1]] = - tab[i + 2] | IMMUTABLE; } } @@ -511,8 +507,6 @@ void InitResetFiltListTNumsFromTable(const Int * tab) for (i = 0; tab[i] != -1; i += 3) { ResetFiltListTNums[tab[i]][tab[i + 1]] = tab[i + 2]; - ResetFiltListTNums[tab[i] | IMMUTABLE][tab[i + 1]] = - tab[i + 2] | IMMUTABLE; } } From bd8fbf8274995560fcd02df688b05ed9f8a134c7 Mon Sep 17 00:00:00 2001 From: Max Horn Date: Thu, 26 Jun 2025 22:38:44 +0200 Subject: [PATCH 04/19] Remove IMMUTABLE: src/blister.c --- src/blister.c | 41 ++++++----------------------------------- 1 file changed, 6 insertions(+), 35 deletions(-) diff --git a/src/blister.c b/src/blister.c index 4b8b10168a..84cbf31a3f 100644 --- a/src/blister.c +++ b/src/blister.c @@ -1707,11 +1707,8 @@ static void MakeImmutableBlist(Obj blist) */ static StructBagNames BagNames[] = { { T_BLIST, "list (boolean)" }, - { T_BLIST +IMMUTABLE, "list (boolean,imm)" }, { T_BLIST_NSORT, "list (boolean,nsort)" }, - { T_BLIST_NSORT +IMMUTABLE, "list (boolean,nsort,imm)" }, { T_BLIST_SSORT, "list (boolean,ssort)" }, - { T_BLIST_SSORT +IMMUTABLE, "list (boolean,ssort,imm)" }, { -1, "" } }; @@ -1896,18 +1893,14 @@ static Int InitKernel ( // GASMAN marking functions and GASMAN names InitBagNamesFromTable( BagNames ); - for ( t1 = T_BLIST; t1 <= T_BLIST_SSORT; t1 += 2 ) { + for ( t1 = T_BLIST; t1 <= T_BLIST_SSORT; t1++ ) { InitMarkFuncBags( t1 , MarkNoSubBags ); - InitMarkFuncBags( t1 +IMMUTABLE , MarkNoSubBags ); } // Make immutable blists public TypeObjFuncs[ T_BLIST ] = TypeBlist; - TypeObjFuncs[ T_BLIST +IMMUTABLE ] = TypeBlist; TypeObjFuncs[ T_BLIST_NSORT ] = TypeBlistNSort; - TypeObjFuncs[ T_BLIST_NSORT +IMMUTABLE ] = TypeBlistNSort; TypeObjFuncs[ T_BLIST_SSORT ] = TypeBlistSSort; - TypeObjFuncs[ T_BLIST_SSORT +IMMUTABLE ] = TypeBlistSSort; // initialise list tables InitClearFiltsTNumsFromTable ( ClearFiltsTab ); @@ -1917,74 +1910,52 @@ static Int InitKernel ( #ifdef GAP_ENABLE_SAVELOAD // Install the saving functions -- cannot save while copying - for ( t1 = T_BLIST; t1 <= T_BLIST_SSORT; t1 += 2 ) { + for ( t1 = T_BLIST; t1 <= T_BLIST_SSORT; t1++ ) { SaveObjFuncs[ t1 ] = SaveBlist; - SaveObjFuncs[ t1 +IMMUTABLE ] = SaveBlist; LoadObjFuncs[ t1 ] = LoadBlist; - LoadObjFuncs[ t1 +IMMUTABLE ] = LoadBlist; } #endif // install the copy functions - for ( t1 = T_BLIST; t1 <= T_BLIST_SSORT; t1 += 2 ) { + for ( t1 = T_BLIST; t1 <= T_BLIST_SSORT; t1++ ) { #if !defined(USE_THREADSAFE_COPYING) CopyObjFuncs [ t1 ] = CopyBlist; - CopyObjFuncs [ t1 +IMMUTABLE ] = CopyBlist; CleanObjFuncs[ t1 ] = 0; - CleanObjFuncs[ t1 +IMMUTABLE ] = 0; #endif ShallowCopyObjFuncs[ t1 ] = ShallowCopyBlist; - ShallowCopyObjFuncs[ t1 +IMMUTABLE ] = ShallowCopyBlist; } // install the comparison methods - for ( t1 = T_BLIST; t1 <= T_BLIST_SSORT+IMMUTABLE; t1++ ) { - for ( t2 = T_BLIST; t2 <= T_BLIST_SSORT+IMMUTABLE; t2++ ) { + for ( t1 = T_BLIST; t1 <= T_BLIST_SSORT; t1++ ) { + for ( t2 = T_BLIST; t2 <= T_BLIST_SSORT; t2++ ) { EqFuncs[ t1 ][ t2 ] = EqBlist; } } // install the list functions in the tables - for ( t1 = T_BLIST; t1 <= T_BLIST_SSORT; t1 += 2 ) { + for ( t1 = T_BLIST; t1 <= T_BLIST_SSORT; t1 ++ ) { LenListFuncs [ t1 ] = LenBlist; - LenListFuncs [ t1 +IMMUTABLE ] = LenBlist; IsbListFuncs [ t1 ] = IsbBlist; - IsbListFuncs [ t1 +IMMUTABLE ] = IsbBlist; Elm0ListFuncs [ t1 ] = Elm0Blist; - Elm0ListFuncs [ t1 +IMMUTABLE ] = Elm0Blist; Elm0vListFuncs [ t1 ] = Elm0vBlist; - Elm0vListFuncs [ t1 +IMMUTABLE ] = Elm0vBlist; ElmListFuncs [ t1 ] = ElmBlist; - ElmListFuncs [ t1 +IMMUTABLE ] = ElmBlist; ElmvListFuncs [ t1 ] = ElmvBlist; - ElmvListFuncs [ t1 +IMMUTABLE ] = ElmvBlist; ElmwListFuncs [ t1 ] = ElmvBlist; - ElmwListFuncs [ t1 +IMMUTABLE ] = ElmvBlist; ElmsListFuncs [ t1 ] = ElmsBlist; - ElmsListFuncs [ t1 +IMMUTABLE ] = ElmsBlist; UnbListFuncs [ t1 ] = UnbBlist; AssListFuncs [ t1 ] = AssBlist; AsssListFuncs [ t1 ] = AsssListDefault; IsDenseListFuncs[ t1 ] = AlwaysYes; - IsDenseListFuncs[ t1 +IMMUTABLE ] = AlwaysYes; IsHomogListFuncs[ t1 ] = IsHomogBlist; - IsHomogListFuncs[ t1 +IMMUTABLE ] = IsHomogBlist; IsTableListFuncs[ t1 ] = AlwaysNo; - IsTableListFuncs[ t1 +IMMUTABLE ] = AlwaysNo; IsPossListFuncs [ t1 ] = IsPossBlist; - IsPossListFuncs [ t1 +IMMUTABLE ] = IsPossBlist; PosListFuncs [ t1 ] = PosBlist; - PosListFuncs [ t1 +IMMUTABLE ] = PosBlist; PlainListFuncs [ t1 ] = PlainBlist; - PlainListFuncs [ t1 +IMMUTABLE ] = PlainBlist; MakeImmutableObjFuncs [ t1 ] = MakeImmutableBlist; } IsSSortListFuncs[ T_BLIST ] = IsSSortBlist; - IsSSortListFuncs[ T_BLIST +IMMUTABLE ] = IsSSortBlist; IsSSortListFuncs[ T_BLIST_NSORT ] = AlwaysNo; - IsSSortListFuncs[ T_BLIST_NSORT +IMMUTABLE ] = AlwaysNo; IsSSortListFuncs[ T_BLIST_SSORT ] = AlwaysYes; - IsSSortListFuncs[ T_BLIST_SSORT +IMMUTABLE ] = AlwaysYes; // Import the types of blists: ImportGVarFromLibrary( "TYPE_BLIST_MUT", &TYPE_BLIST_MUT ); From f27f87030dcfca75a07b370460b479d59af26dd2 Mon Sep 17 00:00:00 2001 From: Max Horn Date: Thu, 26 Jun 2025 22:38:52 +0200 Subject: [PATCH 05/19] Remove IMMUTABLE: src/listoper.c --- src/listoper.c | 28 ++++++++++++---------------- 1 file changed, 12 insertions(+), 16 deletions(-) diff --git a/src/listoper.c b/src/listoper.c index 98dbf4da4b..65d2ade5c8 100644 --- a/src/listoper.c +++ b/src/listoper.c @@ -331,8 +331,7 @@ static Obj ZeroListDefault(Obj list) if (IS_PLIST( list )) { - if (TNUM_OBJ(list) == T_PLIST_FFE || - TNUM_OBJ(list) == T_PLIST_FFE+IMMUTABLE) + if (TNUM_OBJ(list) == T_PLIST_FFE) RetypeBag(res, TNUM_OBJ(list)); else if (TNUM_OBJ(list) >= T_PLIST_CYC && TNUM_OBJ(list) < T_PLIST_FFE) @@ -393,8 +392,7 @@ static Obj ZeroListMutDefault(Obj list) if (IS_PLIST( list )) { - if (TNUM_OBJ(list) == T_PLIST_FFE || - TNUM_OBJ(list) == T_PLIST_FFE+IMMUTABLE) + if (TNUM_OBJ(list) == T_PLIST_FFE) RetypeBag(res, T_PLIST_FFE); else if (TNUM_OBJ(list) >= T_PLIST_CYC && TNUM_OBJ(list) < T_PLIST_FFE) @@ -488,8 +486,7 @@ static Obj AInvMutListDefault(Obj list) // Now adjust the result TNUM info if (IS_PLIST(list)) { - if (TNUM_OBJ(list) == T_PLIST_FFE || - TNUM_OBJ(list) == T_PLIST_FFE+IMMUTABLE) + if (TNUM_OBJ(list) == T_PLIST_FFE) RetypeBag(res, T_PLIST_FFE); else if (TNUM_OBJ(list) >= T_PLIST_CYC && TNUM_OBJ(list) < T_PLIST_FFE) @@ -542,8 +539,7 @@ static Obj AInvListDefault(Obj list) // Now adjust the result TNUM info if (IS_PLIST(list)) { - if (TNUM_OBJ(list) == T_PLIST_FFE || - TNUM_OBJ(list) == T_PLIST_FFE+IMMUTABLE) + if (TNUM_OBJ(list) == T_PLIST_FFE) RetypeBag(res, TNUM_OBJ(list)); else if (TNUM_OBJ(list) >= T_PLIST_CYC && TNUM_OBJ(list) < T_PLIST_FFE) @@ -2138,11 +2134,11 @@ static Int InitKernel ( } } - for (t1 = T_PLIST_CYC; t1 <= T_PLIST_FFE+IMMUTABLE; t1++) { - for (t2 = T_PLIST_CYC; t2 <= T_PLIST_FFE+IMMUTABLE; t2++) { + for (t1 = T_PLIST_CYC; t1 <= T_PLIST_FFE; t1++) { + for (t2 = T_PLIST_CYC; t2 <= T_PLIST_FFE; t2++) { SumFuncs[t1][t2] = SumListList; } - for (t2 = T_PLIST_TAB; t2 <= T_PLIST_TAB_RECT_SSORT+IMMUTABLE; t2++) { + for (t2 = T_PLIST_TAB; t2 <= T_PLIST_TAB_RECT_SSORT; t2++) { SumFuncs[t1][t2] = SumSclList; SumFuncs[t2][t1] = SumListScl; } @@ -2156,11 +2152,11 @@ static Int InitKernel ( DiffFuncs[t2][t1] = DiffSclList; } } - for (t1 = T_PLIST_CYC; t1 <= T_PLIST_FFE+IMMUTABLE; t1++) { - for (t2 = T_PLIST_CYC; t2 <= T_PLIST_FFE+IMMUTABLE; t2++) { + for (t1 = T_PLIST_CYC; t1 <= T_PLIST_FFE; t1++) { + for (t2 = T_PLIST_CYC; t2 <= T_PLIST_FFE; t2++) { DiffFuncs[t1][t2] = DiffListList; } - for (t2 = T_PLIST_TAB; t2 <= T_PLIST_TAB_RECT_SSORT+IMMUTABLE; t2++) { + for (t2 = T_PLIST_TAB; t2 <= T_PLIST_TAB_RECT_SSORT; t2++) { DiffFuncs[t1][t2] = DiffSclList; DiffFuncs[t2][t1] = DiffListScl; } @@ -2181,8 +2177,8 @@ static Int InitKernel ( ProdFuncs[t2][t1] = ProdSclList; } } - for (t1 = T_PLIST_CYC; t1 <= T_PLIST_FFE+IMMUTABLE; t1++) { - for (t2 = T_PLIST_CYC; t2 <= T_PLIST_FFE+IMMUTABLE; t2++) { + for (t1 = T_PLIST_CYC; t1 <= T_PLIST_FFE; t1++) { + for (t2 = T_PLIST_CYC; t2 <= T_PLIST_FFE; t2++) { ProdFuncs[t1][t2] = ProdListList; } } From f9975782dcc9375f693fc3a0f577c520a27fcb8a Mon Sep 17 00:00:00 2001 From: Max Horn Date: Tue, 24 Jun 2025 00:51:08 +0200 Subject: [PATCH 06/19] Remove IMMUTABLE: src/lists.c --- src/lists.c | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/src/lists.c b/src/lists.c index 90873da0ce..69d1216931 100644 --- a/src/lists.c +++ b/src/lists.c @@ -2329,9 +2329,8 @@ static Int InitKernel ( // install tests for being copyable - for ( type = FIRST_LIST_TNUM; type <= LAST_LIST_TNUM; type += 2 ) { + for ( type = FIRST_LIST_TNUM; type <= LAST_LIST_TNUM; type++ ) { IsCopyableObjFuncs[ type ] = AlwaysYes; - IsCopyableObjFuncs[ type+IMMUTABLE ] = AlwaysYes; } // install the default printers @@ -2341,16 +2340,12 @@ static Int InitKernel ( // initialise filter table - for ( type = FIRST_LIST_TNUM; type <= LAST_LIST_TNUM; type +=2 ) { + for ( type = FIRST_LIST_TNUM; type <= LAST_LIST_TNUM; type++ ) { ClearFiltsTNums [ type ] = 0; - ClearFiltsTNums [ type +IMMUTABLE ] = 0; for ( i = 0; i <= LAST_FN; i++ ) { SetFiltListTNums [ type ][i] = 0; - SetFiltListTNums [ type +IMMUTABLE ][i] = 0; ResetFiltListTNums[ type ][i] = 0; - ResetFiltListTNums[ type +IMMUTABLE ][i] = 0; HasFiltListTNums [ type ][i] = -1; - HasFiltListTNums [ type +IMMUTABLE ][i] = -1; } } From 7759809584c5db6a6decbe55c5d91fae228c2e26 Mon Sep 17 00:00:00 2001 From: Max Horn Date: Thu, 26 Jun 2025 22:47:34 +0200 Subject: [PATCH 07/19] Remove IMMUTABLE: src/objset.c --- src/objset.c | 16 ++-------------- 1 file changed, 2 insertions(+), 14 deletions(-) diff --git a/src/objset.c b/src/objset.c index 1d404a5c8a..2994968ba7 100644 --- a/src/objset.c +++ b/src/objset.c @@ -43,13 +43,13 @@ static Obj TypeObjMap(Obj obj) static inline BOOL IS_OBJSET(Obj obj) { UInt tnum = TNUM_OBJ(obj); - return tnum == T_OBJSET || tnum == T_OBJSET + IMMUTABLE; + return tnum == T_OBJSET; } static inline BOOL IS_OBJMAP(Obj obj) { UInt tnum = TNUM_OBJ(obj); - return tnum == T_OBJMAP || tnum == T_OBJMAP + IMMUTABLE; + return tnum == T_OBJMAP; } /** Object sets and maps -------------------- @@ -1085,9 +1085,7 @@ static Obj FuncOBJ_MAP_KEYS(Obj self, Obj map) */ static StructBagNames BagNames[] = { { T_OBJSET , "object set" }, - { T_OBJSET+IMMUTABLE, "immutable object set" }, { T_OBJMAP , "object map" }, - { T_OBJMAP+IMMUTABLE, "immutable object map" }, { -1, "" } }; @@ -1129,22 +1127,16 @@ static Int InitKernel ( // install kind functions TypeObjFuncs[T_OBJSET ] = TypeObjSet; - TypeObjFuncs[T_OBJSET+IMMUTABLE] = TypeObjSet; TypeObjFuncs[T_OBJMAP ] = TypeObjMap; - TypeObjFuncs[T_OBJMAP+IMMUTABLE] = TypeObjMap; // install global variables InitCopyGVar("TYPE_OBJSET", &TYPE_OBJSET); InitCopyGVar("TYPE_OBJMAP", &TYPE_OBJMAP); // install mark functions InitMarkFuncBags(T_OBJSET , MarkObjSet); - InitMarkFuncBags(T_OBJSET+IMMUTABLE, MarkObjSet); InitMarkFuncBags(T_OBJMAP , MarkObjMap); - InitMarkFuncBags(T_OBJMAP+IMMUTABLE, MarkObjMap); // install print functions PrintObjFuncs[ T_OBJSET ] = PrintObjSet; - PrintObjFuncs[ T_OBJSET+IMMUTABLE ] = PrintObjSet; PrintObjFuncs[ T_OBJMAP ] = PrintObjMap; - PrintObjFuncs[ T_OBJMAP+IMMUTABLE ] = PrintObjMap; #ifdef USE_THREADSAFE_COPYING SetTraversalMethod(T_OBJSET, TRAVERSE_BY_FUNCTION, TraverseObjSet, CopyObjSet); @@ -1154,14 +1146,10 @@ static Int InitKernel ( #ifdef GAP_ENABLE_SAVELOAD // Install saving functions SaveObjFuncs[ T_OBJSET ] = SaveObjSet; - SaveObjFuncs[ T_OBJSET +IMMUTABLE ] = SaveObjSet; SaveObjFuncs[ T_OBJMAP ] = SaveObjMap; - SaveObjFuncs[ T_OBJMAP +IMMUTABLE ] = SaveObjMap; LoadObjFuncs[ T_OBJSET ] = LoadObjSet; - LoadObjFuncs[ T_OBJSET +IMMUTABLE ] = LoadObjSet; LoadObjFuncs[ T_OBJMAP ] = LoadObjMap; - LoadObjFuncs[ T_OBJMAP +IMMUTABLE ] = LoadObjMap; #endif // init filters and functions From 5eee4333457484f071f192e90b06521f106ac469 Mon Sep 17 00:00:00 2001 From: Max Horn Date: Thu, 26 Jun 2025 22:39:41 +0200 Subject: [PATCH 08/19] Remove IMMUTABLE: src/plist.c --- src/plist.c | 269 ++++++++++++++++------------------------------------ 1 file changed, 81 insertions(+), 188 deletions(-) diff --git a/src/plist.c b/src/plist.c index eac2a7d3b7..0edd8c14ed 100644 --- a/src/plist.c +++ b/src/plist.c @@ -2441,64 +2441,45 @@ static Obj FuncIsRectangularTablePlist(Obj self, Obj plist) */ static StructBagNames BagNames[] = { { T_PLIST, "plain list" }, - { T_PLIST +IMMUTABLE, "immutable plain list" }, { T_PLIST_NDENSE, "non-dense plain list" }, - { T_PLIST_NDENSE +IMMUTABLE, "immutable non-dense plain list" }, { T_PLIST_DENSE, "dense plain list" }, - { T_PLIST_DENSE +IMMUTABLE, "immutable dense plain list" }, { T_PLIST_DENSE_NHOM, "dense non-homogeneous plain list" }, - { T_PLIST_DENSE_NHOM +IMMUTABLE, "immutable dense non-homogeneous plain list" }, { T_PLIST_DENSE_NHOM_SSORT, "dense non-homogeneous strictly-sorted plain list" }, - { T_PLIST_DENSE_NHOM_SSORT +IMMUTABLE, "immutable dense non-homogeneous strictly-sorted plain list" }, { T_PLIST_DENSE_NHOM_NSORT, "dense non-homogeneous non-strictly-sorted plain list" }, - { T_PLIST_DENSE_NHOM_NSORT +IMMUTABLE, "immutable dense non-homogeneous non-strictly-sorted plain list" }, { T_PLIST_EMPTY, "empty plain list" }, - { T_PLIST_EMPTY +IMMUTABLE, "immutable empty plain list" }, { T_PLIST_HOM, "homogeneous plain list" }, - { T_PLIST_HOM +IMMUTABLE, "immutable homogeneous plain list" }, { T_PLIST_HOM_NSORT, "homogeneous non-strictly-sorted plain list" }, - { T_PLIST_HOM_NSORT +IMMUTABLE, "immutable homogeneous non-strictly-sorted plain list" }, { T_PLIST_HOM_SSORT, "homogeneous strictly-sorted plain list" }, - { T_PLIST_HOM_SSORT +IMMUTABLE, "immutable homogeneous strictly-sorted plain list" }, { T_PLIST_TAB, "plain list (table)" }, - { T_PLIST_TAB +IMMUTABLE, "immutable plain list (table)" }, { T_PLIST_TAB_NSORT, "non-strictly-sorted plain list (table)" }, - { T_PLIST_TAB_NSORT +IMMUTABLE, "immutable non-strictly-sorted plain list (table)" }, { T_PLIST_TAB_SSORT, "strictly-sorted plain list (table)" }, - { T_PLIST_TAB_SSORT +IMMUTABLE, "immutable strictly-sorted plain list (table)" }, { T_PLIST_TAB_RECT, "plain list (rectangular table)" }, - { T_PLIST_TAB_RECT +IMMUTABLE, "immutable plain list (rectangular table)" }, { T_PLIST_TAB_RECT_NSORT, "non-strictly-sorted plain list (rectangular table)" }, - { T_PLIST_TAB_RECT_NSORT +IMMUTABLE, "immutable non-strictly-sorted plain list (rectangular table)" }, { T_PLIST_TAB_RECT_SSORT, "strictly-sorted plain list (rectangular table)" }, - { T_PLIST_TAB_RECT_SSORT +IMMUTABLE, "immutable strictly-sorted plain list (rectangular table)" }, { T_PLIST_CYC, "plain list of cyclotomics" }, - { T_PLIST_CYC +IMMUTABLE, "immutable plain list of cyclotomics" }, { T_PLIST_CYC_NSORT, "non-strictly-sorted plain list of cyclotomics" }, - { T_PLIST_CYC_NSORT +IMMUTABLE, "immutable non-strictly-sorted plain list of cyclotomics" }, { T_PLIST_CYC_SSORT, "strictly-sorted plain list of cyclotomics" }, - { T_PLIST_CYC_SSORT +IMMUTABLE, "immutable strictly-sorted plain list of cyclotomics" }, { T_PLIST_FFE, "plain list of small finite field elements" }, - { T_PLIST_FFE +IMMUTABLE, "immutable plain list of small finite field elements" }, + { -1, "" } }; @@ -3205,23 +3186,19 @@ static Int InitKernel ( // GASMAN marking functions and GASMAN names InitBagNamesFromTable( BagNames ); - for ( t1 = T_PLIST; t1 < T_PLIST_FFE ; t1 += 2 ) { + for ( t1 = T_PLIST; t1 < T_PLIST_FFE ; t1++ ) { InitMarkFuncBags( t1 , MarkAllButFirstSubBags ); - InitMarkFuncBags( t1 +IMMUTABLE , MarkAllButFirstSubBags ); } InitMarkFuncBags( T_PLIST_FFE , MarkNoSubBags ); - InitMarkFuncBags( T_PLIST_FFE +IMMUTABLE , MarkNoSubBags ); // If T_PLIST_FFE is not the last PLIST type then some more // work needs to be done here #ifdef GAP_ENABLE_SAVELOAD - for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1 += 2 ) { + for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1++ ) { SaveObjFuncs[ t1 ] = SavePlist; - SaveObjFuncs[ t1 +IMMUTABLE ] = SavePlist; LoadObjFuncs[ t1 ] = LoadPlist; - LoadObjFuncs[ t1 +IMMUTABLE ] = LoadPlist; } #endif @@ -3261,32 +3238,23 @@ static Int InitKernel ( // install the type methods TypeObjFuncs[ T_PLIST ] = TypePlist; - TypeObjFuncs[ T_PLIST +IMMUTABLE ] = TypePlist; TypeObjFuncs[ T_PLIST_NDENSE ] = TypePlistNDense; - TypeObjFuncs[ T_PLIST_NDENSE +IMMUTABLE ] = TypePlistNDense; TypeObjFuncs[ T_PLIST_DENSE ] = TypePlistDense; - TypeObjFuncs[ T_PLIST_DENSE +IMMUTABLE ] = TypePlistDense; TypeObjFuncs[ T_PLIST_DENSE_NHOM ] = TypePlistDenseNHom; - TypeObjFuncs[ T_PLIST_DENSE_NHOM +IMMUTABLE ] = TypePlistDenseNHom; TypeObjFuncs[ T_PLIST_DENSE_NHOM_SSORT ] = TypePlistDenseNHomSSort; - TypeObjFuncs[ T_PLIST_DENSE_NHOM_SSORT +IMMUTABLE ] = TypePlistDenseNHomSSort; TypeObjFuncs[ T_PLIST_DENSE_NHOM_NSORT ] = TypePlistDenseNHomNSort; - TypeObjFuncs[ T_PLIST_DENSE_NHOM_NSORT +IMMUTABLE ] = TypePlistDenseNHomNSort; TypeObjFuncs[ T_PLIST_EMPTY ] = TypePlistEmpty; - TypeObjFuncs[ T_PLIST_EMPTY +IMMUTABLE ] = TypePlistEmpty; - for ( t1 = T_PLIST_HOM; t1 <= T_PLIST_TAB_RECT_SSORT; t1 += 2 ) { + for ( t1 = T_PLIST_HOM; t1 <= T_PLIST_TAB_RECT_SSORT; t1++ ) { TypeObjFuncs[ t1 ] = TypePlistHom; - TypeObjFuncs[ t1 +IMMUTABLE ] = TypePlistHom; } - for ( t1 = T_PLIST_CYC; t1 <= T_PLIST_CYC_SSORT; t1 += 2 ) { + for ( t1 = T_PLIST_CYC; t1 <= T_PLIST_CYC_SSORT; t1++ ) { TypeObjFuncs[ t1 ] = TypePlistCyc; - TypeObjFuncs[ t1 +IMMUTABLE ] = TypePlistCyc; } TypeObjFuncs[ T_PLIST_FFE ] = TypePlistFfe; - TypeObjFuncs[ T_PLIST_FFE +IMMUTABLE ] = TypePlistFfe; + // init filters and functions InitHdlrFiltsFromTable( GVarFilts ); @@ -3300,25 +3268,22 @@ static Int InitKernel ( // install the shallow copy methods - for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1 += 2 ) { + for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1++ ) { ShallowCopyObjFuncs[ t1 ] = ShallowCopyPlist; - ShallowCopyObjFuncs[ t1 +IMMUTABLE ] = ShallowCopyPlist; } #ifdef USE_THREADSAFE_COPYING for (t1 = FIRST_PLIST_TNUM; t1 <= LAST_PLIST_TNUM; t1++) { SetTraversalMethod(t1, TRAVERSE_BY_FUNCTION, TraversePlist, CopyPlist); } - for (t1 = T_PLIST_CYC; t1 <= T_PLIST_FFE+IMMUTABLE; t1++) { + for (t1 = T_PLIST_CYC; t1 <= T_PLIST_FFE; t1++) { SetTraversalMethod(t1, TRAVERSE_NONE, 0, 0); } #else // install the copy list methods - for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1 += 2 ) { + for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1++ ) { CopyObjFuncs [ t1 ] = CopyPlist; - CopyObjFuncs [ t1 +IMMUTABLE ] = CopyPlist; CleanObjFuncs[ t1 ] = CleanPlist; - CleanObjFuncs[ t1 +IMMUTABLE ] = CleanPlist; } #endif @@ -3332,69 +3297,56 @@ static Int InitKernel ( // install the list length methods - for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1 += 2 ) { + for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1++ ) { LenListFuncs[ t1 ] = LenPlist; - LenListFuncs[ t1 +IMMUTABLE ] = LenPlist; } LenListFuncs[ T_PLIST_EMPTY ] = LenPlistEmpty; - LenListFuncs[ T_PLIST_EMPTY+IMMUTABLE ] = LenPlistEmpty; // install the list element test methods - for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1 += 2 ) { + for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1++ ) { IsbListFuncs [ t1 ] = IsbPlist; - IsbListFuncs [ t1 +IMMUTABLE ] = IsbPlist; } - for ( t1 = T_PLIST_DENSE; t1 <= LAST_PLIST_TNUM; t1 += 2 ) { + for ( t1 = T_PLIST_DENSE; t1 <= LAST_PLIST_TNUM; t1++ ) { IsbListFuncs [ t1 ] = IsbPlistDense; - IsbListFuncs [ t1 +IMMUTABLE ] = IsbPlistDense; } // install the list element methods - for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1 += 2 ) { + for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1++ ) { Elm0ListFuncs [ t1 ] = Elm0Plist; - Elm0ListFuncs [ t1 +IMMUTABLE ] = Elm0Plist; } - for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1 += 2 ) { + for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1++ ) { Elm0vListFuncs[ t1 ] = Elm0vPlist; - Elm0vListFuncs[ t1 +IMMUTABLE ] = Elm0vPlist; } - for ( t1 = T_PLIST; t1 <= T_PLIST_NDENSE; t1 += 2 ) { + for ( t1 = T_PLIST; t1 <= T_PLIST_NDENSE; t1++ ) { ElmListFuncs [ t1 ] = ElmPlist; - ElmListFuncs [ t1 +IMMUTABLE ] = ElmPlist; } - for ( t1 = T_PLIST_DENSE; t1 <= LAST_PLIST_TNUM; t1 += 2 ) { + for ( t1 = T_PLIST_DENSE; t1 <= LAST_PLIST_TNUM; t1++ ) { ElmListFuncs [ t1 ] = ElmPlistDense; - ElmListFuncs [ t1 +IMMUTABLE ] = ElmPlistDense; } - for ( t1 = T_PLIST; t1 <= T_PLIST_NDENSE; t1 += 2 ) { + for ( t1 = T_PLIST; t1 <= T_PLIST_NDENSE; t1++ ) { ElmvListFuncs [ t1 ] = ElmvPlist; - ElmvListFuncs [ t1 +IMMUTABLE ] = ElmvPlist; } - for ( t1 = T_PLIST_DENSE; t1 <= LAST_PLIST_TNUM; t1 += 2 ) { + for ( t1 = T_PLIST_DENSE; t1 <= LAST_PLIST_TNUM; t1++ ) { ElmvListFuncs [ t1 ] = ElmvPlistDense; - ElmvListFuncs [ t1 +IMMUTABLE ] = ElmvPlistDense; } - for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1 += 2 ) { + for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1++ ) { ElmwListFuncs [ t1 ] = ElmvPlistDense; - ElmwListFuncs [ t1 +IMMUTABLE ] = ElmvPlistDense; } // install the list elements methods - for ( t1 = T_PLIST; t1 <= T_PLIST_NDENSE; t1 += 2 ) { + for ( t1 = T_PLIST; t1 <= T_PLIST_NDENSE; t1++ ) { ElmsListFuncs [ t1 ] = ElmsPlist; - ElmsListFuncs [ t1 +IMMUTABLE ] = ElmsPlist; } - for ( t1 = T_PLIST_DENSE; t1 <= LAST_PLIST_TNUM; t1 += 2 ) { + for ( t1 = T_PLIST_DENSE; t1 <= LAST_PLIST_TNUM; t1++ ) { ElmsListFuncs [ t1 ] = ElmsPlistDense; - ElmsListFuncs [ t1 +IMMUTABLE ] = ElmsPlistDense; } // install the list unbind methods - for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1 += 2 ) { + for ( t1 = T_PLIST; t1 <= LAST_PLIST_TNUM; t1++ ) { UnbListFuncs [ t1 ] = UnbPlist; } @@ -3409,11 +3361,11 @@ static Int InitKernel ( AssListFuncs [ T_PLIST_EMPTY ] = AssPlistEmpty; - for ( t1 = T_PLIST_HOM; t1 < T_PLIST_CYC; t1 += 2 ) { + for ( t1 = T_PLIST_HOM; t1 < T_PLIST_CYC; t1++ ) { AssListFuncs[ t1 ] = AssPlistHomog; } - for ( t1 = T_PLIST_CYC; t1 <= T_PLIST_CYC_SSORT; t1 += 2 ) { + for ( t1 = T_PLIST_CYC; t1 <= T_PLIST_CYC_SSORT; t1++ ) { AssListFuncs[ t1 ] = AssPlistCyc; } @@ -3421,168 +3373,109 @@ static Int InitKernel ( // install the list assignments methods AsssListFuncs [ T_PLIST ] = AsssPlist; - for ( t1 = T_PLIST_NDENSE; t1 <= LAST_PLIST_TNUM; t1 += 2 ) { + for ( t1 = T_PLIST_NDENSE; t1 <= LAST_PLIST_TNUM; t1++ ) { AsssListFuncs [ t1 ] = AsssPlistXXX; } // install the dense list test methods IsDenseListFuncs[ T_PLIST ] = IsDensePlist; - IsDenseListFuncs[ T_PLIST +IMMUTABLE ] = IsDensePlist; IsDenseListFuncs[ T_PLIST_NDENSE ] = AlwaysNo; - IsDenseListFuncs[ T_PLIST_NDENSE +IMMUTABLE ] = AlwaysNo; - for ( t1 = T_PLIST_DENSE; t1 <= LAST_PLIST_TNUM; t1 += 2 ) { + for ( t1 = T_PLIST_DENSE; t1 <= LAST_PLIST_TNUM; t1++ ) { IsDenseListFuncs[ t1 ] = AlwaysYes; - IsDenseListFuncs[ t1 +IMMUTABLE ] = AlwaysYes; } // install the homogeneous list test methods - IsHomogListFuncs[ T_PLIST ] = IsHomogPlist; - IsHomogListFuncs[ T_PLIST +IMMUTABLE ] = IsHomogPlist; - IsHomogListFuncs[ T_PLIST_NDENSE ] = AlwaysNo; - IsHomogListFuncs[ T_PLIST_NDENSE +IMMUTABLE ] = AlwaysNo; - IsHomogListFuncs[ T_PLIST_DENSE ] = IsHomogPlist; - IsHomogListFuncs[ T_PLIST_DENSE +IMMUTABLE ] = IsHomogPlist; - IsHomogListFuncs[ T_PLIST_DENSE_NHOM ] = AlwaysNo; - IsHomogListFuncs[ T_PLIST_DENSE_NHOM +IMMUTABLE ] = AlwaysNo; - IsHomogListFuncs[ T_PLIST_DENSE_NHOM_SSORT ] = AlwaysNo; - IsHomogListFuncs[ T_PLIST_DENSE_NHOM_SSORT +IMMUTABLE ] = AlwaysNo; - IsHomogListFuncs[ T_PLIST_DENSE_NHOM_NSORT ] = AlwaysNo; - IsHomogListFuncs[ T_PLIST_DENSE_NHOM_NSORT +IMMUTABLE ] = AlwaysNo; - IsHomogListFuncs[ T_PLIST_EMPTY ] = AlwaysYes; - IsHomogListFuncs[ T_PLIST_EMPTY +IMMUTABLE ] = AlwaysYes; - for ( t1 = T_PLIST_HOM; t1 <= LAST_PLIST_TNUM; t1 += 2 ) { + IsHomogListFuncs[ T_PLIST ] = IsHomogPlist; + IsHomogListFuncs[ T_PLIST_NDENSE ] = AlwaysNo; + IsHomogListFuncs[ T_PLIST_DENSE ] = IsHomogPlist; + IsHomogListFuncs[ T_PLIST_DENSE_NHOM ] = AlwaysNo; + IsHomogListFuncs[ T_PLIST_DENSE_NHOM_SSORT ] = AlwaysNo; + IsHomogListFuncs[ T_PLIST_DENSE_NHOM_NSORT ] = AlwaysNo; + IsHomogListFuncs[ T_PLIST_EMPTY ] = AlwaysYes; + for ( t1 = T_PLIST_HOM; t1 <= LAST_PLIST_TNUM; t1++ ) { IsHomogListFuncs[ t1 ] = AlwaysYes; - IsHomogListFuncs[ t1 +IMMUTABLE ] = AlwaysYes; } // install the equal length list test methods - IsTableListFuncs[ T_PLIST ] = IsTablePlist; - IsTableListFuncs[ T_PLIST +IMMUTABLE ] = IsTablePlist; - IsTableListFuncs[ T_PLIST_NDENSE ] = AlwaysNo; - IsTableListFuncs[ T_PLIST_NDENSE +IMMUTABLE ] = AlwaysNo; - IsTableListFuncs[ T_PLIST_DENSE ] = IsTablePlist; - IsTableListFuncs[ T_PLIST_DENSE +IMMUTABLE ] = IsTablePlist; - IsTableListFuncs[ T_PLIST_DENSE_NHOM ] = AlwaysNo; - IsTableListFuncs[ T_PLIST_DENSE_NHOM +IMMUTABLE ] = AlwaysNo; - IsTableListFuncs[ T_PLIST_DENSE_NHOM_SSORT ] = AlwaysNo; - IsTableListFuncs[ T_PLIST_DENSE_NHOM_SSORT +IMMUTABLE ] = AlwaysNo; - IsTableListFuncs[ T_PLIST_DENSE_NHOM_NSORT ] = AlwaysNo; - IsTableListFuncs[ T_PLIST_DENSE_NHOM_NSORT +IMMUTABLE ] = AlwaysNo; - IsTableListFuncs[ T_PLIST_EMPTY ] = AlwaysNo; - IsTableListFuncs[ T_PLIST_EMPTY +IMMUTABLE ] = AlwaysNo; - IsTableListFuncs[ T_PLIST_HOM ] = IsTablePlist; - IsTableListFuncs[ T_PLIST_HOM +IMMUTABLE ] = IsTablePlist; - IsTableListFuncs[ T_PLIST_HOM_NSORT ] = IsTablePlist; - IsTableListFuncs[ T_PLIST_HOM_NSORT +IMMUTABLE ] = IsTablePlist; - IsTableListFuncs[ T_PLIST_HOM_SSORT ] = IsTablePlist; - IsTableListFuncs[ T_PLIST_HOM_SSORT +IMMUTABLE ] = IsTablePlist; - IsTableListFuncs[ T_PLIST_TAB ] = AlwaysYes; - IsTableListFuncs[ T_PLIST_TAB +IMMUTABLE ] = AlwaysYes; - IsTableListFuncs[ T_PLIST_TAB_NSORT ] = AlwaysYes; - IsTableListFuncs[ T_PLIST_TAB_NSORT +IMMUTABLE ] = AlwaysYes; - IsTableListFuncs[ T_PLIST_TAB_SSORT ] = AlwaysYes; - IsTableListFuncs[ T_PLIST_TAB_SSORT +IMMUTABLE ] = AlwaysYes; - IsTableListFuncs[ T_PLIST_TAB_RECT ] = AlwaysYes; - IsTableListFuncs[ T_PLIST_TAB_RECT +IMMUTABLE ] = AlwaysYes; - IsTableListFuncs[ T_PLIST_TAB_RECT_NSORT ] = AlwaysYes; - IsTableListFuncs[ T_PLIST_TAB_RECT_NSORT +IMMUTABLE ] = AlwaysYes; - IsTableListFuncs[ T_PLIST_TAB_RECT_SSORT ] = AlwaysYes; - IsTableListFuncs[ T_PLIST_TAB_RECT_SSORT +IMMUTABLE ] = AlwaysYes; - IsTableListFuncs[ T_PLIST_CYC ] = AlwaysNo; - IsTableListFuncs[ T_PLIST_CYC +IMMUTABLE ] = AlwaysNo; - IsTableListFuncs[ T_PLIST_CYC_NSORT ] = AlwaysNo; - IsTableListFuncs[ T_PLIST_CYC_NSORT +IMMUTABLE ] = AlwaysNo; - IsTableListFuncs[ T_PLIST_CYC_SSORT ] = AlwaysNo; - IsTableListFuncs[ T_PLIST_CYC_SSORT +IMMUTABLE ] = AlwaysNo; - IsTableListFuncs[ T_PLIST_FFE ] = AlwaysNo; - IsTableListFuncs[ T_PLIST_FFE +IMMUTABLE ] = AlwaysNo; + IsTableListFuncs[ T_PLIST ] = IsTablePlist; + IsTableListFuncs[ T_PLIST_NDENSE ] = AlwaysNo; + IsTableListFuncs[ T_PLIST_DENSE ] = IsTablePlist; + IsTableListFuncs[ T_PLIST_DENSE_NHOM ] = AlwaysNo; + IsTableListFuncs[ T_PLIST_DENSE_NHOM_SSORT ] = AlwaysNo; + IsTableListFuncs[ T_PLIST_DENSE_NHOM_NSORT ] = AlwaysNo; + IsTableListFuncs[ T_PLIST_EMPTY ] = AlwaysNo; + IsTableListFuncs[ T_PLIST_HOM ] = IsTablePlist; + IsTableListFuncs[ T_PLIST_HOM_NSORT ] = IsTablePlist; + IsTableListFuncs[ T_PLIST_HOM_SSORT ] = IsTablePlist; + IsTableListFuncs[ T_PLIST_TAB ] = AlwaysYes; + IsTableListFuncs[ T_PLIST_TAB_NSORT ] = AlwaysYes; + IsTableListFuncs[ T_PLIST_TAB_SSORT ] = AlwaysYes; + IsTableListFuncs[ T_PLIST_TAB_RECT ] = AlwaysYes; + IsTableListFuncs[ T_PLIST_TAB_RECT_NSORT ] = AlwaysYes; + IsTableListFuncs[ T_PLIST_TAB_RECT_SSORT ] = AlwaysYes; + IsTableListFuncs[ T_PLIST_CYC ] = AlwaysNo; + IsTableListFuncs[ T_PLIST_CYC_NSORT ] = AlwaysNo; + IsTableListFuncs[ T_PLIST_CYC_SSORT ] = AlwaysNo; + IsTableListFuncs[ T_PLIST_FFE ] = AlwaysNo; // install the strictly sorted list test methods - IsSSortListFuncs[ T_PLIST ] = IsSSortPlist; - IsSSortListFuncs[ T_PLIST +IMMUTABLE ] = IsSSortPlist; - IsSSortListFuncs[ T_PLIST_NDENSE ] = AlwaysNo; - IsSSortListFuncs[ T_PLIST_NDENSE +IMMUTABLE ] = AlwaysNo; - IsSSortListFuncs[ T_PLIST_DENSE ] = IsSSortPlistDense; - IsSSortListFuncs[ T_PLIST_DENSE +IMMUTABLE ] = IsSSortPlistDense; - IsSSortListFuncs[ T_PLIST_DENSE_NHOM ] = IsSSortPlistDense; - IsSSortListFuncs[ T_PLIST_DENSE_NHOM+IMMUTABLE ] = IsSSortPlistDense; - IsSSortListFuncs[ T_PLIST_DENSE_NHOM_SSORT ] = AlwaysYes; - IsSSortListFuncs[ T_PLIST_DENSE_NHOM_SSORT+IMMUTABLE ] = AlwaysYes; - IsSSortListFuncs[ T_PLIST_DENSE_NHOM_NSORT ] = AlwaysNo; - IsSSortListFuncs[ T_PLIST_DENSE_NHOM_NSORT+IMMUTABLE ] = AlwaysNo; - IsSSortListFuncs[ T_PLIST_EMPTY ] = AlwaysYes; - IsSSortListFuncs[ T_PLIST_EMPTY +IMMUTABLE ] = AlwaysYes; - IsSSortListFuncs[ T_PLIST_HOM ] = IsSSortPlistHom; - IsSSortListFuncs[ T_PLIST_HOM +IMMUTABLE ] = IsSSortPlistHom; - IsSSortListFuncs[ T_PLIST_HOM_NSORT ] = AlwaysNo; - IsSSortListFuncs[ T_PLIST_HOM_NSORT +IMMUTABLE ] = AlwaysNo; - IsSSortListFuncs[ T_PLIST_HOM_SSORT ] = AlwaysYes; - IsSSortListFuncs[ T_PLIST_HOM_SSORT +IMMUTABLE ] = AlwaysYes; - IsSSortListFuncs[ T_PLIST_TAB ] = IsSSortPlistHom; - IsSSortListFuncs[ T_PLIST_TAB +IMMUTABLE ] = IsSSortPlistHom; - IsSSortListFuncs[ T_PLIST_TAB_NSORT ] = AlwaysNo; - IsSSortListFuncs[ T_PLIST_TAB_NSORT +IMMUTABLE ] = AlwaysNo; - IsSSortListFuncs[ T_PLIST_TAB_SSORT ] = AlwaysYes; - IsSSortListFuncs[ T_PLIST_TAB_SSORT +IMMUTABLE ] = AlwaysYes; - IsSSortListFuncs[ T_PLIST_TAB_RECT ] = IsSSortPlistHom; - IsSSortListFuncs[ T_PLIST_TAB_RECT +IMMUTABLE ] = IsSSortPlistHom; - IsSSortListFuncs[ T_PLIST_TAB_RECT_NSORT ] = AlwaysNo; - IsSSortListFuncs[ T_PLIST_TAB_RECT_NSORT +IMMUTABLE ] = AlwaysNo; - IsSSortListFuncs[ T_PLIST_TAB_RECT_SSORT ] = AlwaysYes; - IsSSortListFuncs[ T_PLIST_TAB_RECT_SSORT +IMMUTABLE ] = AlwaysYes; - IsSSortListFuncs[ T_PLIST_CYC ] = IsSSortPlistHom; - IsSSortListFuncs[ T_PLIST_CYC +IMMUTABLE ] = IsSSortPlistHom; - IsSSortListFuncs[ T_PLIST_CYC_NSORT ] = AlwaysNo; - IsSSortListFuncs[ T_PLIST_CYC_NSORT +IMMUTABLE ] = AlwaysNo; - IsSSortListFuncs[ T_PLIST_CYC_SSORT ] = AlwaysYes; - IsSSortListFuncs[ T_PLIST_CYC_SSORT +IMMUTABLE ] = AlwaysYes; - IsSSortListFuncs[ T_PLIST_FFE ] = IsSSortPlistHom; - IsSSortListFuncs[ T_PLIST_FFE +IMMUTABLE ] = IsSSortPlistHom; + IsSSortListFuncs[ T_PLIST ] = IsSSortPlist; + IsSSortListFuncs[ T_PLIST_NDENSE ] = AlwaysNo; + IsSSortListFuncs[ T_PLIST_DENSE ] = IsSSortPlistDense; + IsSSortListFuncs[ T_PLIST_DENSE_NHOM ] = IsSSortPlistDense; + IsSSortListFuncs[ T_PLIST_DENSE_NHOM_SSORT ] = AlwaysYes; + IsSSortListFuncs[ T_PLIST_DENSE_NHOM_NSORT ] = AlwaysNo; + IsSSortListFuncs[ T_PLIST_EMPTY ] = AlwaysYes; + IsSSortListFuncs[ T_PLIST_HOM ] = IsSSortPlistHom; + IsSSortListFuncs[ T_PLIST_HOM_NSORT ] = AlwaysNo; + IsSSortListFuncs[ T_PLIST_HOM_SSORT ] = AlwaysYes; + IsSSortListFuncs[ T_PLIST_TAB ] = IsSSortPlistHom; + IsSSortListFuncs[ T_PLIST_TAB_NSORT ] = AlwaysNo; + IsSSortListFuncs[ T_PLIST_TAB_SSORT ] = AlwaysYes; + IsSSortListFuncs[ T_PLIST_TAB_RECT ] = IsSSortPlistHom; + IsSSortListFuncs[ T_PLIST_TAB_RECT_NSORT ] = AlwaysNo; + IsSSortListFuncs[ T_PLIST_TAB_RECT_SSORT ] = AlwaysYes; + IsSSortListFuncs[ T_PLIST_CYC ] = IsSSortPlistHom; + IsSSortListFuncs[ T_PLIST_CYC_NSORT ] = AlwaysNo; + IsSSortListFuncs[ T_PLIST_CYC_SSORT ] = AlwaysYes; + IsSSortListFuncs[ T_PLIST_FFE ] = IsSSortPlistHom; // install the position list test methods - for ( t1 = T_PLIST; t1 <= T_PLIST_FFE; t1 += 2 ) { + for ( t1 = T_PLIST; t1 <= T_PLIST_FFE; t1++ ) { IsPossListFuncs[ t1 ] = IsPossPlist; - IsPossListFuncs[ t1 +IMMUTABLE ] = IsPossPlist; } // install the position list methods - for ( t1 = T_PLIST; t1 <= T_PLIST_NDENSE; t1 += 2 ) { + for ( t1 = T_PLIST; t1 <= T_PLIST_NDENSE; t1++ ) { PosListFuncs[ t1 ] = PosPlist; - PosListFuncs[ t1 +IMMUTABLE ] = PosPlist; } - for ( t1 = T_PLIST_DENSE; t1 <= T_PLIST_FFE; t1 += 2 ) { + for ( t1 = T_PLIST_DENSE; t1 <= T_PLIST_FFE; t1++ ) { PosListFuncs[ t1 ] = PosPlistDense; - PosListFuncs[ t1 +IMMUTABLE ] = PosPlistDense; } PosListFuncs[ T_PLIST_DENSE_NHOM_SSORT ] = PosPlistSort; - PosListFuncs[ T_PLIST_DENSE_NHOM_SSORT +IMMUTABLE ] = PosPlistSort; PosListFuncs[ T_PLIST_HOM_SSORT ] = PosPlistHomSort; - PosListFuncs[ T_PLIST_HOM_SSORT +IMMUTABLE ] = PosPlistHomSort; PosListFuncs[ T_PLIST_TAB_SSORT ] = PosPlistHomSort; - PosListFuncs[ T_PLIST_TAB_SSORT +IMMUTABLE ] = PosPlistHomSort; PosListFuncs[ T_PLIST_TAB_RECT_SSORT ] = PosPlistHomSort; - PosListFuncs[ T_PLIST_TAB_RECT_SSORT +IMMUTABLE ] = PosPlistHomSort; PosListFuncs[ T_PLIST_CYC_SSORT ] = PosPlistHomSort; - PosListFuncs[ T_PLIST_CYC_SSORT +IMMUTABLE ] = PosPlistHomSort; + // install the plain list methods - for ( t1 = T_PLIST; t1 <= T_PLIST_FFE; t1 += 2 ) { + for ( t1 = T_PLIST; t1 <= T_PLIST_FFE; t1++ ) { PlainListFuncs[ t1 ] = PlainPlist; - PlainListFuncs[ t1 +IMMUTABLE ] = PlainPlist; } - for (t1 = T_PLIST; t1 < T_PLIST_DENSE_NHOM; t1 += 2 ) + for (t1 = T_PLIST; t1 < T_PLIST_DENSE_NHOM; t1++ ) MakeImmutableObjFuncs[ t1 ] = MakeImmutablePlistInHom; - for (t1 = T_PLIST_DENSE_NHOM; t1 <= T_PLIST_FFE; t1 += 2 ) + for (t1 = T_PLIST_DENSE_NHOM; t1 <= T_PLIST_FFE; t1++ ) MakeImmutableObjFuncs[ t1 ] = MakeImmutablePlistNoMutElms; // mutable tables may have mutable rows From 8d95804cc02d1e100d69784cc811b797144c3179 Mon Sep 17 00:00:00 2001 From: Max Horn Date: Thu, 26 Jun 2025 22:39:47 +0200 Subject: [PATCH 09/19] Remove IMMUTABLE: src/precord.c --- src/precord.c | 30 ++++++------------------------ 1 file changed, 6 insertions(+), 24 deletions(-) diff --git a/src/precord.c b/src/precord.c index e6c2239e68..e8168080be 100644 --- a/src/precord.c +++ b/src/precord.c @@ -340,8 +340,8 @@ void UnbPRec ( { UInt len; // length of - // Accept T_PREC and T_COMOBJ, reject T_PREC+IMMUTABLE - if (TNUM_OBJ(rec) == T_PREC+IMMUTABLE) { + // Accept mutable T_PREC and T_COMOBJ, reject immutable T_PREC + if (TNUM_OBJ(rec) == T_PREC && !IS_MUTABLE_OBJ(rec)) { ErrorMayQuit("Record Unbind: must be a mutable record", 0, 0); } @@ -381,8 +381,8 @@ void AssPRec ( { UInt len; // length of - // Accept T_PREC and T_COMOBJ, reject T_PREC+IMMUTABLE - if (TNUM_OBJ(rec) == T_PREC+IMMUTABLE) { + // Accept mutable T_PREC and T_COMOBJ, reject immutable T_PREC + if (TNUM_OBJ(rec) == T_PREC && !IS_MUTABLE_OBJ(rec)) { ErrorMayQuit("Record Assignment: must be a mutable record", 0, 0); } @@ -763,7 +763,6 @@ void MarkPRecSubBags(Obj bag, void * ref) */ static StructBagNames BagNames[] = { { T_PREC, "record (plain)" }, - { T_PREC +IMMUTABLE, "record (plain,imm)" }, { -1, "" } }; @@ -792,7 +791,6 @@ static Int InitKernel ( InitBagNamesFromTable( BagNames ); InitMarkFuncBags( T_PREC , MarkPRecSubBags ); - InitMarkFuncBags( T_PREC +IMMUTABLE , MarkPRecSubBags ); // init filters and functions InitHdlrFuncsFromTable( GVarFuncs ); @@ -800,54 +798,38 @@ static Int InitKernel ( #ifdef GAP_ENABLE_SAVELOAD // Install saving functions SaveObjFuncs[ T_PREC ] = SavePRec; - SaveObjFuncs[ T_PREC +IMMUTABLE ] = SavePRec; LoadObjFuncs[ T_PREC ] = LoadPRec; - LoadObjFuncs[ T_PREC +IMMUTABLE ] = LoadPRec; #endif // install into record function tables ElmRecFuncs[ T_PREC ] = ElmPRec; - ElmRecFuncs[ T_PREC +IMMUTABLE ] = ElmPRec; IsbRecFuncs[ T_PREC ] = IsbPRec; - IsbRecFuncs[ T_PREC +IMMUTABLE ] = IsbPRec; AssRecFuncs[ T_PREC ] = AssPRec; - AssRecFuncs[ T_PREC +IMMUTABLE ] = AssPRec; UnbRecFuncs[ T_PREC ] = UnbPRec; - UnbRecFuncs[ T_PREC +IMMUTABLE ] = UnbPRec; // install tests for being copyable IsCopyableObjFuncs[ T_PREC ] = AlwaysYes; - IsCopyableObjFuncs[ T_PREC +IMMUTABLE ] = AlwaysYes; #ifdef USE_THREADSAFE_COPYING SetTraversalMethod(T_PREC , TRAVERSE_BY_FUNCTION, TraversePRecord, CopyPRecord); - SetTraversalMethod(T_PREC +IMMUTABLE, TRAVERSE_BY_FUNCTION, TraversePRecord, CopyPRecord); #else // install into copy function tables CopyObjFuncs [ T_PREC ] = CopyPRec; - CopyObjFuncs [ T_PREC +IMMUTABLE ] = CopyPRec; CleanObjFuncs[ T_PREC ] = CleanPRec; - CleanObjFuncs[ T_PREC +IMMUTABLE ] = CleanPRec; #endif // install printer PrintObjFuncs[ T_PREC ] = PrintPRec; - PrintObjFuncs[ T_PREC +IMMUTABLE ] = PrintPRec; // install the comparison methods - for (UInt t1 = T_PREC; t1 <= T_PREC + IMMUTABLE; t1++) { - for (UInt t2 = T_PREC; t2 <= T_PREC + IMMUTABLE; t2++) { - EqFuncs[t1][t2] = EqPRec; - LtFuncs[t1][t2] = LtPRec; - } - } + EqFuncs[T_PREC][T_PREC] = EqPRec; + LtFuncs[T_PREC][T_PREC] = LtPRec; // install the type functions ImportGVarFromLibrary( "TYPE_PREC_MUTABLE", &TYPE_PREC_MUTABLE ); ImportGVarFromLibrary( "TYPE_PREC_IMMUTABLE", &TYPE_PREC_IMMUTABLE ); TypeObjFuncs[ T_PREC ] = TypePRec; - TypeObjFuncs[ T_PREC +IMMUTABLE ] = TypePRec; MakeImmutableObjFuncs[ T_PREC ] = MakeImmutablePRec; From 23b638c395c9583faf60165a111620520da92cfc Mon Sep 17 00:00:00 2001 From: Max Horn Date: Tue, 24 Jun 2025 00:57:54 +0200 Subject: [PATCH 10/19] Remove IMMUTABLE: src/range.c --- src/range.c | 51 +-------------------------------------------------- 1 file changed, 1 insertion(+), 50 deletions(-) diff --git a/src/range.c b/src/range.c index 290d9e2967..685763350f 100644 --- a/src/range.c +++ b/src/range.c @@ -993,9 +993,7 @@ static Obj FuncINTER_RANGE(Obj self, Obj r1, Obj r2) */ static StructBagNames BagNames[] = { { T_RANGE_NSORT, "list (range,nsort)" }, - { T_RANGE_NSORT +IMMUTABLE, "list (range,nsort,imm)" }, { T_RANGE_SSORT, "list (range,ssort)" }, - { T_RANGE_SSORT +IMMUTABLE, "list (range,ssort,imm)" }, { -1, "" } }; @@ -1138,9 +1136,7 @@ static Int InitKernel ( InitBagNamesFromTable( BagNames ); InitMarkFuncBags( T_RANGE_NSORT , MarkAllSubBags ); - InitMarkFuncBags( T_RANGE_NSORT +IMMUTABLE , MarkAllSubBags ); InitMarkFuncBags( T_RANGE_SSORT , MarkAllSubBags ); - InitMarkFuncBags( T_RANGE_SSORT +IMMUTABLE , MarkAllSubBags ); // install the type function ImportGVarFromLibrary( "TYPE_RANGE_NSORT_MUTABLE", @@ -1156,9 +1152,7 @@ static Int InitKernel ( &TYPE_RANGE_SSORT_IMMUTABLE ); TypeObjFuncs[ T_RANGE_NSORT ] = TypeRangeNSort; - TypeObjFuncs[ T_RANGE_NSORT +IMMUTABLE ] = TypeRangeNSort; TypeObjFuncs[ T_RANGE_SSORT ] = TypeRangeSSort; - TypeObjFuncs[ T_RANGE_SSORT +IMMUTABLE ] = TypeRangeSSort; // init filters and functions InitHdlrFiltsFromTable( GVarFilts ); @@ -1167,25 +1161,17 @@ static Int InitKernel ( #ifdef GAP_ENABLE_SAVELOAD // Saving functions SaveObjFuncs[T_RANGE_NSORT ] = SaveRange; - SaveObjFuncs[T_RANGE_NSORT +IMMUTABLE ] = SaveRange; SaveObjFuncs[T_RANGE_SSORT ] = SaveRange; - SaveObjFuncs[T_RANGE_SSORT +IMMUTABLE ] = SaveRange; LoadObjFuncs[T_RANGE_NSORT ] = LoadRange; - LoadObjFuncs[T_RANGE_NSORT +IMMUTABLE ] = LoadRange; LoadObjFuncs[T_RANGE_SSORT ] = LoadRange; - LoadObjFuncs[T_RANGE_SSORT +IMMUTABLE ] = LoadRange; #endif #if !defined(USE_THREADSAFE_COPYING) // install the copy methods CopyObjFuncs [ T_RANGE_NSORT ] = CopyRange; - CopyObjFuncs [ T_RANGE_NSORT +IMMUTABLE ] = CopyRange; CopyObjFuncs [ T_RANGE_SSORT ] = CopyRange; - CopyObjFuncs [ T_RANGE_SSORT +IMMUTABLE ] = CopyRange; CleanObjFuncs[ T_RANGE_NSORT ] = 0; - CleanObjFuncs[ T_RANGE_NSORT +IMMUTABLE ] = 0; CleanObjFuncs[ T_RANGE_SSORT ] = 0; - CleanObjFuncs[ T_RANGE_SSORT +IMMUTABLE ] = 0; #endif // Make immutable methods @@ -1194,9 +1180,7 @@ static Int InitKernel ( // install the print method PrintObjFuncs[ T_RANGE_NSORT ] = PrintRange; - PrintObjFuncs[ T_RANGE_NSORT +IMMUTABLE ] = PrintRange; PrintObjFuncs[ T_RANGE_SSORT ] = PrintRange; - PrintObjFuncs[ T_RANGE_SSORT +IMMUTABLE ] = PrintRange; // initialise list tables InitClearFiltsTNumsFromTable ( ClearFiltsTab ); @@ -1215,48 +1199,28 @@ static Int InitKernel ( LtFuncs[ T_RANGE_SSORT ][ T_RANGE_SSORT ] = LtRange; SumFuncs[ T_INT ][ T_RANGE_NSORT ] = SumIntRange; - SumFuncs[ T_INT ][ T_RANGE_NSORT + IMMUTABLE ] = SumIntRange; SumFuncs[ T_INT ][ T_RANGE_SSORT ] = SumIntRange; - SumFuncs[ T_INT ][ T_RANGE_SSORT + IMMUTABLE ] = SumIntRange; SumFuncs[ T_RANGE_NSORT ][ T_INT ] = SumRangeInt; - SumFuncs[ T_RANGE_NSORT + IMMUTABLE ][ T_INT ] = SumRangeInt; SumFuncs[ T_RANGE_SSORT ][ T_INT ] = SumRangeInt; - SumFuncs[ T_RANGE_SSORT + IMMUTABLE ][ T_INT ] = SumRangeInt; // install the list functions in the tables LenListFuncs [ T_RANGE_NSORT ] = LenRange; - LenListFuncs [ T_RANGE_NSORT +IMMUTABLE ] = LenRange; LenListFuncs [ T_RANGE_SSORT ] = LenRange; - LenListFuncs [ T_RANGE_SSORT +IMMUTABLE ] = LenRange; IsbListFuncs [ T_RANGE_NSORT ] = IsbRange; - IsbListFuncs [ T_RANGE_NSORT +IMMUTABLE ] = IsbRange; IsbListFuncs [ T_RANGE_SSORT ] = IsbRange; - IsbListFuncs [ T_RANGE_SSORT +IMMUTABLE ] = IsbRange; Elm0ListFuncs [ T_RANGE_NSORT ] = Elm0Range; - Elm0ListFuncs [ T_RANGE_NSORT +IMMUTABLE ] = Elm0Range; Elm0ListFuncs [ T_RANGE_SSORT ] = Elm0Range; - Elm0ListFuncs [ T_RANGE_SSORT +IMMUTABLE ] = Elm0Range; Elm0vListFuncs [ T_RANGE_NSORT ] = Elm0vRange; - Elm0vListFuncs [ T_RANGE_NSORT +IMMUTABLE ] = Elm0vRange; Elm0vListFuncs [ T_RANGE_SSORT ] = Elm0vRange; - Elm0vListFuncs [ T_RANGE_SSORT +IMMUTABLE ] = Elm0vRange; ElmListFuncs [ T_RANGE_NSORT ] = ElmRange; - ElmListFuncs [ T_RANGE_NSORT +IMMUTABLE ] = ElmRange; ElmListFuncs [ T_RANGE_SSORT ] = ElmRange; - ElmListFuncs [ T_RANGE_SSORT +IMMUTABLE ] = ElmRange; ElmvListFuncs [ T_RANGE_NSORT ] = ElmvRange; - ElmvListFuncs [ T_RANGE_NSORT +IMMUTABLE ] = ElmvRange; ElmvListFuncs [ T_RANGE_SSORT ] = ElmvRange; - ElmvListFuncs [ T_RANGE_SSORT +IMMUTABLE ] = ElmvRange; ElmwListFuncs [ T_RANGE_NSORT ] = ElmvRange; - ElmwListFuncs [ T_RANGE_NSORT +IMMUTABLE ] = ElmvRange; ElmwListFuncs [ T_RANGE_SSORT ] = ElmvRange; - ElmwListFuncs [ T_RANGE_SSORT +IMMUTABLE ] = ElmvRange; ElmsListFuncs [ T_RANGE_NSORT ] = ElmsRange; - ElmsListFuncs [ T_RANGE_NSORT +IMMUTABLE ] = ElmsRange; ElmsListFuncs [ T_RANGE_SSORT ] = ElmsRange; - ElmsListFuncs [ T_RANGE_SSORT +IMMUTABLE ] = ElmsRange; UnbListFuncs [ T_RANGE_NSORT ] = UnbRange; UnbListFuncs [ T_RANGE_SSORT ] = UnbRange; AssListFuncs [ T_RANGE_NSORT ] = AssRange; @@ -1264,33 +1228,20 @@ static Int InitKernel ( AsssListFuncs [ T_RANGE_NSORT ] = AsssRange; AsssListFuncs [ T_RANGE_SSORT ] = AsssRange; IsDenseListFuncs[ T_RANGE_NSORT ] = AlwaysYes; - IsDenseListFuncs[ T_RANGE_NSORT +IMMUTABLE ] = AlwaysYes; IsDenseListFuncs[ T_RANGE_SSORT ] = AlwaysYes; - IsDenseListFuncs[ T_RANGE_SSORT +IMMUTABLE ] = AlwaysYes; IsHomogListFuncs[ T_RANGE_NSORT ] = AlwaysYes; - IsHomogListFuncs[ T_RANGE_NSORT +IMMUTABLE ] = AlwaysYes; IsHomogListFuncs[ T_RANGE_SSORT ] = AlwaysYes; - IsHomogListFuncs[ T_RANGE_SSORT +IMMUTABLE ] = AlwaysYes; IsTableListFuncs[ T_RANGE_NSORT ] = AlwaysNo; - IsTableListFuncs[ T_RANGE_NSORT +IMMUTABLE ] = AlwaysNo; IsTableListFuncs[ T_RANGE_SSORT ] = AlwaysNo; - IsTableListFuncs[ T_RANGE_SSORT +IMMUTABLE ] = AlwaysNo; IsSSortListFuncs[ T_RANGE_NSORT ] = AlwaysNo; - IsSSortListFuncs[ T_RANGE_NSORT +IMMUTABLE ] = AlwaysNo; IsSSortListFuncs[ T_RANGE_SSORT ] = AlwaysYes; - IsSSortListFuncs[ T_RANGE_SSORT +IMMUTABLE ] = AlwaysYes; IsPossListFuncs [ T_RANGE_NSORT ] = IsPossRange; - IsPossListFuncs [ T_RANGE_NSORT +IMMUTABLE ] = IsPossRange; IsPossListFuncs [ T_RANGE_SSORT ] = IsPossRange; - IsPossListFuncs [ T_RANGE_SSORT +IMMUTABLE ] = IsPossRange; PosListFuncs [ T_RANGE_NSORT ] = PosRange; - PosListFuncs [ T_RANGE_NSORT +IMMUTABLE ] = PosRange; PosListFuncs [ T_RANGE_SSORT ] = PosRange; - PosListFuncs [ T_RANGE_SSORT +IMMUTABLE ] = PosRange; PlainListFuncs [ T_RANGE_NSORT ] = PlainRange; - PlainListFuncs [ T_RANGE_NSORT +IMMUTABLE ] = PlainRange; PlainListFuncs [ T_RANGE_SSORT ] = PlainRange; - PlainListFuncs [ T_RANGE_SSORT +IMMUTABLE ] = PlainRange; + return 0; } From 90804df2fba0b4e998ddb621ddec125c81efce8f Mon Sep 17 00:00:00 2001 From: Max Horn Date: Thu, 26 Jun 2025 22:39:55 +0200 Subject: [PATCH 11/19] Remove IMMUTABLE: src/stringobj.c --- src/stringobj.c | 49 ++++++++----------------------------------------- 1 file changed, 8 insertions(+), 41 deletions(-) diff --git a/src/stringobj.c b/src/stringobj.c index 044e7d1f37..d040ac8f26 100644 --- a/src/stringobj.c +++ b/src/stringobj.c @@ -1827,11 +1827,8 @@ static void UnbString(Obj string, Int pos) static StructBagNames BagNames[] = { { T_CHAR, "character" }, { T_STRING, "list (string)" }, - { T_STRING +IMMUTABLE, "list (string,imm)" }, { T_STRING_SSORT, "list (string,ssort)" }, - { T_STRING_SSORT +IMMUTABLE, "list (string,ssort,imm)" }, { T_STRING_NSORT, "list (string,nsort)" }, - { T_STRING_NSORT +IMMUTABLE, "list (string,nsort,imm)" }, { -1, "" } }; @@ -2037,7 +2034,6 @@ static Int InitKernel ( InitMarkFuncBags( T_CHAR , MarkNoSubBags ); for ( t1 = T_STRING; t1 <= T_STRING_SSORT; t1 += 2 ) { InitMarkFuncBags( t1 , MarkNoSubBags ); - InitMarkFuncBags( t1 +IMMUTABLE , MarkNoSubBags ); } #ifdef HPCGAP @@ -2068,11 +2064,8 @@ static Int InitKernel ( ImportGVarFromLibrary("TYPE_STRING_SSORT_MUTABLE", &TYPE_STRING_SSORT_MUTABLE); ImportGVarFromLibrary("TYPE_STRING_SSORT_IMMUTABLE", &TYPE_STRING_SSORT_IMMUTABLE); TypeObjFuncs[ T_STRING ] = TypeString; - TypeObjFuncs[ T_STRING +IMMUTABLE ] = TypeString; TypeObjFuncs[ T_STRING_NSORT ] = TypeStringNSort; - TypeObjFuncs[ T_STRING_NSORT +IMMUTABLE ] = TypeStringNSort; TypeObjFuncs[ T_STRING_SSORT ] = TypeStringSSort; - TypeObjFuncs[ T_STRING_SSORT +IMMUTABLE ] = TypeStringSSort; // init filters and functions InitHdlrFiltsFromTable( GVarFilts ); @@ -2097,78 +2090,56 @@ static Int InitKernel ( #ifdef GAP_ENABLE_SAVELOAD // install the saving method - for ( t1 = T_STRING; t1 <= T_STRING_SSORT; t1 += 2 ) { + for ( t1 = T_STRING; t1 <= T_STRING_SSORT; t1 ++ ) { SaveObjFuncs[ t1 ] = SaveString; - SaveObjFuncs[ t1 +IMMUTABLE ] = SaveString; LoadObjFuncs[ t1 ] = LoadString; - LoadObjFuncs[ t1 +IMMUTABLE ] = LoadString; } #endif #if !defined(USE_THREADSAFE_COPYING) // install the copy method - for ( t1 = T_STRING; t1 <= T_STRING_SSORT; t1 += 2 ) { + for ( t1 = T_STRING; t1 <= T_STRING_SSORT; t1 ++ ) { CopyObjFuncs [ t1 ] = CopyString; - CopyObjFuncs [ t1 +IMMUTABLE ] = CopyString; CleanObjFuncs[ t1 ] = 0; - CleanObjFuncs[ t1 +IMMUTABLE ] = 0; } #endif // install the print method - for ( t1 = T_STRING; t1 <= T_STRING_SSORT; t1 += 2 ) { + for ( t1 = T_STRING; t1 <= T_STRING_SSORT; t1 ++ ) { PrintObjFuncs[ t1 ] = PrintString; - PrintObjFuncs[ t1 +IMMUTABLE ] = PrintString; } // install the comparison methods - for ( t1 = T_STRING; t1 <= T_STRING_SSORT+IMMUTABLE; t1++ ) { - for ( t2 = T_STRING; t2 <= T_STRING_SSORT+IMMUTABLE; t2++ ) { + for ( t1 = T_STRING; t1 <= T_STRING_SSORT; t1++ ) { + for ( t2 = T_STRING; t2 <= T_STRING_SSORT; t2++ ) { EqFuncs[ t1 ][ t2 ] = EqString; LtFuncs[ t1 ][ t2 ] = LtString; } } // install the list methods - for ( t1 = T_STRING; t1 <= T_STRING_SSORT; t1 += 2 ) { + for ( t1 = T_STRING; t1 <= T_STRING_SSORT; t1 ++ ) { LenListFuncs [ t1 ] = LenString; - LenListFuncs [ t1 +IMMUTABLE ] = LenString; IsbListFuncs [ t1 ] = IsbString; - IsbListFuncs [ t1 +IMMUTABLE ] = IsbString; Elm0ListFuncs [ t1 ] = Elm0String; - Elm0ListFuncs [ t1 +IMMUTABLE ] = Elm0String; Elm0vListFuncs [ t1 ] = Elm0vString; - Elm0vListFuncs [ t1 +IMMUTABLE ] = Elm0vString; ElmListFuncs [ t1 ] = ElmString; - ElmListFuncs [ t1 +IMMUTABLE ] = ElmString; ElmvListFuncs [ t1 ] = ElmvString; - ElmvListFuncs [ t1 +IMMUTABLE ] = ElmvString; ElmwListFuncs [ t1 ] = ElmwString; - ElmwListFuncs [ t1 +IMMUTABLE ] = ElmwString; ElmsListFuncs [ t1 ] = ElmsString; - ElmsListFuncs [ t1 +IMMUTABLE ] = ElmsString; UnbListFuncs [ t1 ] = UnbString; AssListFuncs [ t1 ] = AssString; AsssListFuncs [ t1 ] = AsssString; IsDenseListFuncs[ t1 ] = AlwaysYes; - IsDenseListFuncs[ t1 +IMMUTABLE ] = AlwaysYes; IsHomogListFuncs[ t1 ] = AlwaysYes; - IsHomogListFuncs[ t1 +IMMUTABLE ] = AlwaysYes; IsTableListFuncs[ t1 ] = AlwaysNo; - IsTableListFuncs[ t1 +IMMUTABLE ] = AlwaysNo; IsSSortListFuncs[ t1 ] = IsSSortString; - IsSSortListFuncs[ t1 +IMMUTABLE ] = IsSSortString; IsPossListFuncs [ t1 ] = IsPossString; - IsPossListFuncs [ t1 +IMMUTABLE ] = IsPossString; PosListFuncs [ t1 ] = PosString; - PosListFuncs [ t1 +IMMUTABLE ] = PosString; PlainListFuncs [ t1 ] = PlainString; - PlainListFuncs [ t1 +IMMUTABLE ] = PlainString; } IsSSortListFuncs[ T_STRING_NSORT ] = AlwaysNo; - IsSSortListFuncs[ T_STRING_NSORT +IMMUTABLE ] = AlwaysNo; IsSSortListFuncs[ T_STRING_SSORT ] = AlwaysYes; - IsSSortListFuncs[ T_STRING_SSORT +IMMUTABLE ] = AlwaysYes; // install the `IsString' functions @@ -2178,18 +2149,14 @@ static Int InitKernel ( } IsStringFuncs[ T_PLIST ] = IsStringList; - IsStringFuncs[ T_PLIST +IMMUTABLE ] = IsStringList; IsStringFuncs[ T_PLIST_DENSE ] = IsStringList; - IsStringFuncs[ T_PLIST_DENSE+IMMUTABLE ] = IsStringList; IsStringFuncs[ T_PLIST_EMPTY ] = AlwaysYes; - IsStringFuncs[ T_PLIST_EMPTY+IMMUTABLE ] = AlwaysYes; - for ( t1 = T_PLIST_HOM; t1 <= T_PLIST_HOM_SSORT; t1 += 2 ) { + for ( t1 = T_PLIST_HOM; t1 <= T_PLIST_HOM_SSORT; t1 ++ ) { IsStringFuncs[ t1 ] = IsStringListHom; - IsStringFuncs[ t1 +IMMUTABLE ] = IsStringListHom; } - for ( t1 = T_STRING; t1 <= T_STRING_SSORT+IMMUTABLE; t1++ ) { + for ( t1 = T_STRING; t1 <= T_STRING_SSORT; t1++ ) { IsStringFuncs[ t1 ] = AlwaysYes; } From 4ab8bf6f9ccf1cd4bba001db35e900c69866a5ff Mon Sep 17 00:00:00 2001 From: Max Horn Date: Thu, 26 Jun 2025 22:39:35 +0200 Subject: [PATCH 12/19] Remove IMMUTABLE: src/vecffe.c --- src/vecffe.c | 42 +++++++++++++++--------------------------- 1 file changed, 15 insertions(+), 27 deletions(-) diff --git a/src/vecffe.c b/src/vecffe.c index 616b4fce1b..c9b63b29f3 100644 --- a/src/vecffe.c +++ b/src/vecffe.c @@ -36,7 +36,7 @@ static BOOL IsVecFFE(Obj obj) { UInt tnum = TNUM_OBJ(obj); - if (tnum == T_PLIST_FFE || tnum == T_PLIST_FFE + IMMUTABLE) + if (tnum == T_PLIST_FFE) return TRUE; // must be a plain list of length >= 1 @@ -838,8 +838,7 @@ static Obj ZeroMutVecFFE(Obj vec) UInt i, len; Obj res; Obj z; - GAP_ASSERT(TNUM_OBJ(vec) >= T_PLIST_FFE && - TNUM_OBJ(vec) <= T_PLIST_FFE + IMMUTABLE); + GAP_ASSERT(TNUM_OBJ(vec) == T_PLIST_FFE); len = LEN_PLIST(vec); assert(len); res = NEW_PLIST(T_PLIST_FFE, len); @@ -855,8 +854,7 @@ static Obj ZeroVecFFE(Obj vec) UInt i, len; Obj res; Obj z; - GAP_ASSERT(TNUM_OBJ(vec) >= T_PLIST_FFE && - TNUM_OBJ(vec) <= T_PLIST_FFE + IMMUTABLE); + GAP_ASSERT(TNUM_OBJ(vec) == T_PLIST_FFE); len = LEN_PLIST(vec); assert(len); res = NEW_PLIST_WITH_MUTABILITY(IS_MUTABLE_OBJ(vec), T_PLIST_FFE, len); @@ -942,29 +940,19 @@ static StructGVarFunc GVarFuncs [] = { static Int InitKernel ( StructInitInfo * module ) { - Int t1; - Int t2; - // install the arithmetic operation methods - for (t1 = T_PLIST_FFE; t1 <= T_PLIST_FFE + IMMUTABLE; t1++) { - SumFuncs[ T_FFE ][ t1 ] = SumFFEVecFFE; - SumFuncs[ t1 ][ T_FFE ] = SumVecFFEFFE; - DiffFuncs[ T_FFE ][ t1 ] = DiffFFEVecFFE; - DiffFuncs[ t1 ][ T_FFE ] = DiffVecFFEFFE; - ProdFuncs[ T_FFE ][ t1 ] = ProdFFEVecFFE; - ProdFuncs[ t1 ][ T_FFE ] = ProdVecFFEFFE; - ZeroSameMutFuncs[t1] = ZeroVecFFE; - ZeroMutFuncs[ t1 ] = ZeroMutVecFFE; - } - - for (t1 = T_PLIST_FFE; t1 <= T_PLIST_FFE + IMMUTABLE; t1++) { - for (t2 = T_PLIST_FFE; t2 <= T_PLIST_FFE + IMMUTABLE; t2++) { - SumFuncs[ t1 ][ t2 ] = SumVecFFEVecFFE; - DiffFuncs[ t1 ][ t2 ] = DiffVecFFEVecFFE; - ProdFuncs[ t1 ][ t2 ] = ProdVecFFEVecFFE; - } - } - + SumFuncs[ T_FFE ][ T_PLIST_FFE ] = SumFFEVecFFE; + SumFuncs[ T_PLIST_FFE ][ T_FFE ] = SumVecFFEFFE; + DiffFuncs[ T_FFE ][ T_PLIST_FFE ] = DiffFFEVecFFE; + DiffFuncs[ T_PLIST_FFE ][ T_FFE ] = DiffVecFFEFFE; + ProdFuncs[ T_FFE ][ T_PLIST_FFE ] = ProdFFEVecFFE; + ProdFuncs[ T_PLIST_FFE ][ T_FFE ] = ProdVecFFEFFE; + ZeroSameMutFuncs[ T_PLIST_FFE ] = ZeroVecFFE; + ZeroMutFuncs[ T_PLIST_FFE ] = ZeroMutVecFFE; + + SumFuncs[ T_PLIST_FFE ][ T_PLIST_FFE ] = SumVecFFEVecFFE; + DiffFuncs[ T_PLIST_FFE ][ T_PLIST_FFE ] = DiffVecFFEVecFFE; + ProdFuncs[ T_PLIST_FFE ][ T_PLIST_FFE ] = ProdVecFFEVecFFE; InitHdlrFuncsFromTable(GVarFuncs); From 64d80d88b6efb5873b426fd42f14586a4f8abc86 Mon Sep 17 00:00:00 2001 From: Max Horn Date: Thu, 26 Jun 2025 22:40:02 +0200 Subject: [PATCH 13/19] Remove IMMUTABLE: src/vector.c --- src/vector.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/vector.c b/src/vector.c index 96e9a6c166..115d81a8e7 100644 --- a/src/vector.c +++ b/src/vector.c @@ -643,7 +643,7 @@ static Obj ZeroVector(Obj vec) UInt i, len; Obj res; GAP_ASSERT(TNUM_OBJ(vec) >= T_PLIST_CYC && - TNUM_OBJ(vec) <= T_PLIST_CYC_SSORT + IMMUTABLE); + TNUM_OBJ(vec) <= T_PLIST_CYC_SSORT); len = LEN_PLIST(vec); res = NEW_PLIST_WITH_MUTABILITY(IS_MUTABLE_OBJ(vec), T_PLIST_CYC, len); SET_LEN_PLIST(res, len); @@ -657,7 +657,7 @@ static Obj ZeroMutVector(Obj vec) UInt i, len; Obj res; GAP_ASSERT(TNUM_OBJ(vec) >= T_PLIST_CYC && - TNUM_OBJ(vec) <= T_PLIST_CYC_SSORT + IMMUTABLE); + TNUM_OBJ(vec) <= T_PLIST_CYC_SSORT); len = LEN_PLIST(vec); res = NEW_PLIST(T_PLIST_CYC, len); SET_LEN_PLIST(res, len); @@ -698,11 +698,11 @@ static Int InitKernel ( InitHdlrFuncsFromTable(GVarFuncs); // install the arithmetic operation methods - for (t1 = T_PLIST_CYC; t1 <= T_PLIST_CYC_SSORT + IMMUTABLE; t1++) { + for (t1 = T_PLIST_CYC; t1 <= T_PLIST_CYC_SSORT; t1++) { ZeroSameMutFuncs[t1] = ZeroVector; ZeroMutFuncs[ t1 ] = ZeroMutVector; - for (t2 = T_PLIST_CYC; t2 <= T_PLIST_CYC_SSORT + IMMUTABLE; t2++) { + for (t2 = T_PLIST_CYC; t2 <= T_PLIST_CYC_SSORT; t2++) { SumFuncs [ T_INT ][ t2 ] = SumIntVector; SumFuncs [ t1 ][ T_INT ] = SumVectorInt; SumFuncs [ t1 ][ t2 ] = SumVectorVector; From 7ff3b0688418eb78c672d531c95732d54175ea09 Mon Sep 17 00:00:00 2001 From: Max Horn Date: Thu, 26 Jun 2025 22:39:14 +0200 Subject: [PATCH 14/19] Remove IMMUTABLE: src/hpc/serialize.c --- src/hpc/serialize.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/src/hpc/serialize.c b/src/hpc/serialize.c index 3dcd730d93..eeee62f065 100644 --- a/src/hpc/serialize.c +++ b/src/hpc/serialize.c @@ -27,6 +27,8 @@ #include +// TODO/FIXME: serialize mutability information again somehow? + typedef struct SerializerState { Obj stack; Obj obj; @@ -585,8 +587,6 @@ static Obj DeserializeRecord(DeserializerState * state, UInt tnum) SET_ELM_PREC(result, i, el); } SortPRecRNam(result); - if (tnum == T_PREC + IMMUTABLE) - RetypeBag(result, tnum); return result; } @@ -713,7 +713,6 @@ static Obj LookupIntTag(Obj tag) retry: switch (map ? TNUM_OBJ(map) : -1) { case T_OBJMAP: - case T_OBJMAP + IMMUTABLE: result = LookupObjMap(map, tag); if (result || func) return result; @@ -741,7 +740,6 @@ static Obj DeserializeTypedObj(DeserializerState * state, UInt tnum) switch (tagtnum) { case T_INT: case T_STRING: - case T_STRING + IMMUTABLE: if (tagtnum == T_INT) { tag = DeserializeInt(state, T_INT); type = LookupIntTag(tag); @@ -765,6 +763,7 @@ static Obj DeserializeTypedObj(DeserializerState * state, UInt tnum) ErrorQuit("DeserializeTypedObj: expected plist, got %s", (Int)TNAM_OBJ(result), 0); break; case T_PREC: + // TODO/FIXME: reject immutable ones? result = DeserializeObj(state); if (TNUM_OBJ(result) != T_COMOBJ) ErrorQuit("DeserializeTypedObj: expected component object, got %s", (Int)TNAM_OBJ(result), 0); @@ -858,7 +857,6 @@ static void SerializeTypedObj(SerializerState * state, Obj obj) switch (TNUM_OBJ(rep)) { case T_INT: case T_STRING: - case T_STRING + IMMUTABLE: SerializeObj(state, rep); UInt sp = LEN_PLIST(state->stack); switch (TNUM_OBJ(obj)) { @@ -1058,13 +1056,13 @@ static Int InitKernel(StructInitInfo * module) for (i = FIRST_PLIST_TNUM; i <= LAST_PLIST_TNUM; i++) { RegisterSerializerFunctions(i, SerializeList, DeserializeList); } - for (i = T_RANGE_NSORT; i <= T_RANGE_SSORT + IMMUTABLE; i++) { + for (i = T_RANGE_NSORT; i <= T_RANGE_SSORT; i++) { RegisterSerializerFunctions(i, SerializeRange, DeserializeRange); } - for (i = T_BLIST; i <= T_BLIST_SSORT + IMMUTABLE; i++) { + for (i = T_BLIST; i <= T_BLIST_SSORT; i++) { RegisterSerializerFunctions(i, SerializeBlist, DeserializeBlist); } - for (i = T_STRING; i <= T_STRING_SSORT + IMMUTABLE; i++) { + for (i = T_STRING; i <= T_STRING_SSORT; i++) { RegisterSerializerFunctions(i, SerializeString, DeserializeString); } From 3f1a1ecc50a9fac62da5d6116374394089d583ea Mon Sep 17 00:00:00 2001 From: Max Horn Date: Sun, 6 Jan 2019 23:47:24 +0100 Subject: [PATCH 15/19] kernel: adjust IS_* helpers to ignore IMMUTABLE --- src/blister.h | 2 +- src/plist.c | 5 ++--- src/precord.h | 4 ++-- src/range.h | 4 ++-- src/stringobj.h | 4 ++-- 5 files changed, 9 insertions(+), 10 deletions(-) diff --git a/src/blister.h b/src/blister.h index c17f6cda2f..88492261af 100644 --- a/src/blister.h +++ b/src/blister.h @@ -30,7 +30,7 @@ EXPORT_INLINE BOOL IS_BLIST_REP(Obj list) { return T_BLIST <= TNUM_OBJ(list) && - TNUM_OBJ(list) <= T_BLIST_SSORT + IMMUTABLE; + TNUM_OBJ(list) <= T_BLIST_SSORT; } diff --git a/src/plist.c b/src/plist.c index 0edd8c14ed..35f1eee16a 100644 --- a/src/plist.c +++ b/src/plist.c @@ -110,8 +110,7 @@ void GrowPlist ( ** Here begins a new attempt by Steve to describe how it all works: ** ** We begin with the TNUMs attached to the objects. They are defined in -** objects.h and consist of the following, each of which can be qualified by -** adding the constant IMMUTABLE. +** objects.h and consist of the following. ** ** T_PLIST nothing is known ** T_PLIST_NDENSE known to have a hole @@ -248,7 +247,7 @@ static Int KTNumPlist(Obj list, Obj * famfirst) // special case for empty list if ( lenList == 0 ) { res = T_PLIST_EMPTY; - RetypeBagSM(list, res); + RetypeBagIfWritable(list, res); if (famfirst != (Obj *) 0) *famfirst = (Obj) 0; return res; diff --git a/src/precord.h b/src/precord.h index b7cb6a0c17..e647fe25fd 100644 --- a/src/precord.h +++ b/src/precord.h @@ -39,7 +39,7 @@ Obj NEW_PREC(UInt len); EXPORT_INLINE BOOL IS_PREC(Obj rec) { UInt tnum = TNUM_OBJ(rec); - return tnum == T_PREC || tnum == T_PREC+IMMUTABLE; + return tnum == T_PREC; } @@ -58,7 +58,7 @@ EXPORT_INLINE BOOL IS_PREC(Obj rec) EXPORT_INLINE BOOL IS_PREC_OR_COMOBJ(Obj rec) { UInt tnum = TNUM_OBJ(rec); - return tnum == T_PREC || tnum == T_PREC+IMMUTABLE || tnum == T_COMOBJ; + return tnum == T_PREC || tnum == T_COMOBJ; } diff --git a/src/range.h b/src/range.h index b25c084d4c..433a10d942 100644 --- a/src/range.h +++ b/src/range.h @@ -47,8 +47,8 @@ Obj NEW_RANGE(Int len, Int low, Int inc); */ EXPORT_INLINE BOOL IS_RANGE(Obj val) { - return TNUM_OBJ(val) >= T_RANGE_NSORT && - TNUM_OBJ(val) <= T_RANGE_SSORT + IMMUTABLE; + UInt tnum = TNUM_OBJ(val); + return T_RANGE_NSORT <= tnum && tnum <= T_RANGE_SSORT; } diff --git a/src/stringobj.h b/src/stringobj.h index 4071c06365..50f63321d6 100644 --- a/src/stringobj.h +++ b/src/stringobj.h @@ -100,8 +100,8 @@ EXPORT_INLINE UInt1 CHAR_SINT(Int n) */ EXPORT_INLINE BOOL IS_STRING_REP(Obj list) { - return (T_STRING <= TNUM_OBJ(list) && - TNUM_OBJ(list) <= T_STRING_SSORT + IMMUTABLE); + UInt tnum = TNUM_OBJ(list); + return (T_STRING <= tnum && tnum <= T_STRING_SSORT); } From c712072d7a4e751bab736fd736e7b146f5b720a3 Mon Sep 17 00:00:00 2001 From: Max Horn Date: Thu, 26 Jun 2025 22:45:41 +0200 Subject: [PATCH 16/19] Remove (IM)MUTABLE_TNUM --- src/blister.c | 2 +- src/objects.c | 2 +- src/objects.h | 19 ------------------- src/plist.c | 12 ++++++------ src/set.c | 4 ++-- 5 files changed, 10 insertions(+), 29 deletions(-) diff --git a/src/blister.c b/src/blister.c index 84cbf31a3f..6700a15f6c 100644 --- a/src/blister.c +++ b/src/blister.c @@ -216,7 +216,7 @@ static Obj DoCopyBlist(Obj list, Int mut) Obj copy; // make a copy - copy = NewBag(MUTABLE_TNUM(TNUM_OBJ(list)), SIZE_OBJ(list)); + copy = NewBag(TNUM_OBJ(list), SIZE_OBJ(list)); if (!mut) MakeImmutableNoRecurse(copy); diff --git a/src/objects.c b/src/objects.c index f919689be6..873963be5b 100644 --- a/src/objects.c +++ b/src/objects.c @@ -422,7 +422,7 @@ static Obj ShallowCopyObjDefault(Obj obj) Obj * n; // make the new object and copy the contents - new = NewBag( MUTABLE_TNUM(TNUM_OBJ(obj)), SIZE_OBJ(obj) ); + new = NewBag( TNUM_OBJ(obj), SIZE_OBJ(obj) ); o = CONST_ADDR_OBJ(obj); n = ADDR_OBJ( new ); memcpy(n, o, SIZE_OBJ(obj) ); diff --git a/src/objects.h b/src/objects.h index efc1f372a5..385f0e6d49 100644 --- a/src/objects.h +++ b/src/objects.h @@ -493,25 +493,6 @@ EXPORT_INLINE Obj TYPE_OBJ(Obj obj) void SET_TYPE_OBJ(Obj obj, Obj type); -/**************************************************************************** -** -*F MUTABLE_TNUM( ) . . . . . . . . . . mutable type of internal type -*/ -#define MUTABLE_TNUM(type) \ - ( ( (type) < FIRST_IMM_MUT_TNUM ? (type) : \ - ( LAST_IMM_MUT_TNUM < (type) ? (type) : \ - ( ((((type)-T_PLIST)&(~IMMUTABLE))+T_PLIST) ) ) ) ) - - -/**************************************************************************** -** -*F IMMUTABLE_TNUM( ) . . . . . . . . immutable type of internal type -*/ -#define IMMUTABLE_TNUM(type) \ - ( ( (type) < FIRST_IMM_MUT_TNUM ? (type) : \ - ( LAST_IMM_MUT_TNUM < (type) ? (type) : \ - ( ((((type)-T_PLIST)|IMMUTABLE)+T_PLIST) ) ) ) ) - /**************************************************************************** ** *F MakeImmutable( ) . . . . . . . . . . . . . make an object immutable diff --git a/src/plist.c b/src/plist.c index 35f1eee16a..bd2ce3707f 100644 --- a/src/plist.c +++ b/src/plist.c @@ -232,7 +232,7 @@ static Int KTNumPlist(Obj list, Obj * famfirst) #ifdef HPCGAP if (!CheckWriteAccess(list)) { - return MUTABLE_TNUM(TNUM_OBJ(list)); + return TNUM_OBJ(list); } #endif // if list has `OBJ_FLAG_TESTING' keep that @@ -451,7 +451,7 @@ static Int KTNumHomPlist(Obj list) #ifdef HPCGAP if (!CheckWriteAccess(list)) { - return MUTABLE_TNUM(TNUM_OBJ(list)); + return TNUM_OBJ(list); } #endif @@ -658,7 +658,7 @@ static Obj TypePlistWithKTNum ( tnum = KTNumPlist( list, &family); CLEAR_OBJ_FLAG( list, OBJ_FLAG_TESTING ); } else { - tnum = MUTABLE_TNUM(TNUM_OBJ(list)); + tnum = TNUM_OBJ(list); family = 0; } #else @@ -762,7 +762,7 @@ Obj ShallowCopyPlist(Obj list) // make the new object and copy the contents len = LEN_PLIST(list); - new = NEW_PLIST(MUTABLE_TNUM(TNUM_OBJ(list)), len); + new = NEW_PLIST(TNUM_OBJ(list), len); memcpy(ADDR_OBJ(new), CONST_ADDR_OBJ(list), (len + 1) * sizeof(Obj)); // 'CHANGED_BAG(new);' not needed, is newest object return new; @@ -1304,7 +1304,7 @@ static Obj ElmsPlistDense(Obj list, Obj poss) lenPoss = LEN_LIST( poss ); // get the (mutable) tnum of list - tnum = MUTABLE_TNUM(TNUM_OBJ(list)); + tnum = TNUM_OBJ(list); // make the result list // try to assert as many properties as possible @@ -1384,7 +1384,7 @@ static Obj ElmsPlistDense(Obj list, Obj poss) } // get the (mutable) tnum of list - tnum = MUTABLE_TNUM(TNUM_OBJ(list)); + tnum = TNUM_OBJ(list); // make the result list // try to assert as many properties as possible diff --git a/src/set.c b/src/set.c index a46cee51f8..cec028b22e 100644 --- a/src/set.c +++ b/src/set.c @@ -530,7 +530,7 @@ static Obj FuncUNITE_SET(Obj self, Obj set1, Obj set2) // fix up the type of the result if ( 0 == LEN_PLIST(set1) ) { - RetypeBag( set1, MUTABLE_TNUM(TNUM_OBJ(set2)) ); + RetypeBag( set1, TNUM_OBJ(set2) ); } else if ( 0 != LEN_PLIST(set2)) { if (HAS_FILT_LIST(set1, FN_IS_HOMOG)) { if( !HAS_FILT_LIST(set2, FN_IS_HOMOG)) @@ -693,7 +693,7 @@ static Obj FuncINTER_SET(Obj self, Obj set1, Obj set2) else { if ( TNUM_OBJ(set2) >= T_PLIST_CYC ) - RetypeBag(set1, MUTABLE_TNUM( TNUM_OBJ(set2))); + RetypeBag(set1, TNUM_OBJ(set2)); else { RESET_FILT_LIST(set1, FN_IS_NHOMOG); From 00570ca76ce5f4ccef69c2919423704905c571b6 Mon Sep 17 00:00:00 2001 From: Max Horn Date: Thu, 26 Jun 2025 22:47:15 +0200 Subject: [PATCH 17/19] kernel: remove IMMUTABLE Lists, records, object sets and object maps no longer come in pairs of a mutable and an immutable tnum; OBJ_FLAG_IMMUTABLE alone records their mutability. This renumbers most list tnums. Consequences handled here: - TypePlistHomHelper computes the index into the type list of a family from the flag, as the tnums are now consecutive. - RetypeBagSM, CLONE_OBJ and SET_TYPE_OBJ carry the mutability over explicitly, as the tnum no longer does. RetypeBag cannot make an object mutable anymore, so PrecheckRetypeBag goes. - SET_TYPE_OBJ and SET_TYPE_COMOBJ reject immutable records, which used to fail for having a tnum of their own. - In HPC-GAP, MakeImmutableNoRecurse makes the bag public; retyping to an immutable tnum used to do that. - Argument errors say "immutable", as tnum names no longer do. - lib/mat8bit.gi and the tests no longer assume the old tnum numbers and names. Assisted-by: Claude Code (Opus 5.5) --- lib/mat8bit.gi | 4 +- src/bags.c | 85 +++++--------------- src/error.c | 7 +- src/gasman.h | 12 --- src/objects.c | 14 ++++ src/objects.h | 124 +++++++++++------------------ src/plist.c | 5 +- tst/testinstall/kernel/blister.tst | 28 +++---- tst/testinstall/kernel/gap.tst | 2 +- tst/testinstall/kernel/objects.tst | 11 ++- tst/testinstall/kernel/range.tst | 4 +- tst/testinstall/list.tst | 4 +- 12 files changed, 118 insertions(+), 182 deletions(-) diff --git a/lib/mat8bit.gi b/lib/mat8bit.gi index 591b28951f..66c1793be5 100644 --- a/lib/mat8bit.gi +++ b/lib/mat8bit.gi @@ -849,10 +849,10 @@ InstallGlobalFunction( RepresentationsOfMatrix, Print(" compressed over GF(",Q_VEC8BIT(m),") "); elif IsPlistRep(m) then Print(" plain list, tnum: ",TNUM_OBJ(m)," "); - if TNUM_OBJ(m) in [T_PLIST_FFE,T_PLIST_FFE+1] then + if TNUM_OBJ(m) = T_PLIST_FFE then Print("known to be vecffe over GF(",CHAR_FFE_DEFAULT(m[1]),"^", DEGREE_FFE_DEFAULT(m[1]),") "); - elif TNUM_OBJ(m) in [T_PLIST_CYC..T_PLIST_CYC_SSORT+1] then + elif TNUM_OBJ(m) in [T_PLIST_CYC..T_PLIST_CYC_SSORT] then Print("known to be vector of cyclotomics "); fi; else diff --git a/src/bags.c b/src/bags.c index 74ba1a6b01..d94cb33a36 100644 --- a/src/bags.c +++ b/src/bags.c @@ -10,7 +10,11 @@ #include "error.h" #include "gasman.h" -#include "objects.h" // HACK: for FIRST_IMM_MUT_TNUM; remove this later +#include "objects.h" + +#ifdef HPCGAP +#include "hpc/guards.h" +#endif /**************************************************************************** ** @@ -24,82 +28,31 @@ TNumInfoBags InfoBags[NUM_TYPES]; UInt8 SizeAllBags; -#ifdef GAP_KERNEL_DEBUG -void PrecheckRetypeBag(Bag bag, UInt new_type) +// An object which records its mutability in its type, such as a compressed +// vector, needs the flag once it turns into a list or record. +static void KeepMutability(Bag bag, UInt new_type) { - // If the new type contains an (im)mutability bit, verify that this does - // not remove mutability from an object that was previously mutable -- - // something we generally don't allow - if (FIRST_IMM_MUT_TNUM <= new_type && new_type <= LAST_IMM_MUT_TNUM) { -#if !defined(USE_THREADSAFE_COPYING) - // HACK: T_COPYING is used for mutable and immutable objects alike, so - // we can't really determine whether it is "mutable" or not. In - // fact, it is not even a "real" TNUM (it comes after LAST_REAL_TNUM), - // so asking such an object for mutability is not even supported. - // - // In the future, there are at least two ways we could get rid of this - // hack: Either we drop T_COPYING by adopting the copying code from - // HPC-GAP for regular GAP as well. Or we could add an - // IMMUTABLE_OBJ_FLAG which can be used to mark any object as - // immutable, including T_COPYING objects. - if (TNUM_BAG(bag) == T_COPYING) - return; -#endif - - // Some GAP code and packages (including EDIM) produce invalid - // T_DATOBJ objects without correct type info, so skip T_DATOBJ for now - if (IS_DATOBJ(bag)) - return; - -#ifndef HPCGAP - // HACK: when using `DeclareGlobalVariable`, the placeholder object of - // type `IsToBeDefinedObj` is immutable, while `InstallValue` also - // accepts mutable values, which are then copied into the placeholder - // *bag* itself, thus turning the placeholder (which is a T_POSOBJ) - // into any different kind of bag, including mutable ones. - if (TNUM_BAG(bag) == T_POSOBJ) - return; -#endif - Int oldImm = !IS_MUTABLE_OBJ(bag); - Int newImm = new_type & IMMUTABLE; - if (oldImm && !newImm) { - ErrorMayQuit( - "RetypeBag: cannot change immutable object to mutable", 0, 0); - } - } + if (new_type < FIRST_IMM_MUT_TNUM || LAST_IMM_MUT_TNUM < new_type) + return; + if (IS_MUTABLE_OBJ(bag)) + CLEAR_OBJ_FLAG(bag, OBJ_FLAG_IMMUTABLE); + else + SET_OBJ_FLAG(bag, OBJ_FLAG_IMMUTABLE); } -#endif - // TODO: perhaps this should become RetypeObj ? void RetypeBagSM(Bag bag, UInt new_type) { - if (FIRST_IMM_MUT_TNUM <= new_type && new_type <= LAST_IMM_MUT_TNUM) { - Int oldImm = !IS_MUTABLE_OBJ(bag); - Int newImm = new_type & IMMUTABLE; - if (newImm) - ErrorMayQuit( - "RetypeBagSM: target tnum should not indicate immutability", - 0, 0); - if (oldImm) - new_type |= IMMUTABLE; - } + KeepMutability(bag, new_type); RetypeBag(bag, new_type); } #ifdef HPCGAP void RetypeBagSMIfWritable(Bag bag, UInt new_type) { - if (FIRST_IMM_MUT_TNUM <= new_type && new_type <= LAST_IMM_MUT_TNUM) { - Int oldImm = !IS_MUTABLE_OBJ(bag); - Int newImm = new_type & IMMUTABLE; - if (newImm) - ErrorMayQuit( - "RetypeBagSM: target tnum should not indicate immutability", - 0, 0); - if (oldImm) - new_type |= IMMUTABLE; - } - RetypeBagIfWritable(bag, new_type); + if (!CheckWriteAccess(bag)) + return; + KeepMutability(bag, new_type); + RetypeBag(bag, new_type); } #endif diff --git a/src/error.c b/src/error.c index 01bdb7bb83..1f76e9f697 100644 --- a/src/error.c +++ b/src/error.c @@ -588,10 +588,15 @@ void RequireArgumentEx(const char * funcname, gap_strlcat(msgbuf, " (not the value 'fail')", sizeof(msgbuf)); else { const char * tnam = TNAM_OBJ(op); + UInt tnum = TNUM_OBJ(op); + // the names of list and record tnums do not mention mutability + if (FIRST_IMM_MUT_TNUM <= tnum && tnum <= LAST_IMM_MUT_TNUM && + !IS_MUTABLE_OBJ(op)) + gap_strlcat(msgbuf, " (not an immutable %s)", sizeof(msgbuf)); // heuristic to choose between 'a' and 'an': use 'an' before a vowel // and 'a' otherwise; however, that's not always correct, e.g. it is // "an FFE", so we add a special case for that as well - if (TNUM_OBJ(op) == T_FFE || tnam[0] == 'a' || tnam[0] == 'e' || + else if (tnum == T_FFE || tnam[0] == 'a' || tnam[0] == 'e' || tnam[0] == 'i' || tnam[0] == 'o' || tnam[0] == 'u') gap_strlcat(msgbuf, " (not an %s)", sizeof(msgbuf)); else diff --git a/src/gasman.h b/src/gasman.h index a8206c8e37..ebdcb6e183 100644 --- a/src/gasman.h +++ b/src/gasman.h @@ -548,17 +548,8 @@ void RetypeBagIfWritable(Bag bag, UInt new_type); #define RetypeBagIfWritable(x,y) RetypeBag(x,y) #endif -#ifdef GAP_KERNEL_DEBUG -// This helper tests whether the type change is "allowed". As such, it rejects -// attempts to retype an immutable list or record into a mutable one. -void PrecheckRetypeBag(Bag bag, UInt new_type); -#endif - EXPORT_INLINE void RetypeBag(Bag bag, UInt new_type) { -#ifdef GAP_KERNEL_DEBUG - PrecheckRetypeBag(bag, new_type); -#endif RetypeBagIntern(bag, new_type); } @@ -567,9 +558,6 @@ EXPORT_INLINE void RetypeBag(Bag bag, UInt new_type) ** ** 'RetypeBagSM' works like 'RetypeBag', but ensures that the given bag ** retains the same mutability (SM). -** -** FIXME: for now, this checks the tnums; later, this will be turned -** into a check for an object flag */ void RetypeBagSM(Bag bag, UInt new_type); #ifdef HPCGAP diff --git a/src/objects.c b/src/objects.c index 873963be5b..8644b76466 100644 --- a/src/objects.c +++ b/src/objects.c @@ -202,6 +202,9 @@ void SET_TYPE_OBJ(Obj obj, Obj type) break; #endif case T_PREC: + if (!IS_MUTABLE_OBJ(obj)) { + ErrorMayQuit("cannot change type of an immutable %s", (Int)TNAM_OBJ(obj), 0); + } #ifdef HPCGAP MEMBAR_WRITE(); #endif @@ -238,6 +241,8 @@ void SET_TYPE_OBJ(Obj obj, Obj type) #ifdef HPCGAP MEMBAR_WRITE(); #endif + // from here on decides whether is mutable + CLEAR_OBJ_FLAG(obj, OBJ_FLAG_IMMUTABLE); RetypeBag(obj, T_POSOBJ); SET_TYPE_POSOBJ(obj, type); CHANGED_BAG(obj); @@ -1184,6 +1189,9 @@ static Obj FuncSET_TYPE_COMOBJ(Obj self, Obj obj, Obj type) { switch (TNUM_OBJ(obj)) { case T_PREC: + if (!IS_MUTABLE_OBJ(obj)) { + ErrorMayQuit("You can't make a component object from an immutable %s", (Int)TNAM_OBJ(obj), 0); + } case T_COMOBJ: #ifdef HPCGAP case T_AREC: @@ -1803,6 +1811,12 @@ static Obj FuncCLONE_OBJ(Obj self, Obj dst, Obj src) SET_PTR_BAG(dst, PTR_BAG(tmp)); #endif + // the flag is not part of the bag contents copied above + if (TEST_OBJ_FLAG(src, OBJ_FLAG_IMMUTABLE)) + SET_OBJ_FLAG(dst, OBJ_FLAG_IMMUTABLE); + else + CLEAR_OBJ_FLAG(dst, OBJ_FLAG_IMMUTABLE); + return 0; } diff --git a/src/objects.h b/src/objects.h index 385f0e6d49..51bf3a5a0a 100644 --- a/src/objects.h +++ b/src/objects.h @@ -64,39 +64,6 @@ EXPORT_INLINE BOOL IS_FFE(Obj o) Int RegisterPackageTNUM(const char * name, Obj (*typeObjFunc)(Obj obj)); -/**************************************************************************** -** -*F NEXT_ENUM_EVEN( ) -*F START_ENUM_RANGE_EVEN( ) -*F END_ENUM_RANGE_ODD( ) -** -** 'NEXT_ENUM_EVEN' can be used in an enum to force to use the next -** available even integer value. -** -** 'START_ENUM_RANGE_EVEN' is a variant of 'START_ENUM_RANGE' which always -** sets the value of to the next even integer. -** -** 'END_ENUM_RANGE_ODD' is a variant of 'END_ENUM_RANGE' which always sets -** the value of to an odd integer. -*/ -#define NEXT_ENUM_EVEN(id) \ - _##id##_pre, \ - id = _##id##_pre + (_##id##_pre & 1) -#define START_ENUM_RANGE_EVEN(id) \ - NEXT_ENUM_EVEN(id), \ - _##id##_post = id - 1 -#define END_ENUM_RANGE_ODD(id) \ - _##id##_pre, \ - id = _##id##_pre - !(_##id##_pre & 1) - - -/**************************************************************************** -** -** IMMUTABLE is not a TNUM, but rather a bitmask. It is not defined via an -** enum because C++20 deprecates arithmetic between different enum types. -*/ -#define IMMUTABLE 1 - /**************************************************************************** ** *S T_ . . . . . . . . . . . . . . . . symbolic names for object types @@ -168,57 +135,57 @@ enum TNUM { END_ENUM_RANGE(LAST_CONSTANT_TNUM), // first mutable/immutable TNUM - START_ENUM_RANGE_EVEN(FIRST_IMM_MUT_TNUM), + START_ENUM_RANGE(FIRST_IMM_MUT_TNUM), // records - START_ENUM_RANGE_EVEN(FIRST_RECORD_TNUM), + START_ENUM_RANGE(FIRST_RECORD_TNUM), T_PREC, - END_ENUM_RANGE_ODD(LAST_RECORD_TNUM), + END_ENUM_RANGE(LAST_RECORD_TNUM), // lists - START_ENUM_RANGE_EVEN(FIRST_LIST_TNUM), + START_ENUM_RANGE(FIRST_LIST_TNUM), // plists - START_ENUM_RANGE_EVEN(FIRST_PLIST_TNUM), - NEXT_ENUM_EVEN(T_PLIST), - NEXT_ENUM_EVEN(T_PLIST_NDENSE), - NEXT_ENUM_EVEN(T_PLIST_DENSE), - NEXT_ENUM_EVEN(T_PLIST_DENSE_NHOM), - NEXT_ENUM_EVEN(T_PLIST_DENSE_NHOM_SSORT), - NEXT_ENUM_EVEN(T_PLIST_DENSE_NHOM_NSORT), - NEXT_ENUM_EVEN(T_PLIST_EMPTY), - NEXT_ENUM_EVEN(T_PLIST_HOM), - NEXT_ENUM_EVEN(T_PLIST_HOM_NSORT), - NEXT_ENUM_EVEN(T_PLIST_HOM_SSORT), - NEXT_ENUM_EVEN(T_PLIST_TAB), - NEXT_ENUM_EVEN(T_PLIST_TAB_NSORT), - NEXT_ENUM_EVEN(T_PLIST_TAB_SSORT), - NEXT_ENUM_EVEN(T_PLIST_TAB_RECT), - NEXT_ENUM_EVEN(T_PLIST_TAB_RECT_NSORT), - NEXT_ENUM_EVEN(T_PLIST_TAB_RECT_SSORT), - NEXT_ENUM_EVEN(T_PLIST_CYC), - NEXT_ENUM_EVEN(T_PLIST_CYC_NSORT), - NEXT_ENUM_EVEN(T_PLIST_CYC_SSORT), - NEXT_ENUM_EVEN(T_PLIST_FFE), - END_ENUM_RANGE_ODD(LAST_PLIST_TNUM), + START_ENUM_RANGE(FIRST_PLIST_TNUM), + T_PLIST, + T_PLIST_NDENSE, + T_PLIST_DENSE, + T_PLIST_DENSE_NHOM, + T_PLIST_DENSE_NHOM_SSORT, + T_PLIST_DENSE_NHOM_NSORT, + T_PLIST_EMPTY, + T_PLIST_HOM, + T_PLIST_HOM_NSORT, + T_PLIST_HOM_SSORT, + T_PLIST_TAB, + T_PLIST_TAB_NSORT, + T_PLIST_TAB_SSORT, + T_PLIST_TAB_RECT, + T_PLIST_TAB_RECT_NSORT, + T_PLIST_TAB_RECT_SSORT, + T_PLIST_CYC, + T_PLIST_CYC_NSORT, + T_PLIST_CYC_SSORT, + T_PLIST_FFE, + END_ENUM_RANGE(LAST_PLIST_TNUM), // other kinds of lists - NEXT_ENUM_EVEN(T_RANGE_NSORT), - NEXT_ENUM_EVEN(T_RANGE_SSORT), - NEXT_ENUM_EVEN(T_BLIST), - NEXT_ENUM_EVEN(T_BLIST_NSORT), - NEXT_ENUM_EVEN(T_BLIST_SSORT), - NEXT_ENUM_EVEN(T_STRING), - NEXT_ENUM_EVEN(T_STRING_NSORT), - NEXT_ENUM_EVEN(T_STRING_SSORT), + T_RANGE_NSORT, + T_RANGE_SSORT, + T_BLIST, + T_BLIST_NSORT, + T_BLIST_SSORT, + T_STRING, + T_STRING_NSORT, + T_STRING_SSORT, - END_ENUM_RANGE_ODD(LAST_LIST_TNUM), + END_ENUM_RANGE(LAST_LIST_TNUM), // object sets and maps - START_ENUM_RANGE_EVEN(FIRST_OBJSET_TNUM), - NEXT_ENUM_EVEN(T_OBJSET), - NEXT_ENUM_EVEN(T_OBJMAP), - END_ENUM_RANGE_ODD(LAST_OBJSET_TNUM), + START_ENUM_RANGE(FIRST_OBJSET_TNUM), + T_OBJSET, + T_OBJMAP, + END_ENUM_RANGE(LAST_OBJSET_TNUM), // last mutable/immutable TNUM END_ENUM_RANGE(LAST_IMM_MUT_TNUM), @@ -507,14 +474,15 @@ void MakeImmutable(Obj obj); ** This is an unsafe helper function, for use in functions installed as ** handlers in 'MakeImmutableObjFuncs' for internal objects tracking their ** mutability, i.e., in the range FIRST_IMM_MUT_TNUM to LAST_IMM_MUT_TNUM. -** It only modifies the TNUM, and does not make subobjects immutable. +** It only sets an object flag, and does not make subobjects immutable. */ EXPORT_INLINE void MakeImmutableNoRecurse(Obj obj) { - UInt type = TNUM_OBJ(obj); - GAP_ASSERT((FIRST_IMM_MUT_TNUM <= type) && (type <= LAST_IMM_MUT_TNUM)); - RetypeBag(obj, type | IMMUTABLE); + GAP_ASSERT((FIRST_IMM_MUT_TNUM <= TNUM_OBJ(obj)) && (TNUM_OBJ(obj) <= LAST_IMM_MUT_TNUM)); SET_OBJ_FLAG(obj, OBJ_FLAG_IMMUTABLE); +#ifdef HPCGAP + MakeBagPublic(obj); +#endif } @@ -543,8 +511,8 @@ EXPORT_INLINE BOOL IS_MUTABLE_OBJ(Obj obj) UInt tnum = TNUM_OBJ(obj); if (/*FIRST_CONSTANT_TNUM <= tnum &&*/ tnum <= LAST_CONSTANT_TNUM) return FALSE; - if (FIRST_IMM_MUT_TNUM <= tnum && tnum <= LAST_IMM_MUT_TNUM) - return !(tnum & IMMUTABLE); + if (tnum <= LAST_IMM_MUT_TNUM) + return !TEST_OBJ_FLAG(obj, OBJ_FLAG_IMMUTABLE); return ((*IsMutableObjFuncs[tnum])(obj)); } diff --git a/src/plist.c b/src/plist.c index bd2ce3707f..53b0a76bc8 100644 --- a/src/plist.c +++ b/src/plist.c @@ -613,10 +613,9 @@ static Obj TypePlistEmpty(Obj list) static Obj TypePlistHomHelper(Obj family, UInt tnum, UInt knr, Obj list) { // make sure tnum reflects mutability + knr = 2*(tnum - knr) + 1; if (!IS_MUTABLE_OBJ(list)) - tnum |= IMMUTABLE; - - knr = tnum - knr + 1; + knr++; // get the list types of that family Obj types = TYPES_LIST_FAM(family); diff --git a/tst/testinstall/kernel/blister.tst b/tst/testinstall/kernel/blister.tst index e8c7b500d3..498d9bfdb3 100644 --- a/tst/testinstall/kernel/blister.tst +++ b/tst/testinstall/kernel/blister.tst @@ -224,8 +224,8 @@ Error, UNITE_BLIST: must have the same length as (lengths ar\ e 3 and 2) gap> x:= [false,true,true,false];; gap> UniteBlist(Immutable(x), [true,true,false,false]); -Error, UNITE_BLIST: must be a mutable boolean list (not a list (boole\ -an,imm)) +Error, UNITE_BLIST: must be a mutable boolean list (not an immutable \ +list (boolean)) gap> x; [ false, true, true, false ] gap> UniteBlist(x, [true,true,false,false]); @@ -246,8 +246,8 @@ gap> UniteBlistList([1,2], [true,false], fail); Error, UNITE_BLIST_LIST: must be a small list (not the value 'fail') gap> x:= [true,true,false];; gap> UniteBlistList([1,2,3], Immutable(x), [2,3]); -Error, UNITE_BLIST_LIST: must be a mutable boolean list (not a list (b\ -oolean,imm)) +Error, UNITE_BLIST_LIST: must be a mutable boolean list (not an immuta\ +ble list (boolean)) gap> x; [ true, true, false ] gap> UniteBlistList([1,2,3], x, [2,3]); @@ -277,8 +277,8 @@ Error, INTER_BLIST: must have the same length as (lengths ar\ e 3 and 2) gap> x:= [false,true,true,false];; gap> IntersectBlist(Immutable(x), [true,true,false,false]); -Error, INTER_BLIST: must be a mutable boolean list (not a list (boole\ -an,imm)) +Error, INTER_BLIST: must be a mutable boolean list (not an immutable \ +list (boolean)) gap> x; [ false, true, true, false ] gap> IntersectBlist(x, [true,true,false,false]); @@ -295,8 +295,8 @@ Error, SUBTR_BLIST: must have the same length as (lengths ar\ e 3 and 2) gap> x:= [false,true,true,false];; gap> SubtractBlist(Immutable(x), [true,true,false,false]); -Error, SUBTR_BLIST: must be a mutable boolean list (not a list (boole\ -an,imm)) +Error, SUBTR_BLIST: must be a mutable boolean list (not an immutable \ +list (boolean)) gap> x; [ false, true, true, false ] gap> SubtractBlist(x, [true,true,false,false]); @@ -322,8 +322,8 @@ gap> FLIP_BLIST(fail); Error, FLIP_BLIST: must be a boolean list (not the value 'fail') gap> x:= [false,true,true,false];; gap> FlipBlist(Immutable(x)); -Error, FLIP_BLIST: must be a mutable boolean list (not a list (boolean\ -,imm)) +Error, FLIP_BLIST: must be a mutable boolean list (not an immutable li\ +st (boolean)) gap> x; [ false, true, true, false ] gap> FLIP_BLIST(x); @@ -346,8 +346,8 @@ gap> SET_ALL_BLIST(fail); Error, SET_ALL_BLIST: must be a boolean list (not the value 'fail') gap> x:= [false,true,true,false];; gap> SET_ALL_BLIST(Immutable(x)); -Error, SET_ALL_BLIST: must be a mutable boolean list (not a list (bool\ -ean,imm)) +Error, SET_ALL_BLIST: must be a mutable boolean list (not an immutable\ + list (boolean)) gap> x; [ false, true, true, false ] gap> SET_ALL_BLIST(x); @@ -368,8 +368,8 @@ gap> CLEAR_ALL_BLIST(fail); Error, CLEAR_ALL_BLIST: must be a boolean list (not the value 'fail') gap> x:= [false,true,true,false];; gap> CLEAR_ALL_BLIST(Immutable(x)); -Error, CLEAR_ALL_BLIST: must be a mutable boolean list (not a list (bo\ -olean,imm)) +Error, CLEAR_ALL_BLIST: must be a mutable boolean list (not an immutab\ +le list (boolean)) gap> x; [ false, true, true, false ] gap> CLEAR_ALL_BLIST(x); diff --git a/tst/testinstall/kernel/gap.tst b/tst/testinstall/kernel/gap.tst index ba82a4c3ca..f9aa274bd0 100644 --- a/tst/testinstall/kernel/gap.tst +++ b/tst/testinstall/kernel/gap.tst @@ -172,7 +172,7 @@ gap> TNUM_OBJ(Z(2)); gap> TNUM_OBJ(rec()); 20 gap> TNUM_OBJ([]); -34 +27 # gap> TNAM_OBJ(0); diff --git a/tst/testinstall/kernel/objects.tst b/tst/testinstall/kernel/objects.tst index 198c0ac1ee..755f256c45 100644 --- a/tst/testinstall/kernel/objects.tst +++ b/tst/testinstall/kernel/objects.tst @@ -28,7 +28,7 @@ Error, You can't make a component object from a boolean or fail gap> SET_TYPE_COMOBJ([], fail); Error, You can't make a component object from a empty plain list gap> SET_TYPE_COMOBJ(MakeImmutable(rec()), fail); -Error, You can't make a component object from a record (plain,imm) +Error, You can't make a component object from an immutable record (plain) gap> x:=rec();; gap> SET_TYPE_COMOBJ(x, t1c); @@ -113,6 +113,15 @@ gap> CLONE_OBJ(x, y); gap> x; IsMutable(x); [ 2 ] false +#@if not IsHPCGAP +gap> x := [ [ 1 ] ];; +gap> CLONE_OBJ(y, x); +gap> y; IsMutable(y); IsMutable(y[1]); IsIdenticalObj(x[1], y[1]); +[ [ 1 ] ] +true +true +false +#@fi # gap> STOP_TEST("kernel/objects.tst"); diff --git a/tst/testinstall/kernel/range.tst b/tst/testinstall/kernel/range.tst index b713bfc4ed..3c0f4bf89d 100644 --- a/tst/testinstall/kernel/range.tst +++ b/tst/testinstall/kernel/range.tst @@ -148,8 +148,8 @@ Error, INTER_RANGE: must be a range (not the value 'fail') gap> r := MakeImmutable([0..9]); [ 0 .. 9 ] gap> INTER_RANGE(r, [-1..1]); -Error, INTER_RANGE: must be a mutable range (not a list (range,ssort,\ -imm)) +Error, INTER_RANGE: must be a mutable range (not an immutable list (r\ +ange,ssort)) gap> r; [ 0 .. 9 ] diff --git a/tst/testinstall/list.tst b/tst/testinstall/list.tst index f4742a9834..f0d6faeee0 100644 --- a/tst/testinstall/list.tst +++ b/tst/testinstall/list.tst @@ -362,10 +362,10 @@ false gap> TNAM_OBJ(x); "plain list" gap> TNAM_OBJ(y); -"immutable plain list" +"plain list" gap> IsSSortedList(y);; gap> TNAM_OBJ(y); -"immutable dense non-homogeneous strictly-sorted plain list" +"dense non-homogeneous strictly-sorted plain list" # String, for a range gap> l := [5 .. 10]; From 883484657415ff15a0a458cb2677227bf11727ff Mon Sep 17 00:00:00 2001 From: Max Horn Date: Tue, 6 Oct 2026 22:17:21 +0200 Subject: [PATCH 18/19] hpc: serialize mutability of lists and records The serializer writes the tnum of an object, which no longer tells whether it is mutable, so immutable lists, strings and records came back mutable. Precede them by a tag. Assisted-by: Claude Code (Opus 5.5) --- src/hpc/serialize.c | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/src/hpc/serialize.c b/src/hpc/serialize.c index eeee62f065..5dfd23c042 100644 --- a/src/hpc/serialize.c +++ b/src/hpc/serialize.c @@ -27,8 +27,6 @@ #include -// TODO/FIXME: serialize mutability information again somehow? - typedef struct SerializerState { Obj stack; Obj obj; @@ -237,6 +235,10 @@ static inline BOOL IsBasicObj(Obj obj) #define OBJ_BACKREF(x) ((Obj)((x) << 2)) #define BACKREF_OBJ(obj) (((UInt)(obj)) >> 2) +// Tag preceding an immutable list, record, object set or object map; their +// tnums do not record mutability. +#define T_IMMUTABLE_TAG 254 + static int SerializedAlready(SerializerState * state, Obj obj) { Obj ref = LookupObjMap(state->registry, obj); @@ -270,12 +272,21 @@ static void SerializeObj(SerializerState * state, Obj obj) WriteImmediateObj(state, INTOBJ_INT(0)); return; } - SerializationFuncByTNum[TNUM_OBJ(obj)](state, obj); + UInt tnum = TNUM_OBJ(obj); + if (FIRST_IMM_MUT_TNUM <= tnum && tnum <= LAST_IMM_MUT_TNUM && + !IS_MUTABLE_OBJ(obj)) + WriteTNum(state, T_IMMUTABLE_TAG); + SerializationFuncByTNum[tnum](state, obj); } static Obj DeserializeObj(DeserializerState * state) { UInt tnum = ReadTNum(state); + if (tnum == T_IMMUTABLE_TAG) { + Obj obj = DeserializeObj(state); + MakeImmutableNoRecurse(obj); + return obj; + } return DeserializationFuncByTNum[tnum](state, tnum); } From 740c5243a213893abc6092f14836f8c74b890905 Mon Sep 17 00:00:00 2001 From: Max Horn Date: Tue, 6 Oct 2026 22:17:21 +0200 Subject: [PATCH 19/19] hpc: keep immutability when copying traversed objects The copies are allocated with the tnum of the original, which used to include its mutability. Assisted-by: Claude Code (Opus 5.5) --- src/hpc/traverse.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/hpc/traverse.c b/src/hpc/traverse.c index 864ef5a13b..a39968570c 100644 --- a/src/hpc/traverse.c +++ b/src/hpc/traverse.c @@ -325,6 +325,8 @@ Obj CopyReachableObjectsFrom(Obj obj, int delimited, int asList, int imm) Obj original = traversed[i]; Obj copy; copy = NewBag(TNUM_BAG(original), SIZE_BAG(original)); + if (TEST_BAG_FLAG(original, OBJ_FLAG_IMMUTABLE)) + SET_BAG_FLAG(copy, OBJ_FLAG_IMMUTABLE); SET_ELM_PLIST(traversal.copyMap, loc, copy); copies[i] = copy; } @@ -366,6 +368,8 @@ Obj CopyTraversed(Obj traversedList) UInt loc = FindTraversedObj(&traversal, original); Obj copy; copy = NewBag(TNUM_BAG(original), SIZE_BAG(original)); + if (TEST_BAG_FLAG(original, OBJ_FLAG_IMMUTABLE)) + SET_BAG_FLAG(copy, OBJ_FLAG_IMMUTABLE); SET_ELM_PLIST(traversal.copyMap, loc, copy); copies[i] = copy; }