diff --git a/lib/mat8bit.gi b/lib/mat8bit.gi index 18eedcbc3f..d87ea86861 100644 --- a/lib/mat8bit.gi +++ b/lib/mat8bit.gi @@ -821,10 +821,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) in 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..4864ed0fd5 100644 --- a/src/bags.c +++ b/src/bags.c @@ -60,12 +60,6 @@ void PrecheckRetypeBag(Bag bag, UInt new_type) 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); - } } } #endif @@ -74,32 +68,12 @@ void PrecheckRetypeBag(Bag bag, UInt new_type) // 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; - } 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); } #endif diff --git a/src/blister.c b/src/blister.c index e4b76c911e..1d1b4fdd9f 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); @@ -1701,11 +1701,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, "" } }; @@ -1890,25 +1887,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 -#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; - TypeObjFuncs[ T_BLIST_NSORT +IMMUTABLE ] = TypeBlistNSort; TypeObjFuncs[ T_BLIST_SSORT ] = TypeBlistSSort; - TypeObjFuncs[ T_BLIST_SSORT +IMMUTABLE ] = TypeBlistSSort; // initialise list tables InitClearFiltsTNumsFromTable ( ClearFiltsTab ); @@ -1918,74 +1904,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 ); 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/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); } diff --git a/src/hpc/threadapi.c b/src/hpc/threadapi.c index 4abb6f6a5e..a5010699eb 100644 --- a/src/hpc/threadapi.c +++ b/src/hpc/threadapi.c @@ -2023,7 +2023,7 @@ MigrateObjects(int count, Obj * objects, Region * target, int retype) // they need to be sorted, as sorting upon access may prove impossible. for (i = 0; i < count; i++) { Obj obj = objects[i]; - if (TNUM_OBJ(obj) == T_PREC) { + if (TNUM_OBJ(obj) == T_PREC && IS_MUTABLE_OBJ(obj)) { SortPRecRNam(obj); } SET_REGION(obj, target); diff --git a/src/listfunc.c b/src/listfunc.c index 5da324d25a..4d39d0fe49 100644 --- a/src/listfunc.c +++ b/src/listfunc.c @@ -64,7 +64,7 @@ void AddPlist3(Obj list, Obj obj, Int pos) { UInt len; - if (!IS_PLIST_MUTABLE(list)) { + if (!IS_MUTABLE_OBJ(list)) { ErrorMayQuit("List Assignment: must be a mutable list", 0, 0); } // in order to be optimistic when building list call assignment @@ -162,7 +162,7 @@ static Obj RemPlist(Obj list) Int pos; Obj removed; - if ( ! IS_PLIST_MUTABLE(list) ) { + if ( ! IS_MUTABLE_OBJ(list) ) { ErrorMayQuit("Remove: must be a mutable list", 0, 0); } pos = LEN_PLIST( list ); diff --git a/src/listoper.c b/src/listoper.c index a30e7b7af9..57f7477013 100644 --- a/src/listoper.c +++ b/src/listoper.c @@ -335,8 +335,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) @@ -398,8 +397,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) @@ -494,8 +492,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) @@ -549,8 +546,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) @@ -2162,11 +2158,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; } @@ -2180,11 +2176,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; } @@ -2205,8 +2201,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; } } diff --git a/src/lists.c b/src/lists.c index beed2d5149..87db853e50 100644 --- a/src/lists.c +++ b/src/lists.c @@ -2201,9 +2201,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 @@ -2213,16 +2212,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; } } @@ -2288,12 +2283,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]); } @@ -2311,7 +2305,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 = 0; } @@ -2393,39 +2387,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 = 0; - } - 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 = 0; - } - - 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 = 0; - } - - 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 = 0; - } - - } - } - - 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 5b7a0f832c..19a10560e1 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; } } diff --git a/src/objects.c b/src/objects.c index d76f74d6bb..7a48e1f226 100644 --- a/src/objects.c +++ b/src/objects.c @@ -194,6 +194,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 @@ -414,7 +417,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) ); @@ -812,9 +815,10 @@ void (*MakeImmutableObjFuncs[LAST_REAL_TNUM+1])( Obj ); void MakeImmutable( Obj obj ) { - if (IS_MUTABLE_OBJ( obj )) - { - (*(MakeImmutableObjFuncs[TNUM_OBJ(obj)]))(obj); + if (IS_MUTABLE_OBJ( obj )) { + (*(MakeImmutableObjFuncs[TNUM_OBJ(obj)]))(obj); + SET_OBJ_FLAG(obj, OBJ_FLAG_IMMUTABLE); + GAP_ASSERT(!IS_MUTABLE_OBJ(obj)); } } @@ -1180,6 +1184,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: diff --git a/src/objects.h b/src/objects.h index 5dde781835..4f26455696 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) - - -/**************************************************************************** -** -*/ -enum { - IMMUTABLE = 1 // IMMUTABLE is not a TNUM, but rather a bitmask -}; - /**************************************************************************** ** *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), @@ -326,6 +293,9 @@ enum { #ifdef HPCGAP OBJ_FLAG_TESTED = (1 << 1), #endif + + // OBJ_FLAG_IMMUTABLE is used to mark immutable objects. + OBJ_FLAG_IMMUTABLE = (1 << 2), }; @@ -488,25 +458,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 @@ -521,13 +472,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 } @@ -556,8 +509,10 @@ 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 (TEST_OBJ_FLAG(obj, OBJ_FLAG_IMMUTABLE)) + return FALSE; + if (tnum <= LAST_IMM_MUT_TNUM) + return TRUE; return ((*IsMutableObjFuncs[tnum])(obj)); } diff --git a/src/objset.c b/src/objset.c index d72eaa22c3..7de6d401d3 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 diff --git a/src/plist.c b/src/plist.c index c05f9b147a..169a49b78c 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 @@ -205,7 +204,7 @@ static Obj TYPE_LIST_EMPTY_MUTABLE; static Obj TYPE_LIST_EMPTY_IMMUTABLE; static Obj TYPE_LIST_HOM; -static Obj TypePlistWithKTNum( Obj list, UInt *ktnum ); +static Obj TypePlistWithKTNum(Obj list, UInt * ktnum); static Int KTNumPlist(Obj list, Obj * famfirst) { @@ -245,7 +244,7 @@ static Int KTNumPlist(Obj list, Obj * famfirst) // special case for empty list if ( lenList == 0 ) { - res = IS_MUTABLE_OBJ(list) ? T_PLIST_EMPTY : T_PLIST_EMPTY+IMMUTABLE; + res = T_PLIST_EMPTY; RetypeBagIfWritable(list, res); if (famfirst != (Obj *) 0) *famfirst = (Obj) 0; @@ -266,7 +265,7 @@ static Int KTNumPlist(Obj list, Obj * famfirst) #endif else if (TEST_OBJ_FLAG(elm, OBJ_FLAG_TESTING)) { isHom = 0; - areMut = IS_PLIST_MUTABLE(elm); + areMut = IS_MUTABLE_OBJ(elm); isTable = 0; } else { @@ -331,7 +330,7 @@ static Int KTNumPlist(Obj list, Obj * famfirst) #endif else if (TEST_OBJ_FLAG(elm, OBJ_FLAG_TESTING)) { isHom = 0; - areMut = (areMut || IS_PLIST_MUTABLE(elm)); + areMut = (areMut || IS_MUTABLE_OBJ(elm)); isTable = 0; isRect = 0; } @@ -432,7 +431,6 @@ static Int KTNumPlist(Obj list, Obj * famfirst) SET_FILT_LIST( list, areMut ? FN_IS_DENSE : FN_IS_RECT ); res = T_PLIST_TAB_RECT; } - res = res + ( IS_MUTABLE_OBJ(list) ? 0 : IMMUTABLE ); return res; } @@ -560,13 +558,12 @@ static Int KTNumHomPlist(Obj list) res = T_PLIST_HOM; finish: - res = res + ( IS_MUTABLE_OBJ(list) ? 0 : IMMUTABLE ); return res; } static Obj TypePlist(Obj list) { - return TypePlistWithKTNum( list, (UInt *) 0); + return TypePlistWithKTNum(list, 0); } static Obj TypePlistNDense(Obj list) @@ -613,8 +610,10 @@ static Obj TypePlistEmpty(Obj list) static Obj TypePlistHomHelper(Obj family, UInt tnum, UInt knr, Obj list) { - GAP_ASSERT(knr <= tnum); - knr = tnum - knr + 1; + // make sure tnum reflects mutability + knr = 2*(tnum - knr) + 1; + if (!IS_MUTABLE_OBJ(list)) + knr++; // get the list types of that family Obj types = TYPES_LIST_FAM(family); @@ -669,24 +668,18 @@ static Obj TypePlistWithKTNum ( *ktnum = tnum; // handle special cases - switch (tnum) - { - case T_PLIST_NDENSE: - case T_PLIST_NDENSE+IMMUTABLE: + switch (tnum) { + case T_PLIST_NDENSE: return TypePlistNDense(list); - case T_PLIST_DENSE_NHOM: - case T_PLIST_DENSE_NHOM+IMMUTABLE: + case T_PLIST_DENSE_NHOM: return TypePlistDenseNHom(list); - case T_PLIST_DENSE_NHOM_SSORT: - case T_PLIST_DENSE_NHOM_SSORT+IMMUTABLE: + case T_PLIST_DENSE_NHOM_SSORT: return TypePlistDenseNHomSSort(list); - case T_PLIST_DENSE_NHOM_NSORT: - case T_PLIST_DENSE_NHOM_NSORT+IMMUTABLE: + case T_PLIST_DENSE_NHOM_NSORT: return TypePlistDenseNHomNSort(list); - case T_PLIST_EMPTY: - case T_PLIST_EMPTY+IMMUTABLE: + case T_PLIST_EMPTY: return TypePlistEmpty(list); - default: ; // fall through into the rest of the function + default: ; // fall through into the rest of the function } // handle homogeneous list @@ -759,20 +752,14 @@ static Obj TypePlistFfe(Obj list) ** 'ShallowCopyPlist' only copies up to the logical length, the result is ** always a mutable list. */ -Obj ShallowCopyPlist ( - Obj list ) +Obj ShallowCopyPlist(Obj list) { Obj new; UInt len; // make the new object and copy the contents len = LEN_PLIST(list); - if ( ! IS_PLIST_MUTABLE(list) ) { - new = NEW_PLIST( TNUM_OBJ(list) - IMMUTABLE, len ); - } - else { - new = NEW_PLIST( 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; @@ -1297,6 +1284,7 @@ static Obj ElmsPlistDense(Obj list, Obj poss) Int pos; // as integer Int inc; // increment in a range Int i; // loop variable + Int tnum; // TNUM of // select no element if ( LEN_LIST(poss) == 0 ) { @@ -1312,22 +1300,23 @@ static Obj ElmsPlistDense(Obj list, Obj poss) // get the length of lenPoss = LEN_LIST( poss ); + // get the (mutable) tnum of list + tnum = TNUM_OBJ(list); + // make the result list // try to assert as many properties as possible if (HAS_FILT_LIST(list, FN_IS_SSORT) && HAS_FILT_LIST(poss, FN_IS_SSORT)) { - elms = NEW_PLIST( MUTABLE_TNUM(TNUM_OBJ(list)), lenPoss); + elms = NEW_PLIST(tnum, lenPoss); RESET_FILT_LIST( elms, FN_IS_NHOMOG); // can't deduce this one } else if (HAS_FILT_LIST(list, FN_IS_RECT)) elms = NEW_PLIST( T_PLIST_TAB_RECT, lenPoss ); else if (HAS_FILT_LIST(list, FN_IS_TABLE)) elms = NEW_PLIST( T_PLIST_TAB, lenPoss ); - else if (T_PLIST_CYC <= TNUM_OBJ(list) && TNUM_OBJ(list) <= - T_PLIST_CYC_SSORT+IMMUTABLE) + else if (T_PLIST_CYC <= tnum && tnum <= T_PLIST_CYC_SSORT) elms = NEW_PLIST( T_PLIST_CYC, lenPoss ); - else if (T_PLIST_FFE <= TNUM_OBJ(list) && TNUM_OBJ(list) <= - T_PLIST_FFE+IMMUTABLE) + else if (T_PLIST_FFE <= tnum && tnum <= T_PLIST_FFE) elms = NEW_PLIST( T_PLIST_FFE, lenPoss ); else if (HAS_FILT_LIST(list, FN_IS_HOMOG)) elms = NEW_PLIST( T_PLIST_HOM, lenPoss ); @@ -1391,19 +1380,20 @@ static Obj ElmsPlistDense(Obj list, Obj poss) (Int)pos + (lenPoss - 1) * inc, 0); } + // get the (mutable) tnum of list + tnum = TNUM_OBJ(list); + // make the result list // try to assert as many properties as possible if ( HAS_FILT_LIST(list, FN_IS_SSORT) && inc > 0 ) - elms = NEW_PLIST( MUTABLE_TNUM(TNUM_OBJ(list)), lenPoss ); + elms = NEW_PLIST( tnum, lenPoss ); else if (HAS_FILT_LIST(list, FN_IS_RECT)) elms = NEW_PLIST( T_PLIST_TAB_RECT, lenPoss ); else if (HAS_FILT_LIST(list, FN_IS_TABLE)) elms = NEW_PLIST( T_PLIST_TAB, lenPoss ); - else if (T_PLIST_CYC <= TNUM_OBJ(list) && TNUM_OBJ(list) <= - T_PLIST_CYC_SSORT+IMMUTABLE) + else if (T_PLIST_CYC <= tnum && tnum <= T_PLIST_CYC_SSORT) elms = NEW_PLIST( T_PLIST_CYC, lenPoss ); - else if (T_PLIST_FFE <= TNUM_OBJ(list) && TNUM_OBJ(list) <= - T_PLIST_FFE+IMMUTABLE) + else if (T_PLIST_FFE <= tnum && tnum <= T_PLIST_FFE) elms = NEW_PLIST( T_PLIST_FFE, lenPoss ); else if (HAS_FILT_LIST(list, FN_IS_HOMOG)) elms = NEW_PLIST( T_PLIST_HOM, lenPoss ); @@ -2383,7 +2373,7 @@ static Obj FuncASS_PLIST_DEFAULT(Obj self, Obj plist, Obj pos, Obj val) Int p; p = GetPositiveSmallInt("List Assignment", pos); - if (!IS_PLIST(plist) || !IS_PLIST_MUTABLE(plist)) { + if (!IS_PLIST(plist) || !IS_MUTABLE_OBJ(plist)) { RequireArgumentEx(0, plist, "", "must be a mutable plain list"); } @@ -2493,64 +2483,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, "" } }; @@ -3257,23 +3228,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 @@ -3313,32 +3280,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 ); @@ -3352,25 +3310,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 @@ -3384,69 +3339,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; } @@ -3461,11 +3403,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; } @@ -3473,179 +3415,114 @@ 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 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/plist.h b/src/plist.h index 52a9b2d87f..2c241fcd1a 100644 --- a/src/plist.h +++ b/src/plist.h @@ -50,14 +50,14 @@ EXPORT_INLINE Obj NEW_PLIST(UInt type, Int plen) EXPORT_INLINE Obj NEW_PLIST_IMM(UInt type, Int plen) { - return NEW_PLIST(type | IMMUTABLE, plen); + Obj list = NEW_PLIST(type, plen); + MakeImmutableNoRecurse(list); + return list; } EXPORT_INLINE Obj NEW_PLIST_WITH_MUTABILITY(Int mut, UInt type, Int plen) { - if (!mut) - type |= IMMUTABLE; - return NEW_PLIST(type, plen); + return mut ? NEW_PLIST(type, plen) : NEW_PLIST_IMM(type, plen); } /**************************************************************************** @@ -232,16 +232,6 @@ EXPORT_INLINE BOOL IS_DENSE_PLIST(Obj list) TNUM_OBJ(list) <= LAST_PLIST_TNUM; } -/**************************************************************************** -** -*F IS_PLIST_MUTABLE( ) . . . . . . . . . . . is a plain list mutable -*/ -EXPORT_INLINE BOOL IS_PLIST_MUTABLE(Obj list) -{ - GAP_ASSERT(IS_PLIST(list)); - return !((TNUM_OBJ(list) - T_PLIST) % 2); -} - /**************************************************************************** ** *F AssPlist( , , ) . . . . . . . . . assign to a plain list diff --git a/src/pperm.cc b/src/pperm.cc index 921c204d9e..3734f1ff29 100644 --- a/src/pperm.cc +++ b/src/pperm.cc @@ -247,7 +247,7 @@ static inline Obj DOM_PPERM(Obj f) static inline void SET_IMG_PPERM(Obj f, Obj img) { GAP_ASSERT(IS_PPERM(f)); - GAP_ASSERT(IS_PLIST(img) && !IS_PLIST_MUTABLE(img)); + GAP_ASSERT(IS_PLIST(img) && !IS_MUTABLE_OBJ(img)); GAP_ASSERT(DOM_PPERM(f) == NULL || LEN_PLIST(img) == LEN_PLIST(DOM_PPERM(f))); // TODO check entries of img are valid @@ -257,7 +257,7 @@ static inline void SET_IMG_PPERM(Obj f, Obj img) static inline void SET_DOM_PPERM(Obj f, Obj dom) { GAP_ASSERT(IS_PPERM(f)); - GAP_ASSERT(IS_PLIST(dom) && !IS_PLIST_MUTABLE(dom)); + GAP_ASSERT(IS_PLIST(dom) && !IS_MUTABLE_OBJ(dom)); GAP_ASSERT(IMG_PPERM(f) == NULL || LEN_PLIST(dom) == LEN_PLIST(IMG_PPERM(f))); // TODO check entries of img are valid diff --git a/src/precord.c b/src/precord.c index d78601e7fa..bccdec1d0c 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); } @@ -764,7 +764,6 @@ void MarkPRecSubBags(Obj bag, void * ref) */ static StructBagNames BagNames[] = { { T_PREC, "record (plain)" }, - { T_PREC +IMMUTABLE, "record (plain,imm)" }, { -1, "" } }; @@ -793,12 +792,6 @@ static Int InitKernel ( InitBagNamesFromTable( BagNames ); 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 ); @@ -806,54 +799,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; 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.c b/src/range.c index 3c80522a0b..70614f5d40 100644 --- a/src/range.c +++ b/src/range.c @@ -951,9 +951,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, "" } }; @@ -1096,15 +1094,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 ); - -#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", @@ -1120,9 +1110,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 ); @@ -1131,25 +1119,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 @@ -1158,9 +1138,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 ); @@ -1180,37 +1158,21 @@ static Int InitKernel ( // 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; @@ -1218,33 +1180,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; } 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/set.c b/src/set.c index 1441f0b60e..34b77ebc5c 100644 --- a/src/set.c +++ b/src/set.c @@ -532,7 +532,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)) @@ -695,7 +695,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); diff --git a/src/stringobj.c b/src/stringobj.c index 9e70b53f53..9a91d44f0e 100644 --- a/src/stringobj.c +++ b/src/stringobj.c @@ -1828,11 +1828,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, "" } }; @@ -2038,13 +2035,9 @@ 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 - for ( t1 = T_STRING; t1 <= T_STRING_SSORT; t1 += 2 ) { - MakeBagTypePublic( t1 + IMMUTABLE ); - } MakeBagTypePublic(T_CHAR); #endif @@ -2072,11 +2065,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 ); @@ -2101,78 +2091,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 @@ -2182,15 +2150,11 @@ 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; t1++ ) { diff --git a/src/stringobj.h b/src/stringobj.h index 9b28f61107..ff68e7b5a9 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); } diff --git a/src/trans.cc b/src/trans.cc index 2558a37693..8792e520b0 100644 --- a/src/trans.cc +++ b/src/trans.cc @@ -233,14 +233,14 @@ static inline Obj EXT_TRANS(Obj f) static inline void SET_IMG_TRANS(Obj f, Obj img) { GAP_ASSERT(IS_TRANS(f)); - GAP_ASSERT(img == NULL || (IS_PLIST(img) && !IS_PLIST_MUTABLE(img))); + GAP_ASSERT(img == NULL || (IS_PLIST(img) && !IS_MUTABLE_OBJ(img))); ADDR_OBJ(f)[0] = img; } static inline void SET_KER_TRANS(Obj f, Obj ker) { GAP_ASSERT(IS_TRANS(f)); - GAP_ASSERT(ker == NULL || (IS_PLIST(ker) && !IS_PLIST_MUTABLE(ker) && + GAP_ASSERT(ker == NULL || (IS_PLIST(ker) && !IS_MUTABLE_OBJ(ker) && LEN_PLIST(ker) == DEG_TRANS(f))); ADDR_OBJ(f)[1] = ker; } @@ -3366,7 +3366,7 @@ static Obj FuncOnPosIntSetsTrans(Obj self, Obj set, Obj f, Obj n) } if (IS_PLIST(set)) { - res = NEW_PLIST_WITH_MUTABILITY(IS_PLIST_MUTABLE(set), T_PLIST_CYC_SSORT, len); + res = NEW_PLIST_WITH_MUTABILITY(IS_MUTABLE_OBJ(set), T_PLIST_CYC_SSORT, len); SET_LEN_PLIST(res, len); } else { diff --git a/src/vecffe.c b/src/vecffe.c index 6b68078c77..059f36e047 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(TNUM_OBJ(vec), 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); diff --git a/src/vecgf2.c b/src/vecgf2.c index 69f1c9e8a1..af08fbaaf3 100644 --- a/src/vecgf2.c +++ b/src/vecgf2.c @@ -1373,7 +1373,7 @@ static void ConvGF2Vec(Obj list) // retype and resize bag ResizeWordSizedBag(list, SIZE_PLEN_GF2VEC(len)); SET_LEN_GF2VEC(list, len); - if (IS_PLIST_MUTABLE(list)) { + if (IS_MUTABLE_OBJ(list)) { SetTypeDatObj(list, TYPE_LIST_GF2VEC); } else { @@ -1459,7 +1459,7 @@ static Obj NewGF2Vec(Obj list) } // mutability should be inherited from the argument - if (IS_PLIST_MUTABLE(list)) + if (IS_MUTABLE_OBJ(list)) SetTypeDatObj(res, TYPE_LIST_GF2VEC); else SetTypeDatObj(res, TYPE_LIST_GF2VEC_IMM); @@ -1515,7 +1515,7 @@ static Obj FuncCONV_GF2MAT(Obj self, Obj list) SET_ELM_PLIST(list, i + 1, tmp); } SET_ELM_PLIST(list, 1, INTOBJ_INT(len)); - mut = IS_PLIST_MUTABLE(list); + mut = IS_MUTABLE_OBJ(list); RetypeBag(list, T_POSOBJ); SET_TYPE_POSOBJ(list, mut ? TYPE_LIST_GF2MAT : TYPE_LIST_GF2MAT_IMM); return (Obj)0; diff --git a/src/vector.c b/src/vector.c index 8c72b59b19..21cf8da26a 100644 --- a/src/vector.c +++ b/src/vector.c @@ -640,7 +640,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); @@ -654,7 +654,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); @@ -695,11 +695,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; diff --git a/tst/testinstall/kernel/blister.tst b/tst/testinstall/kernel/blister.tst index e8c7b500d3..0f45a53f3b 100644 --- a/tst/testinstall/kernel/blister.tst +++ b/tst/testinstall/kernel/blister.tst @@ -225,7 +225,7 @@ 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)) +an)) gap> x; [ false, true, true, false ] gap> UniteBlist(x, [true,true,false,false]); @@ -247,7 +247,7 @@ 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)) +oolean)) gap> x; [ true, true, false ] gap> UniteBlistList([1,2,3], x, [2,3]); @@ -278,7 +278,7 @@ 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)) +an)) gap> x; [ false, true, true, false ] gap> IntersectBlist(x, [true,true,false,false]); @@ -296,7 +296,7 @@ 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)) +an)) gap> x; [ false, true, true, false ] gap> SubtractBlist(x, [true,true,false,false]); @@ -323,7 +323,7 @@ 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)) +)) gap> x; [ false, true, true, false ] gap> FLIP_BLIST(x); @@ -347,7 +347,7 @@ 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)) +ean)) gap> x; [ false, true, true, false ] gap> SET_ALL_BLIST(x); @@ -369,7 +369,7 @@ 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)) +olean)) 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 e9dc5769de..50c2a50a1f 100644 --- a/tst/testinstall/kernel/gap.tst +++ b/tst/testinstall/kernel/gap.tst @@ -169,7 +169,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 88dc4df441..1635523156 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); diff --git a/tst/testinstall/kernel/range.tst b/tst/testinstall/kernel/range.tst index ce1b1b3a50..b74b01a243 100644 --- a/tst/testinstall/kernel/range.tst +++ b/tst/testinstall/kernel/range.tst @@ -100,8 +100,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 a list (range,ssort)\ +) gap> r; [ 0 .. 9 ] diff --git a/tst/testinstall/list.tst b/tst/testinstall/list.tst index 65a8e0fcd7..21f6759db9 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]; diff --git a/tst/testinstall/listindex.tst b/tst/testinstall/listindex.tst index 0c4571b94a..7d4e16d381 100644 --- a/tst/testinstall/listindex.tst +++ b/tst/testinstall/listindex.tst @@ -227,8 +227,8 @@ gap> l := [];; Append(l,l); l; gap> l := [1,2,3,4];; Append(l,l); l; [ 1, 2, 3, 4, 1, 2, 3, 4 ] gap> Append(Immutable([1,2,3]), [1,2,3]); -Error, FuncAPPEND_LIST_INTR: must be a mutable list (not an immutable \ -plain list of cyclotomics) +Error, FuncAPPEND_LIST_INTR: must be a mutable list (not a plain list \ +of cyclotomics) gap> Append([1,2,3], () ); Error, FuncAPPEND_LIST_INTR: must be a small list (not a permutation (\ small)) @@ -284,8 +284,8 @@ gap> CopyListEntries(s,3,-1,"abc",4,-3,2); Error, COPY_LIST_ENTRIES: must be a mutable plain list (not a list (st\ ring)) gap> CopyListEntries(s,3,-1,Immutable([1,2,3]),4,-3,2); -Error, COPY_LIST_ENTRIES: must be a mutable plain list (not an immutab\ -le plain list of cyclotomics) +Error, COPY_LIST_ENTRIES: must be a mutable plain list (not a plain li\ +st of cyclotomics) gap> CopyListEntries(s, "cheese", 1, l, 1, 1, 2); Error, CopyListEntries: must be a small integer (not a list (string)\ )