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/blister.c b/src/blister.c index 995affab5e..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); @@ -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,25 +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 -#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 ); @@ -1924,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 ); 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/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/hpc/serialize.c b/src/hpc/serialize.c index 3dcd730d93..5dfd23c042 100644 --- a/src/hpc/serialize.c +++ b/src/hpc/serialize.c @@ -235,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); @@ -268,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); } @@ -585,8 +598,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 +724,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 +751,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 +774,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 +868,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 +1067,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/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; } 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; } } diff --git a/src/lists.c b/src/lists.c index 9eeaf30344..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; } } @@ -2416,12 +2411,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 +2433,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 +2515,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; } } diff --git a/src/objects.c b/src/objects.c index f919689be6..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); @@ -422,7 +427,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) ); @@ -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 f8145453b1..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), @@ -326,6 +293,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), }; @@ -488,25 +460,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 +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 } @@ -556,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/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 diff --git a/src/plist.c b/src/plist.c index a96f0735e3..53b0a76bc8 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 @@ -233,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 @@ -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; @@ -452,7 +451,7 @@ static Int KTNumHomPlist(Obj list) #ifdef HPCGAP if (!CheckWriteAccess(list)) { - return MUTABLE_TNUM(TNUM_OBJ(list)); + return TNUM_OBJ(list); } #endif @@ -614,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); @@ -659,7 +657,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 @@ -763,7 +761,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; @@ -1305,7 +1303,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 @@ -1385,7 +1383,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 @@ -2441,64 +2439,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 +3184,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 +3236,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 +3266,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 +3295,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 +3359,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,179 +3371,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/precord.c b/src/precord.c index 57b5b9dc58..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,12 +791,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 ); @@ -805,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; 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 02d0550400..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,15 +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 ); - -#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", @@ -1162,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 ); @@ -1173,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 @@ -1200,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 ); @@ -1221,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; @@ -1270,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; } 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 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); diff --git a/src/stringobj.c b/src/stringobj.c index 8ed81dceab..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,13 +2034,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 @@ -2071,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 ); @@ -2100,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 @@ -2181,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; } 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); } 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); 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; 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];