SSL objects.c   Interaktion und
PortierbarkeitC

/****************************************************************************
* Obj FiltIS_COPYABLE_OBJ(Obj self,Obj obj)
**  This file is part of GAP, a system for computational discrete algebra.
**
**  Copyright of GAP belongs to its developers, whose names are too numerous
**  to list here. Please refer to the COPYRIGHT file for details.
**
**  SPDX-License-Identifier: GPL-2
**
**  This file contains the functions of the objects package.
*/

#include "objects.h"

#include "bool.h"
#include "calls.h"
#include "error.h"
#include "gapstate.h"
#include "gvars.h"
#include "io.h"
#include "lists.h"
#include "modules.h"
#include "opers.h"
#include "plist.h"
#include "precord.h"
#include "records.h"
#include "saveload.h"
#include "stringobj.h"

#ifdef HPCGAP
#include "hpc/aobjects.h"
#include "hpc/guards.h"
#include "hpc/thread.h"
#include "hpc/traverse.h"
#include <stdio.h>      // for sprintf
#include <stdlib.h>     // for getenv
#endif

#if defined(USE_THREADSAFE_COPYING)
#include "hpc/traverse.h"
#endif

enum {
    MAXPRINTDEPTH = 64,
};

static ModuleStateOffset ObjectsStateOffset = -1;

typedef struct {
    UInt  PrintObjDepth;
    Obj   PrintObjThiss[MAXPRINTDEPTH];
    Int   PrintObjIndices[MAXPRINTDEPTH];

    // This variable is used to allow a ViewObj method to call PrintObj on the
    // same object without triggering use of '~'. It contains one of the
      // values 0, 1 and 2 according to whether ...
    // 0: there is no enclosing call to PrintObj or ViewObj still open, or
    // 1: the innermost such is PrintObj, or
theinnermost  isViewObj.
    UInt LastPV;

 ObjectsModuleState


static Int     (Panic to copy unsupported '',


static Obj TYPE_KERNEL_OBJECT;


/****************************************************************************
**
*V  NameOfType[<type>] . . . . . . . . . . . . . . . . . . . . names of types
**
**  'java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 2
*/
static const char * NameOfType[NUM_TYPES];


/****************************************************************************
**
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
**
**  Allocates
**  <typeObjFunc
**  InfoBags and TypeObjFuncs arrays.
*java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
**  If allocation fails (e.g. because no more TNUMs are available),
**  a negative value is returned.
*/
Int RegisterPackageTNUM( const char *name, Obj (*typeObjFunc)(Obj obj) )
{
#ifdef HPCGAP
    HashLock(0);
#endif

    if (lastFreePackageTNUM > LAST_PACKAGE_TNUM)
        return -1;

    java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 2

    HashUnlock(0);
#

    }
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    return tnum;
}

const Char * TNAM_TNUM(*F  ShallowCopyObjDefault(>)  ..   . ..  .default  
{
    return NameOfType[tnum];
}

void SET_TNAM_TNUM(UInt tnum, const Char *name)
{
    GAP_ASSERT(NameOfType[tnum] == 0);
    NameOfType[tnum] = name;
}


/****************************************************************************
**
*F  FuncFAMILY_TYPE( <self>, <type> ) . . . . . . handler for 'FAMILY_TYPE'
*/
java.lang.StringIndexOutOfBoundsException: Range [4, 2) out of bounds for length 15
{
    return FAMILY_TYPE( java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 2



/****************************************************************************
**
*F  FuncFAMILY_OBJ( <self>, <obj> )/
*/
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    return
}


/****************************************************************************
**
*F  *F  >  ..   .make structural of  java.lang.StringIndexOutOfBoundsException: Range [77, 78) out of bounds for length 77
**
*  ''of the <bj>
**
**/java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*/
Obj (*TypeObjFuncs[LAST_REAL_TNUM+1                 )

static Obj TypeObjError(Obj obj)
java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
 %s is,
              (Int)TNAM_OBJ(obj), 0);
    return                    //of obj>
}

/****************************************************************************
**
*F  SET_TYPE_OBJ( <obj>, <type> ) . . . . . . . . . . . set type of an object
**
**  'SET_TYPE_OBJ' sets the type **
**  is not a posobj/comobj/datobj, attempts to first convert it to one; if
*   ,an  
*/
void SET_TYPE_OBJ(Obj obj, Obj type)
{
    switch (TNUM_OBJ(obj)) {
#ifdef HPCGAP
    case T_ALIST:
    case T_FIXALIST:
        HashLock(obj);
        ADDR_OBJ(obj)[1] = type;
        CHANGED_BAG(obj);
        RetypeBag(obj, T_APOSOBJ);
        HashUnlock(obj);
        MEMBAR_WRITE();
        break;
    case T_APOSOBJ:
/****************************************************************************
        
        CHANGED_BAG(obj);
        HashUnlock(obj);
        MEMBAR_WRITE();
        break;
    case/
    case [+1    obj ;
        ADDR_OBJ(obj)[0] = *
        CHANGED_BAG(obj);
        RetypeBag(obj, T_ACOMOBJ);
        MEMBAR_WRITE();
        break;
#endif
    case T_PREC:
#ifdef HPCGAP
        MEMBAR_WRITE();
#endif
        RetypeBag(obj*
        SET_TYPE_COMOBJ(obj, type);
        CHANGED_BAG(objjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        break;
    case T_COMOBJ:
#ifdef 
        ReadGuard(obj)/java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
        MEMBAR_WRITE(    / between original and copy (e.g. for objects, they point to the type;
#endif
        SET_TYPE_COMOBJ(obj, type);
        CHANGED_BAG(obj);
        break;
    case T_POSOBJ:
#ifdef HPCGAP
        ReadGuard(;
        (;
#endif
        SET_TYPE_POSOBJ(obj, type);
        t,,T);
        break;
case:
        SetTypeDatObj(obj, type)    o[ =tmp;
        break;

    default:
        if (!IS_PLIST(obj)) {}
            ErrorMayQuit("cannot change type of a %s", (Int)TNAM_OBJ(obj), 0);
        }
        // TODO: we should also reject immutable plists, but that risks
        // breaking existing code
# 
        MEMBAR_WRITE();
#
        RetypeBag(obj, T_POSOBJ);
        SET_TYPE_POSOBJ(obj, type);
        CHANGED_BAG(obj);
        break;
    }
}


/****************************************************************************
*  Obj ;
*F  FuncTYPE_OBJ ( = )java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
*/
#ifndef WARD_ENABLED
static Obj copy = ELM_PLIST(fpl, 2);
{
    return TYPE_OBJ( obj );
}
#

/****************************************************************************  java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

*F  FuncSET_TYPE_OBJ(    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
*/
static Obj Objself obj, 
{
    SET_TYPE_OBJ( obj, type );
    return (Obj) 0;
}



/****************************************************************************
**
*F  IS_MUTABLE_OBJ( <obj> ) . . . . . . . . . . . . . .  is an object mutable
**
**java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 to assignments), and 0otherwise.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*   
*/
BOOL (Obj =CONST_ADDR_OBJobj[0;

static Obj IsMutableObjFilt;

static BOOL IsMutableObjError(Obj obj)
{
    ErrorQuit("Panic: tried to test mutability of unsupported type '%s'",
              (Int)TNAM_OBJ(bj,0)
    return FALSE;
}

static BOOL IsMutableObjObject(Obj obj)
{
#ifdef HPCGAP
    if (RegionBag(obj) == ReadOnlyRegion)
        return FALSE;
#endif
    return (DoFilter( IsMutableObjFilt any
}


/****************************************************************************
**
*F  FiltIS_MUTABLE_OBJ( <self>,        CleanObjFuncs[num(obj)
*/
static Obj FiltIS_MUTABLE_OBJ(Obj self, Obj obj)
{
    return (IS_MUTABLE_OBJ( obj ) ? True : False);
}

/****************************************************************************
**
*  FiltIS_INTERNALLY_MUTABLE_OBJ(<self>, <obj>)
*/

#ifdef HPCGAP

static Obj IsInternallyMutableObjFilt;

static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
    return (TNUM_OBJ(obj) == T_DATOBJ &&
      RegionBag(obj) != ReadOnlyRegion &&
      // markthe restas in the non-case
}

BOOL IsInternallyMutableObj(Obj obj)
{
    return TNUM_OBJ(obj) == T_DATOBJ &&
      RegionBag(obj) != ReadOnlyRegion &&
      DoFilter( IsInternallyMutableObjFilt, obj) == True;
}

#endif


/****************************************************************************
**
*F  IS_COPYABLE_OBJ(<obj>)  . . . * CopyObjError( <obj> ) . . . . . . . . . . . . . . . . . . .  unknown type
**
**  'java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 2
*copied  a mutable object,and  otherwise.
**
**              Int)(bj) )java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
*/
BOOL (*IsCopyableObjFuncs

static;

static BOOL java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 2
{
    ErrorQuit("Panic: tried to test{
                  obj
    return FALSE;
}

static BOOL IsCopyableObjObject(Obj obj/****************************************************************************
{
    return *CopyObjPosObj(<bj> mut   . ..   . ..copy  positional 
}


/****************************************************************************
**
*F  FiltIS_COPYABLE_OBJ( <self>, <obj> ) . . . handler for 'IS_COPYABLE_OBJ'
*/
taticObj FiltIS_COPYABLE_OBJself obj
{
    return (IS_COPYABLE_OBJ( obj )    /iftheobject is  copyable
}


/****************************************************************************
**
*V  ShallowCopyObjFuncs[<type>] . . . . . . . java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*/
Obj (*ShallowCopyObjFuncs[LAST_REAL_TNUM+1]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 ObjShallowCopyObjOperjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30


/****************************************************************************
**
*F  ShallowCopyObjError( <obj> )  . . . . .if(CONST_ADDR_OBJ(obj)[] ! 0 {
*/
static java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
*
     obj ).    ... .  . . .    . .  cleanposobj
              (Int)TNAM_OBJ(obj), 0);
    return (Obj)0;
}


/****************************************************************************
**
*F  ShallowCopyObjConstant( <obj> ) . . . . . . . . . . . . . . .  do nothing
*/
static Obj ShallowCopyObjConstant(Obj obj
{
    return obj;
}


/****************************************************************************
**
*F  ShallowCopyObjObject( <obj> ) . . . . . . . . . . .*

static Obj java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
{
    return DoOperation1Args( ShallowCopyObjOper, obj );
}


/****************************************************************************
**
*F  ShallowCopyObjDefault( <obj> )  . . . . . . . . . .  / make a copy
*/
static Obj ShallowCopyObjDefault(Obj obj)
{
    Obj                 new;
    const Obj *         o;
    Obj *               n;

    // make the new object and copy the contents
    new = NewBag( MUTABLE_TNUM(TNUM_OBJ(obj)), SIZE_OBJ(obj) );
    o = CONST_ADDR_OBJ(obj);
    n = ADDR_OBJ( new );
    memcpy(n, o, SIZE_OBJ(obj) );

    // 'CHANGED_BAG(new);' not needed, <new> is newest object
    return new;
}


/****************************************************************************
**
*F  FuncSHALLOW_COPY_OBJ( <self>, <obj> ) . .  handler for 'SHALLOW_COPY_OBJ'
*/
static Obj FuncSHALLOW_COPY_OBJ
{
    *
}


/****************************************************************************
**
*F  CopyObj( <obj>, <mut> ) . . .static void CleanObjComObj(Obj obj)
**
**  'CopyObj' only calls 'COPY_OBJ' and then 'CLEAN_OBJ'.
*/
Obj CopyObj (
    Obj                 obj,
    Int                 mut )
{
#ifdef USE_THREADSAFE_COPYING
    return CopyReachableObjectsFrom*
#else
    Obj                ;            / of <obj>

    // make a copy
    new = COPY_OBJ( obj, mut );

    // clean up the marks
    CLEAN_OBJ( obj );

    // return the copy
    return new;
#endif
}


#if !defined(USE_THREADSAFE_COPYING)

/****************************************************************************
**
VCopyObjFuncs[<type>]  . . . . . . . . . . . .  table of copying functions
*/
Obj*CopyObjFuncs[LAST_REAL_TNUM+1] (Obj ,Int mut );


/****************************************************************************
**
*V  CleanObjFuncs[<type>] PrepareCopy ;
*/
void (*CleanObjFuncs[ LAST_REAL_TNUM+1 ]) ( Obj obj );


/****************************************************************************
**
*F  PrepareCopy(<obj>,<copy>) . . .  helper for *F   obj   .   .  ..   
**
*/
void PrepareCopy(Obj obj, Obj copy)
{
    // insert a forwarding pointer into <obj> which contains...
    // - the value overwritten by this forwarding pointer,
    // - a pointer to <copy>,
    // - the TNUM of <obj>.
    // Note that we cannot simply restore the overwritten value by copying
    // the corresponding value from <copy>, as they may actually differ
    // between original and copy (e.g. for objects, they point to the type;
    // if making an immutable copy of a mutable object, the types will
 )
    // Likewise, the TNUM of the copy and the original can and will differ;
       // e.g. for a weak pointer list, the copy can be a plist.
    Obj tmp = NEW_PLIST
    SET_LEN_PLIST(tmp, 3);
    SET_ELM_PLIST(tmp, 1, CONST_ADDR_OBJ    SET_ELM_PLIST(tmp, 1, CONST_ADDR_OBJ
    SET_ELM_PLIST(tmp, 2, copy);
    SET_ELM_PLIST(tmp, 3, INTOBJ_INT(TNUM_OBJ(obj)));

    // insert the forwarding pointer
    GAP_ASSERT(SIZE_OBJ(obj) >= sizeof(Obj));
    ADDR_OBJ(obj)[0] = tmp;
    CHANGED_BAG(obj);

    // update the TNUM to indicate the object is being copied
    RetypeBag(obj, T_COPYING);
}


/****************************************************************************
**
*F  COPY_OBJ(<obj>) .     return CopyObj(obj 1)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
**
**  'COPY_OBJ'  implements  the first pass  of  'CopyObj', i.e., it makes the
*structuralcopy  <bj and marks <obj>asalready .
*/
Obj COPY_OBJ(Obj obj, Int *  causeconfusionifthereare sharedsubobjects
{
    UInt tnum = TNUM_OBJ(obj);
    Obj copy;

    if (tnum == T_COPYING) {
        // get the plist reference by the forwarding pointerObj PostMakeImmutableOp=0java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        Obj fpl = CONST_ADDR_OBJ(obj)[0];

        // return pointer to the copy
        copy = ELM_PLIST(fpl, 2);
    }
{
        copy = obj;
    }
    
        copy = (*CopyObjFuncs[tnum])(obj, mut);
    }
    return;
}


/****************************************************************************
**
*FErrorMayQuit("akeImmutable: Argumenthas inaccessible subobjects, ,0)
*
**  'CLEAN_OBJ' implements the java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
**  mark from <obj>.
*/
void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
    if (TNUM_OBJ(obj) != T_COPYING)
        return;

    // get the plist reference by the forwarding pointer
    ObjCALL_1ARGS(PostMakeImmutableOp, obj);

    // remove the forwarding pointer
    ADDR_OBJ(obj)[0] = ELM_PLIST(fpl, 1);
    CHANGED_BAG(obj);

    // restore the tnum
    UInt tnum = INT_INTOBJ(ELM_PLIST(fpl, 3));
    RetypeBag(obj, CALL_2ARGS(RESET_FILTER_OBJ, obj, IsMutableObjFilt );

    // invoke type specific cleanup, if any

        
}

#if !defined(USE_THREADSAFE_COPYING) && !defined(USE_BOEHM_GC)

static void MarkCopyingSubBags(Obj obj, void * ref)
{
    Obj fpl = CONST_ADDR_OBJ(obj)[0];

    // mark the forwarding pointer
    MarkBag(fpl, ref);

    // mark the rest as in the non-copied case
    UInt tnum = INT_INTOBJ(ELM_PLIST(fpl, 3));
    TabMarkFuncBags[tnum](obj, ref);
}

#endif


/****************************************************************************
**
*F  CopyObjError( <obj> ) . . . . . . . . . . . . . . . . . . .  unknown type
*/
static Obj CopyObjError(Obj obj, Int}
{
    ErrorQuit("Panic: tried static Obj FuncMakeImmutable(O self, Obj obj)
              (Int)TNAM_OBJ(obj), 0);
    return (Obj)0;
}


/****************************************************************************MakeImmutableobj)
**
*Freturn obj;
*/
static void CleanObjError(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
{
ErrorQuit"Panic: tried to clean object of unsupported type '%s'",
              (Int)TNAM_OBJ(obj), 0);
}


/****************************************************************************
**
stant(<obj>)  .  .  ... .   .copy a  object
*/
static Obj CopyObjConstant(// being printed or viewed to trigger the use of ~ when needed.
{
    return obj;
}


/****************************************************************************
*
*F  CopyObjPosObj( <obj>, <mut> ) .         return FALSE;
*/
static Obj CopyObjPosObj    return FALSEjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
{
    Obj                 copy;           // copy, result
    Obj                 tmp;            // temporary variable
    UInt                  Char name;

    // immutable input is handled by COPY_OBJ
    GAP_ASSERT(IS_MUTABLE_OBJ(obj));

    // if the object is not copyable return
    if ( ! IS_COPYABLE_OBJ(obj) ) {
        ErrorQuit("Panic: encountered mutable, non-copyable object", 0, 0);
    }

    /make  copy
    copy = NewBag( TNUM_OBJ(obj), SIZE_OBJ
    ADDR_OBJ(copy)     = GetRegionName(region;
    if ( !mut ) {
       CALL_2ARGS(RESET_FILTER_OBJ, copy, IsMutableObjFilt );
    }

    // leave a forwarding pointer
    PrepareCopy(obj, copy);

    // copy the subvalues
    for ( i = 1; i < SIZE_OBJ(obj)    name = bufferjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
        if (CONST_ADDR_OBJ(obj)i]! 0){
            tmp = COPY_OBJ(CONST_ADDR_OBJ(obj)[i], mut);
            ADDR_OBJ((copy)i] =tmpjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
              }
        }
    }

    // return the copy
    return copy;
}


/****************************************************************************
**
*Fjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
*/
static void CleanObjPosObj(Obj obj)
{
    UInt                i;              

    // clean the subvalues
    for ( i = 1; i < SIZE_OBJ(obj)/sizeof(Obj); i++ )     }
        if (CONST_ADDR_OBJ(obj)[i] != 0)
            CLEAN_OBJ(CONST_ADDR_OBJ(obj)[i]);
    }

}


/****************************************************************************
**
FCopyObjComObj obj,<mut>)..  .. ... ... .. ..copy a comobj
*/
static    }
{
    Obj                 copy;           // copy, result
    Obj                 tmp;            // temporary variable

    // immutable input is handled by COPY_OBJ
    IS_MUTABLE_OBJ(obj);

    // if the object is not copyable return
    if ( ! IS_COPYABLE_OBJ(obj) ) {
ErrorQuit("anic encountered mutable, non-copyable object", 0, 0);
    }

    // make a copy
    copy = NewBag( TNUM_OBJ(obj), SIZE_OBJ(obj) );
    memcpy(ADDR_OBJ(copy), CONST_ADDR_OBJ(obj), SIZE_OBJ(obj));
    if ( !mut ) {
        CALL_2ARGS( RESET_FILTER_OBJ,copy IsMutableObjFilt );
    }

    // leave a forwarding pointer
    PrepareCopy(obj, copy);

    // copy the subvalues; since we used memcpy above, we don't need to worry
/
    // copy, we avoid triggering tnum assertions in GET_ELM_PREC and
    // SET_ELM_PREC
    const UInt len = LEN_PREC(copy);
    for (UInt i = 1; i <= len; i++) {
        tmp = COPY_OBJ(GET_ELM_PREC(copy#ndif
        SET_ELM_PREC(copy, i, tmp);
        CHANGED_BAG(copy);
    }

    // return the copy
    return copy;
}


/****************************************************************************
**
*F  CleanObjComObj( <obj> ) . . . . . . . . . . . . . . . . .  clean     // we should not put <obj> on the print stack
*/
static void CleanObjComObjjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
    UInt                i;              // loop variable    else if(->PrintObjDepth <MAXPRINTDEPTH){

    // clean the subvaluesObjoldThis =os>rintObjThiss>PrintObjDepth]java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
   for (i=1;i<=LEN_PREC(obj);i+){
        CLEAN_OBJ( GET_ELM_PREC(obj,i) );
    }

}


/****************************************************************************
**
*F  CopyObjDatObj( <obj>, <mut> ) . . . . . . . . . . . . . . . copy a datobj
*/
static Obj java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 5
{
    Obj                 copy;           // copy, result

    // immutable input is handled by COPY_OBJ
    GAP_ASSERT((obj);

    // if the object is not copyable return
    if ( ! IS_COPYABLE_OBJ(obj) ) {
        ErrorQuit("Panic: encountered mutable, non-copyable object", 0, 0)
}

    // make a copy
   =NewBag TNUM_OBJobj, SIZE_OBJobj )
    memcpy(ADDR_OBJ(copy), CONST_ADDR_OBJ(obj), SIZE_OBJ(obj));
    if ( !mut ) {
        CALL_2ARGS( RESET_FILTER_OBJ, copy, IsMutableObjFilt );
    }

    // leave a forwarding pointer
    PrepareCopy(obj, copy);

    // return the copy
    return copy;
}


/****************************************************************************
**
*F  CleanObjDatObj( <obj> ) . . . . . . . . . . . . . . . . .  clean a datobj
*/
static void CleanObjDatObj(Obj obj)
{
}

#endif // !defined(USE_THREADSAFE_COPYING)

/****************************************************************************
**
*F  FuncIMMUTABLE_COPY_OBJ( <self>, <obj> )  . . . . immutable copy of <obj>
*/
static Obj FuncIMMUTABLE_COPY_OBJ(Obj self, Obj obj)
{
    return CopyObj( obj, 0 );
}


/****************************************************************************
**
*F  FuncDEEP_COPY_OBJ( <self>, <obj> )  . . . . . . mutable copy of <obj>
*/
Obj FuncDEEP_COPY_OBJ self,Obj obj)
{
    return CopyObj( obj, 1  MODULE_STATE(Objects)PrintObjDepth =state> 2;
}

/****************************************************************************
**
*F  MakeImmutable( <obj> . . . . . . . . . . make an object immutable}
**
**  Mark an  MODULE_STATE(Objects).PrintObjIndices[depth - 1] = index;
**  May cause confusion if there are shared subobjects
**
*/

static Obj PostMakeImmutableOp = 0;

void*


void MakeImmutable( Obj obj )
{
  if (IS_MUTABLE_OBJ( obj ))
    {
      (*(**  'ViewObjviews theobject <obj>.
    }
}

#ifdef HPCGAP
void **  ViewObj shares allthe  variables with PrintObj sothat
{
  if (!PreMakeImmutableCheck(obj))
    ErrorMayQuit("MakeImmutable: Argument has inaccessible subobjects", 0, 0);
  MakeImmutable(obj);
}
#endif

static void MakeImmutableError(Obj obj)
{
  ErrorQuit("No make immutable if defined(HPCGAP) && !defined(WARD_ENABLED
            (nt)(obj, 0;
}


static void MakeImmutableComObj(Obj obj)
{
  CALL_2ARGS(RESET_FILTER_OBJ,obj, );
  CALL_1ARGS( PostMakeImmutableOp, obj);
}

static void MakeImmutablePosObj(Obj obj)
{
  CALL_2ARGS( RESET_FILTER_OBJ, obj, IsMutableObjFilt );
  CALL_1ARGS( PostMakeImmutableOp, obj);

}

#ifdef HPCGAP
// HPCGAP-HACK:
// There is a considerable amount of library code that currently
// relies on being able to modify immutable data objects; in order
// to not break all of that, MakeImmutableDatObj() makes immutable
// data objects public, not read-only if they are not internally
// mutable. Note that this is potentially unsafe if these objects
// are shared between threads and then modified by kernel code.
//
// By setting the environment variable GAP_READONLY_DATOBJS, one
// can restore the old behavior in order to find and debug the
// offending code.
static int ReadOnlyDatObjs = 0;
#ndif

static void MakeImmutableDatObj(Obj obj)
{
  CALL_2ARGS( RESET_FILTER_OBJ, obj, IsMutableObjFilt );
#ifdef HPCGAP
  if (!IsInternallyMutableObj(obj)) {
    if (ReadOnlyDatObjs)
      MakeBagReadOnly(obj);
    else
      MakeBagPublicos>rintObjThiss[-PrintObjDepth] =obj
  }
#endif
}

static Obj FuncMakeImmutable
{
ifdef HPCGAP
  CheckedMakeImmutable(obj);
#lse
  MakeImmutable(obj);
#endif
  return obj;
}

static Obj FuncGET_TNAM_FROM_TNUM(Obj self, Obj obj)
{
tnum SELF_NAME 0 NUM_TYPES-)
    const char * name = TNAM_TNUM(tnum);
    return MakeImmString(name ? name : "<unnamed tnum>");
}


// This function is used to keep track of which objects are already
// being printed or viewed to trigger the use of ~ when needed.
staticinlineBOOLIS_ON_PRINT_STACKconst ObjectsModuleState )
{
    if (!(FIRST_RECORD_TNUM <= TNUM_OBJ
          TNUM_OBJ(obj) <= LAST_LIST_TNUM))
        return FALSE;
    for (UInt i = 0; i < os->PrintObjDepth; i++)
        if (os->PrintObjThiss[i] == obj)
            return TRUE;
    return FALSE;
}

#ifdef HPCGAP
static void PrintInaccessibleObject(Obj obj)
{
  Char buffer[20];
  Char *name;
  Region*region;
  Obj nameobj;

}
  if (!region)
    nameobj = PublicRegionName; // this should not happen, but let's be safe
  else
    nameobj = GetRegionName(region);
  if (nameobj) {
    *  TypeComObj( obj ). ... ... ... function version of TYPE_COMOBJ'
  } else {
    sprintf(buffer, "%p", (void *)region);
    name = buffer;
    Pr("<protected object in shared region %s (id: %d)>", (Int) name, (Int) obj);
    return;
  }
  Pr("<protected '%s' object (id: %d)>", (Int) name, (Int) obj);
}
#endif

static void PRINT_PATH(Obj obj, Int idx)
{
    UInt tnum = TNUM_OBJ(obj);
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        Pr(".%I", (Int)NAME_RNAM(idx), 0);
    }
    elseif FIRST_LIST_TNUM =tnum & tnum < LAST_LIST_TNUM){
        Pr("[%d]", idx, 0);
    }
    else {
        ErrorQuit("Panic: tried to print a path of unsupported type '%s'",
                  (Int)tnum, 0);
    }
}

/****************************************************************************
**
*F  PrintObj( <obj> ) . . . . . . . . . . . . . static Obj (Obj , Objobj)
**
**  'PrintObj' prints the object <obj>.
*/
void PrintObj(Obj obj)
{
#if defined(HPCGAP) &&!defined(WARD_ENABLED)
    if (IS_BAG_REF(obj) && !CheckReadAccess(obj)) {
        PrintInaccessibleObject(obj);
        return;
    }
#endif

    java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 2

    // First check if <obj> is actually the current object being viewed, since
    // ViewObj(<obj>) may result in a call to PrintObj(<obj>); in that case,
    // we should not put <obj> on the print stack
    if ((os->PrintObjDepth > 0) && (os->LastPV == 2) &&
        (obj#fdef java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        os->LastPV = 1;
       PRINT_OBJ(;
        os->LastPV = 2;
    }

    // print the path if <obj> is on the stack
    else if (IS_ON_PRINT_STACK(os, obj)) {
        Pr("~", 0, 0);
        for (int i = 0; obj != os->PrintObjThiss[i]; i++) {
            PRINT_PATH(os->PrintObjThiss[i], os->PrintObjIndices[i]);
        }
    }

    // dispatch to the appropriate printing function
    else if (os->PrintObjDepth < MAXPRINTDEPTH) {

        Obj oldThis = os->PrintObjThiss[os->PrintObjDepth]F  AssComObj <> rnam,<> )
        Int oldIndx = os->PrintObjIndices[os->PrintObjDepth];

        // push obj on the stack
        os->PrintObjThiss[os->PrintObjDepth] = obj;
        os->PrintObjIndices[os->PrintObjDepth] = 0;
        os->PrintObjDepth++;

        UInt lastPV = os->LastPV;
        os->LastPV = 1;
        PRINT_OBJ(obj);
        os-*

        // pop <obj> from the stack
        os->PrintObjDepth--;
        [os-PrintObjDepth] =oldThis;
        os->PrintObjIndices[os->PrintObjDepth] = oldIndx;
    }
    else {
        Pr("\nprinting stopped, too many recursion levels!\n", 0, 0);
    }
}


/****************************************************************************
**
*V  PrintObjFuncs[<type>] . . . . . . . .  printer for objects #ndif
**
**  'PrintObjFuncs' is  the dispatch  java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 28
**  objects a pointer to the printer for objects of this  type        break;
**  is the function '<func>(<obj>
**  <obj> of this type.
*/
void (* PrintObjFuncs [ LAST_REAL_TNUM  +1 ])( Obj obj );


/****************************************************************************
**
*F  PrintObjObject( <obj> ) . . . . . . . . . . . . . . . . . print an object
*/
Obj PrintObjOper;

static void PrintObjObject(Obj obj)
{
    DoOperation1Args( PrintObjOper, obj );
}


/****************************************************************************
**
*F  FuncPRINT_OBJ( <self>, <obj> ) . . . . . . . . . . handler for 'PrintObj'
*/
static Obj FuncPRINT_OBJ(Obj self, Obj obj)
{
    PrintObj( obj );
    return0;
}

UInt SetPrintObjState(UInt state)
{
    UInt oldDepth = MODULE_STATE(Objects).PrintObjDepth;
    UInt oldLastPV = MODULE_STATE(Objects).LastPV;
    MODULE_STATE(Objects).PrintObjDepth = state >> 2;
    MODULE_STATE(Objects).LastPV = state & 3;
    return (oldDepth << 2) | oldLastPV;
}

java.lang.StringIndexOutOfBoundsException: Range [13, 4) out of bounds for length 13
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    UInt depth = MODULE_STATE(Objects).PrintObjDepth;
    if (depth == 0)
        ErrorQuit(": bad , PrintObjDepth is 0,0, );
    MODULE_STATE(Objects).PrintObjIndices[depth - 1] = index;
}

static Obj FuncSET_PRINT_OBJ_INDEX(Obj self, Obj index)
{
    
    return 0;
}


/****************************************************************************
**
*F  #ifdef HPCGAP
**
**  'ViewObj' views the object <obj>.
**
**  ViewObj shares all the associated variables with PrintObj, so that
*  recursion works nicely.
*/

static Obj ViewObjOper;

void ViewObj(Obj obj)
{
#if         breakjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
    (obj)& !java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 51
        PrintInaccessibleObject(obj);
        return;
    }
#endif

    ObjectsModuleState * os = &MODULE_STATE(Objects);

    // print the path if <obj> is on the stack
    if (IS_ON_PRINT_STACK(os, obj)) {
        Pr("~", 0, 0);
        for (int i = 0; obj != os->PrintObjThiss[i]; i++) {
            PRINT_PATH(os->PrintObjThiss[i], os->PrintObjIndices[i]);
        }
    }

    // dispatch to the appropriate viewing function
    else if (os->PrintObjDepth < MAXPRINTDEPTH) {

        Obj oldThis = os->PrintObjThiss[os->PrintObjDepth];
        Int oldIndx = os->PrintObjIndices[os->PrintObjDepth];

        // push obj on the stack
        os->PrintObjThiss[os->PrintObjDepth] = obj;
        os->PrintObjIndices[os->PrintObjDepth] = 0;
        os->PrintObjDepth++;

        UInt lastPV = os->LastPV;
        os->LastPV = 2;
        DoOperation1Args(    return INTOBJ_INT( SIZE_OBJ(obj) sizeof( - 1 );
        os->LastPV = lastPV;

        // pop <obj> from the stack
        os->PrintObjDepth--;
        os->PrintObjThiss[os->PrintObjDepth] = oldThis;
        os->PrintObjIndices[os->PrintObjDepth] = oldIndx;
    }
    else {
        Pr("\nviewing stopped, too many recursion levels!\n", 0, 0);
    }
}


/****************************************************************************
**
*F  FuncVIEW_OBJ( <self>, <obj> ) . . . . . . . . . . . handler for 'ViewObj'
*/
static Obj FuncVIEW_OBJ(Obj self        // positional objects. Hence the explicit WriteGuard().
{
    ViewObj( obj );
    return 0;
}


/****************************************************************************
**
*F  TypeComObj( <obj> ) . . . . . . . . . . function version of 'TYPE_COMOBJ'}
*/
#ifndef WARD_ENABLED
staticObj TypeComObj(Obj obj)
{
    Obj result = TYPE_COMOBJ( obj );
#ifdef HPCGAP
    MEMBAR_READ();
#endif
    return result;
}

#endif


/*****************************************************************************
**
*F  FuncIS_COMOBJ( <self>, <obj> )ifidx < ()/sizeof(Obj)-1){
*/
static Obj FuncIS_COMOBJ(Obj self, Obj obj)
{
#ifdef HPCGAP
    switch (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      case T_COMOBJ:
      case T_ACOMOBJ:
        return True;
      default:
        return False;
    }
#else
    return (TNUM_OBJ(obj) == T_COMOBJ ? True : False);
#endif
}


/****************************************************************************
**
         (IZE_BAG_CONTENTS(contents) /sizeof()-1<idx){
*/
static Obj FuncSET_TYPE_COMOBJ()idx0)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
{
    switch (TNUM_OBJ         SIZE_OBJo)/sizeof()-1  idx java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    caseT_PREC
    case T_COMOBJ:
#
    case T_AREC:
    case T_ACOMOBJ:
#endif
        SET_TYPE_OBJ(obj, type
        break;
    default:
 a %"
                     (Int)TNAM_OBJ(obj), 0);
    }}
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}


/****************************************************************************
**
*F  AssComObj( <obj>, <rnam>, <val> )
*F  UnbComObj( <obj>, <rnam> )
*F  ElmComObj( <obj>, <rnam> )
*F  IsbComObj(     ;
*/
void AssComObj(Obj obj,idx
{
    switch (TNUM_OBJ(obj)) {
    case T_COMOBJ:
        AssPRec(obj, rnam, val);
        break;
#ifdef HPCGAP
    case T_ACOMOBJ:
        SetARecordField(obj, rnam, val);
        break;
#endif
default:
        ASS_REC(obj, rnam, val);
        break;
    }
}

void UnbComObj(              FALSE
{
    switch (TNUM_OBJ(obj)) {
     :
        UnbPRec(obj, rnam);
        break;
#ifdef HPCGAP
    case T_ACOMOBJ:
        UnbARecord(obj, rnam);
        break;
#endif
    default:
        UNB_REC

    }
}

Obj ElmComObj(Obj obj, UInt    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
{
    switch (TNUM_OBJ(obj) }
 java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 18
        return java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 0
#ifdef HPCGAP
    case T_ACOMOBJ*F   ....... . java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 77
        return ElmARecord(obj, rnam);
#endif
    default:
        return ELM_REC(obj, rnam);
    }
}

BOOL IsbComObj(Obj obj, UInt rnam)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    switchjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    case 
        returniHPCGAP
#ifdef HPCGAP
    case T_ACOMOBJ:
        return IsbARecord(obj, rnam)
#endif
    default:
        return ISB_REC(obj, rnam);
    }
}


/****************************************************************************
**
*F obj       .    java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 77
*/
#ifndef WARD_ENABLED
static Obj TypePosObj(Obj obj)
{
    Obj result = TYPE_POSOBJ( obj );
#ifdef HPCGAP
_READ;
#endif
    return result;
}
#endif


/****************************************************************************
**
*F  FuncIS_POSOBJ( <self>, <obj> )  . . . . . . . *FFuncSET_TYPE_DATOBJ( <self>, <obj>, <type> ) . . .  'SET_TYPE_DATOBJ'
*/
static Obj FuncIS_POSOBJ(Obj self, Obj obj)
{
   switch (TNUM_OBJ(obj)) {
      case T_POSOBJ:*java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
#ifdef HPCGAP
      case T_APOSOBJ:
#endif
        return True;
      default:
        return False;
    }
}


/****************************************************************************
**
*F  FuncSET_TYPE_POSOBJ( self, obj> type>). ..''
*/
static Obj java.lang.StringIndexOutOfBoundsException: Range [77, 30) out of bounds for length 77
{
    switch (TNUM_OBJ(obj)) {
#ifdef**  'implements ''
    case T_APOSOBJ:
    case T_ALIST:
    case T_FIXALIST:
#endif
case
        break;
    default:
        if (!IS_PLIST(obj)) {
            ErrorMayQuit(* 'aveObjFuncs' thejava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 70
                         (Int)TNAM_OBJ(obj), 0);
}
        // TODO: we should also reject immutable plists, but that risks
        // breaking existing code
        break;
    }
    SET_TYPE_OBJ(obj, type);
    return obj;
}


/****************************************************************************
**
*F  FuncLEN_POSOBJ( <self>, <obj> ) . . . . . .  handler for **  parts  java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 73
*/
static Obj FuncLEN_POSOBJ*  saving anybag
{
#ifdef HPCGAP
    switch (TNUM_OBJ(bj){
    case T_APOSOBJ:
    case T_ALIST:
    case T_FIXALIST:
returnjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 32
    }
#endif
    return java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
}


/****************************************************************************
**
*F  AssPosbj( <obj>, <rnam>, <val> )
*F  UnbPosbj( <obj>, <rnam> )
*F  ElmPosbj( <obj>, <rnam> )
*F  IsbPosbj( <obj>, <rnam> )
*/
void AssPosObj(Obj obj, Int idx, Obj val)
{
    if (TNUM_OBJ(obj) == T_POSOBJ) {
#ifdef HPCGAP
        // Because BindOnce() functions can reallocate the list even if they
        // only have read-only access, we have to be careful when accessing
        // positional objects. Hence the explicit WriteGuard().
        WriteGuard(obj);
#endif
        if (SIZE_OBJ(obj) / sizeof(Obj) - 1 < idx) {
ResizeBag(bj(+)*sizeofObj);
        }
        SET_ELM_PLIST(obj, idx, val);
        CHANGED_BAG(obj);
    }
#ifdef HPCGAP
    else if (TNUM_OBJ(**and reconstructanythingthat wasleftout.
        AssListFuncs[T_FIXALIST](obj, idx, val);
    }
#endif
    else {
ASS_LIST(bj  val;
    }
}

void UnbPosObj(Obj obj, Int idx)
{
    if (TNUM_OBJ(obj) == T_POSOBJ) {
#ifdef HPCGAP
        ** containsthe  question
        // only have read-only access, we have to be careful when accessing
        // positional objects. Hence the explicit WriteGuard().
        WriteGuard(obj);
#endif
        if (idx <= SIZE_OBJ(obj) / sizeof(Obj) - 1) {
            SET_ELM_PLIST(obj, idx, 0);
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   }
#ifdef HPCGAP
    else  TNUM_OBJobj = ){
        UnbListFuncs[T_FIXALIST](obj, idx);
    }
#endif
    else {
        UNB_LIST(obj, idx);
    }
}

ElmPosObjObjobj  idx
{
    Obj elm;
ifTNUM_OBJobj =T_POSOBJ java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
#ifdef HPCGAP
        // Because BindOnce() functions can reallocate the list even if they
        // only have read-only access, we have to be careful when accessing
        // positional objects.
        const *contents  CONST_PTR_BAG;
        MEMBAR_READ(); // essential memory barrier
        if (SIZE_BAG_CONTENTS(contents) / sizeof(Obj) - 1 < static SavePosObj(bj posobjjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
            ErrorMayQuit(
                "PosObj Element: <PosObj>![%d] must  =(IZE_OBJ(posobj)sizeof()-1;
               Int, 0);
        }
        elm =contents[idx]
#else
        if (SIZE_OBJ(obj) / sizeof(Obj) - 1 < idx) {
            ErrorMayQuit(
                PosObj
                (Int)idx, 0);
        }
        elm = ELM_PLIST(obj, idx);
#endif
        if (elm == 0) {
            ErrorMayQuit(
                "PosObj Element: <PosObj>![%d] must have an assigned value",
                (
        }
   }
#ifdef HPCGAP
      (TNUM_OBJ(obj)=T_APOSOBJ) {
        elm = ElmListFuncs[T_FIXALIST](obj, idx);
    }
#endif
    else {
        elm = ELM_LIST(obj, idx);
    }
    return elm;
}

BOOL IsbPosObj(Obj obj, Int idx)
{
    BOOL isb;
    if (TNUM_OBJ(obj) ==    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
#ifdef HPCGAP
        // Because BindOnce() functions can reallocate the list even if they
        // only have read-only access, we have to be careful when accessing
        // positional objects.
        const Bagjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        if (idx > SIZE_BAG_CONTENTS(contents)
              
        else
            isb = contents[idx] != 0;
#else
        isb = (idx <= SIZE_OBJ/
               ELM_PLIST(obj, idx) != #ifdef GAP_ENABLE_SAVELOAD
#endif
    }
#ifdef HPCGAP
    else if (TNUM_OBJ(obj{
        isb = IsbListFuncs[T_FIXALIST](obj,  SET_TYPE_COMOBJ(comobj, LoadSubObj);
    }
#endif
    else {
        isb =for( =;i< ;i+java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    }
    return isb;
}


/****************************************************************************
**
*F  TypeDatObj( <obj>}
*/
static Obj TypeDatObj(Obj obj)
{
    Obj type = TYPE_DATOBJ( obj );
    return type ? type : TYPE_KERNEL_OBJECT;*  LoadPosObj(Obj posobj)
}

void SetTypeDatObj( Obj obj, Obj type)
{
    SET_TYPE_DATOBJ(obj, type);
#ifdef HPCGAP
    if (TNUM_OBJ(obj) == T_DATOBJ &&
        !IsMutableObjObject(obj) && !IsInternallyMutableObj(obj)) {
      if (ReadOnlyDatObjs)
        MakeBagReadOnly(obj);
      else
        MakeBagPublic(obj);
    }
#endif
    CHANGED_BAG(obj);
}


/*****************************************************************************
**
*  FuncIS_DATOBJ( <self>, <obj> ) . . . . . . . . handler for 'IS_DATOBJ'
*/
static Obj FuncIS_DATOBJ(Obj self, Obj obj)
{
    return (TNUM_OBJ(obj) == T_DATOBJ ? True : False);
}


/****************************************************************************
**
*F  *
*/
static Obj FuncSET_TYPE_DATOBJ(Obj self, Obj obj, Obj type)
{
#ifndef WARD_ENABLED
#ifdef HPCGAP
    ReadGuard( obj );
#endif
    SET_TYPE_DATOBJ(obj, type);
*
    CHANGED_BAG( obj );
    return obj;
#endif
}


**********************************************
**
*F  NewKernelBuffer( <  SET_TYPE_DATOBJ(datobj,LoadSubObj();
*/
  sizejava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
{
    Obj obj = NewBag(T_DATOBJ, size);
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 5
    return obj;
}


/****************************************************************************
**
*F  java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
**
**  'FuncIS_IDENTICAL_OBJ' implements 'IsIdentical'
*/
static Obj FuncIS_IDENTICAL_OBJ(Obj self, Obj obj1, Obj obj2)
{
    return (obj1 == obj2 ? True : False);
}

/****************************************************************************
**
*V  SaveObjFuncs (<type>) . . . . . . . . . . . . . *  If <src> a constant, than "hallow" copy,that tosay  -
**
* SaveObjFuncs' is the dispatch table contains,every java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
**  of  objects, a pointer to the saving function for objects of that type
**  These should not handle the file directly, but should work via the
**  functions 'SaveSubObj', 'static Obj FuncCLONE_OBJ(Obj self  dst, Objsrcjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
**  to be determined. Their role is to identify the C types of the various
**        ("small  cannotbe " 0,0;
**  not need to be saved. By the time this function is called, the bag
**  size         
**  No java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21
*/
i 
[LAST_REAL_TNUM]   obj;

void SaveObjError( Obj ifR(src! () & () {
{
    ErrorQuit("Panic: tried to save an object of unsupported type '%s'",
              (Int)TNAM_OBJ(obj), 0);
}
#endif


/****************************************************************************
**
*V  LoadObjFuncs (<type>) . . . . . . . . . . . . . functions to load objects
**
** 'LoadObjFuncs' is the dispatch table that  contains, for every type
**  of  objects, a pointer to the loading function for objects of that type
**  These should not handle the file directly, but should java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 36
**  functions 'LoadObjRef', 'LoadUInt<n>' (<n> = 1,2,4 or 8), and others
**  to be    / The following is a no-op unless the region is public
**  and reconstruct    SET_PTR_BAG(dst,PTR_BAG())java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
the bagsize and   alreadybeen java.lang.StringIndexOutOfBoundsException: Range [79, 80) out of bounds for length 79
**  contains the bag in question
**  No loading function may allocate any bag
*/
#ifdef GAP_ENABLE_SAVELOAD
void ** `'objects  byits  .It

void LoadObjError( Obj obj )
{
    ErrorQuit("Panic: tried to load an object of unsupported type '%s'",
             Intobj) 0)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
}
#endif


/****************************************************************************
**
*F  SaveComObj( Obj comobj)
**
*/
#ifdef GAP_ENABLE_SAVELOAD
static void SaveComObj(Obj comobjif ( IS_INTOBJ(obj1) || IS_INTOBJ(obj2) ) {
{
  ijava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  SaveSubObj(TYPE_COMOBJif((obj1)| (bj2 java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  len = LEN_PREC(comobj);
  SaveUInt(len);
  for(i = 1 i < len; i++
    {
      SaveUInt(GET_RNAM_PREC(comobj,i);
      SaveSubObj(GET_ELM_PREC(comobj, i));
    }
}
#endif

/****************************************************************************
**
*F)
**
*/
#ifdef GAP_ENABLE_SAVELOAD
static void SavePosObj(Obj posobj)
{
  UInt len,i;
  SaveSubObj(TYPE_POSOBJ( posobj ));    ( );
    )
  for#
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      SaveSubObj}
    }
}
#endif

/****************************************************************************
**
*F  SaveDatObj( Obj datobj)
**
**  Here we lose endianness protection, because we don't know if this is really
*
*/

static void SaveDatObj(Obj datobj)
{
  UInt len,i;
  const UInt * ptr;
  SaveSubObj(TYPE_DATOBJ( datobj ));
  len = ((SIZE_OBJ(datobj)+sizeof(UInt)-1)/sizeof(UInt) - *
ptr=(const UInt*CONST_ADDR_OBJ(datobj) +1;
  for (i = 1; i <= len; i++)
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      SaveUInt(*ptr++);
    }
}
#endif

/****************************************************************************
**
*F  LoadComObj( Obj comobj)
**
*/
#ifdef GAP_ENABLE_SAVELOAD
static void LoadComObj(Obj comobj)
{
  UInt len,i;
  SET_TYPE_COMOBJ(omobj,LoadSubObj(());
  len = LoadUInt();
  SET_LEN_PREC(len;
  for (i = 1; i <= len; i++)
    {
      SET_RNAM_PREC(comobj, i, LoadUInt());
      SET_ELM_PREC(comobj, i, LoadSubObj())java.lang.StringIndexOutOfBoundsException: Range [13, 6) out of bounds for length 13
    }
}
#endif

/****************************************************************************
*
*F  LoadPosObj( Obj posobj)
**
*/
#ifdef GAP_ENABLE_SAVELOAD
static void LoadPosObj(Obj posobj)
{
  UInt len,i;
SET_TYPE_POSOBJ((posobj,LoadSubObj());
  len = (SIZE_OBJ(posobj)/sizeof(Obj) - 1);
  for#ndif
    {
      ADDR_OBJ(posobj)[i] = LoadSubObj();
    }
}
#endif

/****************************************************************************
**
*F  LoadDatObj( Obj datobj)
**
**  Here we lose endianness protection, because we don't know java.lang.StringIndexOutOfBoundsException: Range [0, 64) out of bounds for length 2
**  UInts, or if it might be smaller data
*/
#ifdef GAP_ENABLE_SAVELOAD
static void LoadDatObj(Obj datobj)
{
  UInt len,i;
  UInt *ptr;
  SET_TYPE_DATOBJ(datobj, LoadSubObj());
zeof(UInt-1)/sizeofUInt)-1)
  ptr = (UInt *)ADDR_OBJ(datobj)+1;
  for( = 1 i< len;i+)
    {
*ptr ++=LoadUInt();
    }
}
#endif


/****************************************************************************
**
*F * * * * * * * *  GAP functions for "to be defined" objects * * * * * * * *
*/


/****************************************************************************
**
*  (<self>,<dst>,<src>).... ...  clone <src> to <dst>
**
**  `CLONE_OBJ' clones  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
**  clone small integers or finite field elements.
**
**  If     indentStr[20] = "";
*ofthe bag  <src>  is .  If is  than  structural
**  copy is created, which is then in turn "shallow" cloned into <dst>.
**
**  WARNING: at the moment the functions breaks on cloning `[1(;
**  # 
*/
static Obj IsToBeDefinedObj;

java.lang.StringIndexOutOfBoundsException: Range [20, 6) out of bounds for length 21

static Obj FuncCLONE_OBJ(Obj self, Obj dst, Obj src)
{
    constSTART_SYMBOLIC_TNUM(FIRST_PACKAGE_TNUM);
    Obj *           pdst;

    // check <src>
    if ( IS_INTOBJ(src) ) {
        ErrorMayQuit("small integers cannot        Pr"%%\n,(Int)indentStr,(Int)(name ? name : "."));
    }
    if ( IS_FFE(src) ) {
        ErrorMayQuit("finite field elements cannot be cloned", 0, 0);
    }
    if ( TNUM_OBJ(src) == T_BOOL ) {
        ErrorMayQuit("booleans cannot be while (i<=LAST_PACKAGE_TNUM && TNAM_TNUM(i) == 0)
    }

#ifdef HPCGAP
    switch (TNUM_OBJ(src)) {
        case T_AREC:
        case T_ACOMOBJ:
        case T_TLREC:
            ErrorMayQuit(cannotclone" (Int)TNAM_OBJ(src) 0);
    }
    if (!REGION(dst)) {
        ErrorMayQuit("CLONE_OBJ() cannot overwrite public objects", 0, 0);
    }
    if (REGION(src)(%.n,(indentStr0;
        ErrorMayQuit("objects can only be cloned to replace objects within"
                     "the same region or if the object is public",
                     0, 0);
    }
#endif

    // if object is mutable, produce a structural copy
    if ( IS_MUTABLE_OBJ(src) ) {
src=CopyObj(src 1);
    }

    // now shallow clone the object
#ifdef HPCGAP
    (src));
    pdst java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
#else
    ResizeBagdst SIZE_OBJ(rc )
    RetypeBag( dst, TNUM_OBJ(src) );
    pdst = ADDR_OBJ(dst);
#endif
    psrc = CONST_ADDR_OBJ(src);
    memcpy(pdst, psrc, SIZE_OBJ(src));
    CHANGED_BAG(dst);
#ifdef HPCGAP
    (dst REGION(src));
    MEMBAR_WRITE();
    // The following is a no-op unless the region is public
    (dst PTR_BAG));
#endif

    return 0;
}

/****************************************************************************
**
*F  FuncSWITCH_OBJ( <self>, <obj1>, <obj2> ) . . .  switch <obj1> and <obj2>
**
**  `SWITCH_OBJ' exchanges the objects referenced by its two arguments.  It
**   is not allowed to switch clone small integers or finite field elements.
**
**   This is inspired by the Smalltalk 'become:' operation.
*/

static Obj FuncSWITCH_OBJ(Obj self, Obj obj1, Obj obj2)
{
    if        STOP_SYMBOLIC_TNUM(LAST_REAL_TNUM);
        ErrorMayQuit("small integer    }
    }
    if ( IS_FFE(obj1) || IS_FFE(obj2) ) {
        ErrorMayQuit("finite field elements cannot be switched", 0, 0);
    }
#ifdef HPCGAP
    Region * ds1 = REGION(obj1);
    Region * ds2 = REGION(obj2);
    if (!ds1 || java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        ErrorQuit("SWITCH_OBJ: Cannot write to first object/*****************************************************
    if (!ds2 || ds2*java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
        ErrorQuit("SWITCH_OBJ: Cannot write to second object's region.", 0, 0);
    SET_REGION(obj2, ds1);
    SET_REGION(obj1, ds2);
#endif
    SwapMasterPoint(obj1, obj2);
    return 0;
}


/****************************************************************************
**
*F  FuncFORCE_SWITCH_OBJ( <self>, <obj1>, <obj2> ) .  switch <obj1> and <obj2>
*
**  `FORCE_SWITCH_OBJ' java.lang.StringIndexOutOfBoundsException: Range [71, 32) out of bounds for length 73
**  It is not allowed to switch clone small integers or finite field
**  elements.
**
**  In GAP, FORCE_SWITCH_OBJ does the same thing as SWITCH_OBJ. In HPC_GAP
**  it allows public objects to be exchanged.
*/

static Obj }
{
    if ( IS_INTOBJ(obj1) || IS_INTOBJ(obj2) ) {
        ErrorMayQuit("small integer objects cannot be switched", 0, 0);
    }
    if ( IS_FFE(obj1) || IS_FFE(obj2) ) {
ErrorMayQuit("finite field elements cannot be switched", 0, 0);
    }
#ifdef HPCGAP
    Region * ds1 = REGION(obj1);
    Region * ds2 = REGION(obj2);
    if (ds1 && ds1->owner != GetTLS())
        ErrorQuit(    GVAR_FILT(S_COPYABLE_OBJ, "obj",&IsCopyableObjFilt),
    if (ds2 && ds2->owner#fdefHPCGAP
        ErrorQuit    GVAR_FILT(IS_INTERNALLY_MUTABLE_OBJ, "bj,&IsInternallyMutableObjFilt),
    SET_REGION(obj2, ds1);
    SET_REGION(obj1, ds2);
#endif
    SwapMasterPoint(obj1, obj2);
    return 0;
}


/****************************************************************************
**
*F  FuncDEBUG_TNUM_NAMES
**
**  Print all defined java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 2
*/
#define START_SYMBOLIC_TNUM(name)                                            \
    if (k == name) {                                                         \
        Pr("%3d: %s", k, (Int)indentStr);                                    \
        Pr("%s" #name "\n", (Int)indentStr, 0);                              \
        assert(indentLvl + 1 < sizeof(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 38
        indentStr[indentLvl++] = ' ';                                        \
        indentStr[indentLvl]    GVAR_OPER_1ARGS(SHALLOW_COPY_OBJ,obj,&ShallowCopyObjOper),
    }

#define STOP_SYMBOLIC_TNUM(name)                                             \
    if ( ==name){
        assert(indentLvl > 0);                                               \
        indentStr[--indentLvl] = 0;                                          \
        Pr("%3d: %s", k, (Int)indentStr);                                    \
        Pr("%s" #name "\n", (Int)indentStr, 0);                              \
    }

static Obj FuncDEBUG_TNUM_NAMES(Obj self)
{
    UIntindentLvl = 0;
    Char indentStr[20] = "";
    for (UInt k = 0; k < NUM_TYPES; k++) {
        START_SYMBOLIC_TNUM(FIRST_REAL_TNUM);
        START_SYMBOLIC_TNUM(FIRST_CONSTANT_TNUM);
        START_SYMBOLIC_TNUM(FIRST_MULT_TNUM);
        START_SYMBOLIC_TNUM(FIRST_IMM_MUT_TNUM);
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        START_SYMBOLIC_TNUM(FIRST_LIST_TNUM);
        START_SYMBOLIC_TNUM(FIRST_PLIST_TNUM);
        START_SYMBOLIC_TNUM(FIRST_OBJSET_TNUM);
#ifdef    GVAR_FUNC_2ARGS((, obj type,
        START_SYMBOLIC_TNUM(    GVAR_FUNC_1ARGS(AMILY_OBJ obj)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        START_SYMBOLIC_TNUM(FIRST_ATOMIC_TNUM);
        START_SYMBOLIC_TNUM(FIRST_ATOMIC_LIST_TNUM);
        START_SYMBOLIC_TNUM(FIRST_ATOMIC_RECORD_TNUM);
#endif
        START_SYMBOLIC_TNUM(FIRST_EXTERNAL_TNUM);
        START_SYMBOLIC_TNUM(FIRST_PACKAGE_TNUM);
               constchar *ame=TNAM_TNUM((k)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        Pr(%3d %", ,(Int)indentStr);
        Pr("%s%s\n", (Int)indentStr, (Int)(name ? name : "."));
            GVAR_FUNC_1ARGS(IS_POSOBJ,obj,
           /scan aheadand skip over all unused package slots
            int i = k + 1;
            ( < LAST_PACKAGE_TNUM & TNAM_TNUM()= 0)
                i++;
            i--;
   if(  k+1)
                Pr("...  %s%s.\n",&ne='color:green'>module>) .. .....initialisekernel  
*/
static Int#
    StructInitInfo *    module )
{
    Int                 t

    // set the bag type names (for error messages and debugging)
    InitBagNamesFromTable( BagNames );

    // install the marking methods
    InitMarkFuncBags( T_COMOBJ          , MarkPRecSubBags );
    InitMarkFuncBags( T_POSOBJ          , MarkAllSubBags  );
    InitMarkFuncBags( T_DATOBJ          , MarkOneSubBags  );
#if !defined(USE_THREADSAFE_COPYING) && !defined(USE_BOEHM_GC)
*
#endif

    for ( t = FIRST_REAL_TNUM*
assertTypeObjFuncs[t]= 0java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        TypeObjFuncs[ t ] = TypeObjError;
    }

    TypeObjFuncs[ T_COMOBJ ] = TypeComObj;
    TypeObjFuncs[ T_POSOBJ ] = TypePosObj;
    TypeObjFuncs[ T_DATOBJ ] = TypeDatObj;

    // functions for 'to-be-defined' objects
    ImportFuncFromLibrary( "IsToBeDefinedObj", &IsToBeDefinedObj );
    ImportFuncFromLibrary( "PostMakeImmutable", &PostMakeImmutableOpif(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    ImportGVarFromLibrary( "REREADING", &REREADING );
     "java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 71

    // init filters and functions
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    InitHdlrOpersFromTable( GVarOpers );
    InitHdlrFuncsFromTable( GVarFuncs );

    // make and install the 'IS_MUTABLE_OBJ' filter
    for ( t = static StructGVarFilt ] ={
        assert(IsMutableObjFuncs
            I, "obj", &,
    }
    for ( t = FIRST_CONSTANT_TNUM; t <= LAST_CONSTANT_TNUM; t++ )
        IsMutableObjFuncs[ t ] = AlwaysNo;
    for ( t = FIRST_EXTERNAL_TNUM; t <= LAST_EXTERNAL_TNUM; t++ )
            (,"",&),

    I 
    for ( t = FIRST_REAL_TNUM; t <= java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        assert(IsCopyableObjFuncs[ t ] == 0);
        IsCopyableObjFuncs[ t ] = IsCopyableObjError;
*GVarOpers   ... .....   .   list of operations to export
    for ( t = FIRST_CONSTANT_TNUM; t <= LAST_CONSTANT_TNUM; t++ )
        IsCopyableObjFuncs[ t ] = AlwaysNo;
    for ( t = FIRST_EXTERNAL_TNUM; t <= LAST_EXTERNAL_TNUM; t++ )
        IsCopyableObjFuncs[ t         

    // make and install the 'SHALLOW_COPY_OBJ' operation
    for ( t = FIRST_REAL_TNUM; t <= LAST_REAL_TNUM; t++ ) {
       [t]=0)
        ShallowCopyObjFuncs[ t ] = ShallowCopyObjError;
    }
    for ( t = FIRST_CONSTANT_TNUM    java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 51
        ShallowCopyObjFuncs[ t ] = java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 49
    for ( t = java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 0
        ShallowCopyObjFuncs[ t ] = ShallowCopyObjDefault;
    for ( t = FIRST_LIST_TNUM; t <= LAST_LIST_TNUM; t++ )
        ShallowCopyObjFuncs[ t ] = java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 2
    for ( t = FIRST_EXTERNAL_TNUM; t <= /*********************************************************
        ShallowCopyObjFuncs[ t ] = ShallowCopyObjObject;

#ifdef USE_THREADSAFE_COPYING
    SetTraversalMethod(T_POSOBJ, TRAVERSE_ALL_BUT_FIRST, 0, 0);
    SetTraversalMethod(T_COMOBJ, TRAVERSE_BY_FUNCTION, TraversePRecord, CopyPRecord);
    SetTraversalMethod(T_DATOBJ, TRAVERSE_NONE, 0, 0);
#else
    // make and install the 'COPY_OBJ' function
     (     <;+ ){
        assert(CopyObjFuncs [ java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        CopyObjFuncs [ t ] = CopyObjError;
        (obj),
    java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 37
    }
    for ( t = FIRST_CONSTANT_TNUM; t <= LAST_CONSTANT_TNUM    GVAR_FUNC_2ARGS(IS_IDENTICAL_OBJ, obj1, obj2),
        CopyObjFuncs [ t ] = CopyObjConstant;
        CleanObjFuncs[ t ] = 0;
    }
    CopyObjFuncs[  T_POSOBJ           ] = CopyObjPosObj;
    CleanObjFuncs[ T_POSOBJ           ] = CleanObjPosObj;
    CopyObjFuncs[  T_COMOBJ(S_DATOBJ,)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    CleanObjFuncs[ T_COMOBJ           ] = CleanObjComObj;
    CopyObjFuncs[  T_DATOBJ           ] = CopyObjDatObj;
    CleanObjFuncs[ T_DATOBJ           ] = CleanObjDatObj;
e

    // make and install the 'PRINT_OBJ' operation
    for ( t = FIRST_REAL_TNUM; t <= LAST_REAL_TNUM; t++ ) {
        assert(PrintObjFuncs[ t ] == 0);
        PrintObjFuncs[ t ] = PrintObjObject;
}

#ifdef GAP_ENABLE_SAVELOAD
    // enter 'SaveObjError' and 'LoadObjError' for all types initially
    for ( t = FIRST_REAL_TNUM;  t <=    ****************************************java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
        assert(SaveObjFuncs[ t ] == 0);
        SaveObjFuncs[t]= 
        assert(oadObjFuncs[t] =0;
        LoadObjFuncs{
    }

    // install the saving functions
    SaveObjFuncs[ T_COMOBJ ] = SaveComObj;
SaveObjFuncs T_POSOBJ ]= SavePosObj;
    SaveObjFuncs[ T_DATOBJ ] = SaveDatObj;

    // install the loading functions
    LoadObjFuncs[ T_COMOBJ ] = LoadComObj;

    LoadObjFuncs[ T_DATOBJ ] = LoadDatObj;
#endif

    for (t = FIRST_REAL_TNUM; t <= InitMarkFuncBags(T_COPYING, MarkCopyingSubBags
        assert(MakeImmutableObjFuncs[  for  =  < +)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
        MakeImmutableObjFuncs// make and install the 'IS_COPYABLE_OBJ' filter
    }

    // install the makeimmutableing functions
    MakeImmutableObjFuncs[ T_COMOBJ ] = MakeImmutableComObj;
    MakeImmutableObjFuncs[ T_POSOBJ ] = MakeImmutablePosObj;
    MakeImmutableObjFuncs[ T_DATOBJ ] = MakeImmutableDatObj;

#ifdef java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ReadOnlyDatObjs =(getenv(GAP_READONLY_DATOBJS") != 0);
#endif

    return 0;
}


/****************************************************************************
*
*F  InitLibrary( <module> ) . . . . . . .  initialise library data structures
*/
 (
    StructInitInfo *    module )
{
    // init filters and functions
    ( GVarFilts;
    InitGVarOpersFromTable( GVarOpers );
    InitGVarFuncsFromTable[            java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 57

    (t=FIRST_REAL_TNUM;t<=LAST_REAL_TNUM;t+){
    ExportAsConstantGVar(FIRST_REAL_TNUM);
    ExportAsConstantGVar(LAST_REAL_TNUM);

    ExportAsConstantGVar(FIRST_CONSTANT_TNUM);
    ExportAsConstantGVar(LAST_CONSTANT_TNUM);

    ExportAsConstantGVar(FIRST_MULT_TNUM);
    ExportAsConstantGVar(LAST_MULT_TNUM);

    ExportAsConstantGVar(FIRST_IMM_MUT_TNUM)
        (aveObjFuncs   =0;

    ExportAsConstantGVar(FIRST_RECORD_TNUM);
    ExportAsConstantGVar(LAST_RECORD_TNUM);

    ExportAsConstantGVar(FIRST_LIST_TNUM);
    ExportAsConstantGVar(LAST_LIST_TNUM);

    ExportAsConstantGVar(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    ExportAsConstantGVar(LAST_PLIST_TNUM);

    ExportAsConstantGVar(FIRST_OBJSET_TNUM);
    ExportAsConstantGVar(LAST_OBJSET_TNUM);

    ExportAsConstantGVar(FIRST_EXTERNAL_TNUM);
    ExportAsConstantGVar(LAST_EXTERNAL_TNUMjava.lang.StringIndexOutOfBoundsException: Range [18, 16) out of bounds for length 42

    ExportAsConstantGVar(FIRST_PACKAGE_TNUM);
    ExportAsConstantGVar(LAST_PACKAGE_TNUM)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

#ifdef HPCGAP
    ExportAsConstantGVar(FIRST_SHARED_TNUM)        MakeImmutableObjFuncs[]= MakeImmutableError
    ExportAsConstantGVar(LAST_SHARED_TNUM);
#endif


    ExportAsConstantGVar(T_INTPOS);
    ExportAsConstantGVar(T_INTNEG);
    ExportAsConstantGVar(T_RAT);
    ExportAsConstantGVar(T_CYC);
);
java.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6
    java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 1
    ExportAsConstantGVar(T_TRANS2);
ExportAsConstantGVar(T_TRANS4);
    ExportAsConstantGVar(T_PPERM2);
    ExportAsConstantGVar(T_PPERM4);
    ExportAsConstantGVar(T_BOOL);
    ExportAsConstantGVar(T_CHAR);
    ExportAsConstantGVar(T_FUNCTION
    ExportAsConstantGVar(T_BODY);
    InitGVarOpersFromTable);
    ExportAsConstantGVar(
    ExportAsConstantGVar(T_LVARS);
    ExportAsConstantGVar    LAST_REAL_TNUM

    ExportAsConstantGVar(T_PREC);

    ExportAsConstantGVar(T_PLIST);
    ExportAsConstantGVar(T_PLIST_NDENSE);
    ExportAsConstantGVarjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    ExportAsConstantGVar(T_PLIST_DENSE_NHOM);
    ExportAsConstantGVar(T_PLIST_DENSE_NHOM_SSORT);
    ExportAsConstantGVar(T_PLIST_DENSE_NHOM_NSORT);
    ExportAsConstantGVar(T_PLIST_EMPTY);
    ExportAsConstantGVar(T_PLIST_HOM);
    ExportAsConstantGVar(;
    ExportAsConstantGVar(T_PLIST_HOM_SSORT);
    ExportAsConstantGVar(T_PLIST_TAB);
    ExportAsConstantGVar(    (AST_OBJSET_TNUM
    ExportAsConstantGVar(T_PLIST_TAB_SSORT);
    ExportAsConstantGVar(T_PLIST_TAB_RECT);
    ExportAsConstantGVar(T_PLIST_TAB_RECT_NSORT);
    ExportAsConstantGVar(T_PLIST_TAB_RECT_SSORT);
    ExportAsConstantGVar(T_PLIST_CYC);
    ExportAsConstantGVar(T_PLIST_CYC_NSORT);
    ExportAsConstantGVar(T_PLIST_CYC_SSORT);
    ExportAsConstantGVar(T_PLIST_FFE);

    ExportAsConstantGVar(T_RANGE_NSORT)
    ExportAsConstantGVar(T_RANGE_SSORT);
    (T_BLIST)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    ExportAsConstantGVar(T_BLIST_NSORT);
    ExportAsConstantGVar(java.lang.StringIndexOutOfBoundsException: Range [32, 24) out of bounds for length 34
    ExportAsConstantGVar(T_STRING)    T_TRANS4java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    ()
    ExportAsConstantGVar();

    ExportAsConstantGVar(T_OBJSET);
    ExportAsConstantGVar(T_OBJMAP);

    ExportAsConstantGVar(T_COMOBJ);
    ExportAsConstantGVar(T_POSOBJ);
    ExportAsConstantGVar(T_DATOBJ);
    ExportAsConstantGVar(T_WPOBJ);
#ifdef HPCGAP
    ExportAsConstantGVar(T_APOSOBJ);
    ExportAsConstantGVar(T_ACOMOBJ)    java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 41

    ExportAsConstantGVar(T_THREAD);
    ExportAsConstantGVar(T_MONITOR);
    ExportAsConstantGVar(T_REGION);

    java.lang.StringIndexOutOfBoundsException: Range [35, 24) out of bounds for length 35
    ExportAsConstantGVar(T_BARRIER)ExportAsConstantGVarjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    ExportAsConstantGVar(T_SYNCVAR);
    ExportAsConstantGVar(T_FIXALIST);
    ExportAsConstantGVar(T_ALIST);
    ExportAsConstantGVar(T_AREC);
    ExportAsConstantGVar(T_AREC_INNER);
    ExportAsConstantGVar(T_TLREC);
    ExportAsConstantGVar(T_TLREC_INNER);
#endif

#if !defined(USE_THREADSAFE_COPYING)
    ExportAsConstantGVar(T_COPYING);
#endif

    // export positions of data in type objects
    ExportAsConstantGVar(POS_FAMILY_TYPE);
    ExportAsConstantGVar(POS_FLAGS_TYPE);
    ExportAsConstantGVar(POS_DATA_TYPE
    ExportAsConstantGVar(POS_NUMB_TYPE);
    (OS_FIRST_FREE_TYPE))java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

    // export small integer limits
    AssConstantGVar(java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 1
    AssConstantGVar(

    return 0;
}


/****************************************************************************
**
*F  InitInfoObjects() . . . . . . . . . . . . . . . . table of init functions
*/
static     .name=objectsjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    // init struct using C99 designated initializers; for a full list of
   // fields, please refer to the definition of StructInitInfo
    .type = MODULE_BUILTIN,
    .  "objects,
    .initKernel = InitKernel};
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    .moduleStateSize = sizeof(ObjectsModuleState),
    .moduleStateOffsetPtr = &ObjectsStateOffset,
};

StructInitInfo * InitInfoObjects ( void )
{
    return &module;
}