/****************************************************************************
**
*F InitKernel( <module> ) . . . . . . . . initialise kernel data structures
*/
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;
ZeroFuncs[ 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;
}
}
InitHdlrFuncsFromTable(GVarFuncs);
InitFopyGVar("AddRowVector", &AddRowVectorOp);
/* return success */
return 0;
}
/****************************************************************************
**
*F InitKernel( <module> ) . . . . . . . . initialise kernel data structures
*/
static Int InitKernel (
StructInitInfo * module )
{
/* install the marking and sweeping methods */
InfoBags[ T_WPOBJ ].name = "object (weakptr)";
InfoBags[ T_WPOBJ +COPYING ].name = "object (weakptr, copied)";
InitMarkFuncBags ( T_WPOBJ, MarkWeakPointerObj );
InitSweepFuncBags( T_WPOBJ, SweepWeakPointerObj );
InitMarkFuncBags ( T_WPOBJ +COPYING, MarkWeakPointerObj );
InitSweepFuncBags( T_WPOBJ +COPYING, SweepWeakPointerObj );
/* typing method */
TypeObjFuncs[ T_WPOBJ ] = TypeWPObj;
ImportGVarFromLibrary( "TYPE_WPOBJ", &TYPE_WPOBJ );
/* init filters and functions */
InitHdlrFiltsFromTable( GVarFilts );
InitHdlrFuncsFromTable( GVarFuncs );
/* saving function */
SaveObjFuncs[ T_WPOBJ ] = SaveWPObj;
LoadObjFuncs[ T_WPOBJ ] = LoadWPObj;
/* copying functions */
CopyObjFuncs[ T_WPOBJ ] = CopyObjWPObj;
CopyObjFuncs[ T_WPOBJ + COPYING ] = CopyObjWPObjCopy;
CleanObjFuncs[ T_WPOBJ ] = CleanObjWPObj;
CleanObjFuncs[ T_WPOBJ + COPYING ] = CleanObjWPObjCopy;
MakeImmutableObjFuncs[ T_WPOBJ ] = MakeImmutableWPObj;
/* return success */
return 0;
}
/****************************************************************************
**
*F InitKernel( <module> ) . . . . . . . . initialise kernel data structures
*/
static Int InitKernel (
StructInitInfo * module )
{
InitHdlrFuncsFromTable( GVarFuncs );
InitGlobalBag( &STATE(ValueObj), "STATE(ValueObj)");
return 0;
}
/****************************************************************************
**
*F InitKernel( <module> ) . . . . . . . . initialise kernel data structures
*/
static Int InitKernel( StructInitInfo *module )
{
/* init filters and functions */
InitHdlrFuncsFromTable( GVarFuncs );
/* return success */
return 0;
}
/****************************************************************************
**
*F InitKernel( <module> ) . . . . . . . . initialise kernel data structures
*/
static Int InitKernel (
StructInitInfo * module )
{
/* Keep track of variables containing library functions called in this */
/* module. */
/* init filters and functions */
InitHdlrFuncsFromTable( GVarFuncs );
/* return success */
return 0;
}
static Int InitKernel(
StructInitInfo * module )
{
UInt i;
PtyIOStreams[0].childPID = -1;
for (i = 1; i < MAX_PTYS; i++)
{
PtyIOStreams[i].childPID = i-1;
PtyIOStreams[i].inuse = 0;
}
FreePtyIOStreams = MAX_PTYS-1;
/* init filters and functions */
InitHdlrFuncsFromTable( GVarFuncs );
/* Set up the trap to detect future dying children */
signal( SIGCHLD, ChildStatusChanged );
return 0;
}
/****************************************************************************
**
*F InitKernel( <module> ) . . . . . . . . initialise kernel data structures
*/
static Int InitKernel (
StructInitInfo * module )
{
UInt t1; /* type of left operand */
UInt t2; /* type of right operand */
/* init filters and functions */
InitHdlrOpersFromTable( GVarOpers );
InitHdlrFuncsFromTable( GVarFuncs );
/* make and install the 'ZERO' arithmetic operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
assert(ZeroFuncs[t1] == 0);
ZeroFuncs[t1] = ZeroObject;
}
InstallZeroObject(0);
/* make and install the 'ZERO_MUT' arithmetic operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
assert(ZeroMutFuncs[t1] == 0);
ZeroMutFuncs[t1] = ZeroMutObject;
}
InstallZeroMutObject(0);
/* make and install the 'AINV' arithmetic operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
assert(AInvFuncs[t1] == 0);
AInvFuncs[t1] = AInvObject;
}
InstallAInvObject(0);
/* make and install the 'AINV_MUT' arithmetic operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
assert(AInvMutFuncs[t1] == 0);
AInvMutFuncs[t1] = AInvMutObject;
}
InstallAInvMutObject(0);
/* make and install the 'ONE' arithmetic operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
assert(OneFuncs[t1] == 0);
OneFuncs[t1] = OneObject;
}
InstallOneObject(0);
/* make and install the 'ONE' arithmetic operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
assert(OneMutFuncs[t1] == 0);
OneMutFuncs[t1] = OneMutObject;
}
InstallOneMutObject(0);
/* make and install the 'INV' arithmetic operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
assert(InvFuncs[t1] == 0);
InvFuncs[t1] = InvObject;
}
InstallInvObject(0);
/* make and install the 'INV' arithmetic operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
assert(InvMutFuncs[t1] == 0);
InvMutFuncs[t1] = InvMutObject;
}
InstallInvMutObject(0);
/* make and install the 'EQ' comparison operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
for ( t2 = FIRST_REAL_TNUM; t2 <= LAST_REAL_TNUM; t2++ ) {
assert(EqFuncs[t1][t2] == 0);
EqFuncs[t1][t2] = EqNot;
}
}
InstallEqObject(0);
/* make and install the 'LT' comparison operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
for ( t2 = FIRST_REAL_TNUM; t2 <= LAST_REAL_TNUM; t2++ ) {
assert(LtFuncs[t1][t2] == 0);
LtFuncs[t1][t2] = LtObject;
}
}
InstallLtObject(0);
/* make and install the 'IN' comparison operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
for ( t2 = FIRST_REAL_TNUM; t2 <= LAST_REAL_TNUM; t2++ ) {
assert(InFuncs[t1][t2] == 0);
InFuncs[t1][t2] = InUndefined;
}
}
InstallInObject(0);
/* make and install the 'SUM' arithmetic operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
for ( t2 = FIRST_REAL_TNUM; t2 <= LAST_REAL_TNUM; t2++ ) {
assert(SumFuncs[t1][t2] == 0);
SumFuncs[t1][t2] = SumObject;
}
}
InstallSumObject(0);
/* make and install the 'DIFF' arithmetic operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
for ( t2 = FIRST_REAL_TNUM; t2 <= LAST_REAL_TNUM; t2++ ) {
assert(DiffFuncs[t1][t2] == 0);
DiffFuncs[t1][t2] = DiffDefault;
}
}
InstallDiffObject(0);
/* make and install the 'PROD' arithmetic operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
for ( t2 = FIRST_REAL_TNUM; t2 <= LAST_REAL_TNUM; t2++ ) {
assert(ProdFuncs[t1][t2] == 0);
ProdFuncs[t1][t2] = ProdObject;
}
}
InstallProdObject(0);
/* make and install the 'QUO' arithmetic operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
for ( t2 = FIRST_REAL_TNUM; t2 <= LAST_REAL_TNUM; t2++ ) {
assert(QuoFuncs[t1][t2] == 0);
QuoFuncs[t1][t2] = QuoDefault;
}
}
InstallQuoObject(0);
/* make and install the 'LQUO' arithmetic operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
for ( t2 = FIRST_REAL_TNUM; t2 <= LAST_REAL_TNUM; t2++ ) {
assert(LQuoFuncs[t1][t2] == 0);
LQuoFuncs[t1][t2] = LQuoDefault;
}
}
InstallLQuoObject(0);
/* make and install the 'POW' arithmetic operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
for ( t2 = FIRST_REAL_TNUM; t2 <= LAST_REAL_TNUM; t2++ ) {
assert(PowFuncs[t1][t2] == 0);
PowFuncs[t1][t2] = PowObject;
}
}
InstallPowObject(0);
/* make and install the 'COMM' arithmetic operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
for ( t2 = FIRST_REAL_TNUM; t2 <= LAST_REAL_TNUM; t2++ ) {
assert(CommFuncs[t1][t2] == 0);
CommFuncs[t1][t2] = CommDefault;
}
}
InstallCommObject(0);
/* make and install the 'MOD' arithmetic operation */
for ( t1 = FIRST_REAL_TNUM; t1 <= LAST_REAL_TNUM; t1++ ) {
for ( t2 = FIRST_REAL_TNUM; t2 <= LAST_REAL_TNUM; t2++ ) {
assert(ModFuncs[t1][t2] == 0);
ModFuncs[t1][t2] = ModObject;
}
}
InstallModObject(0);
/* return success */
return 0;
}
extern "C" int InitFPLLLKernel(void) {
InitHdlrFuncsFromTable (GVarFuncs);
return 0;
}
/****************************************************************************
**
*F InitKernel( <module> ) . . . . . . . . initialise kernel data structures
*/
static Int InitKernel (
StructInitInfo * module )
{
UInt type; /* loop variable */
/* make the list of names of record names */
InitGlobalBag( &NamesRNam, "src/records.c:NamesRNam" );
/* make the hash list of record names */
InitGlobalBag( &HashRNam, "src/records.c:HashRNam" );
/* init filters and functions */
InitHdlrFiltsFromTable( GVarFilts );
InitHdlrOpersFromTable( GVarOpers );
InitHdlrFuncsFromTable( GVarFuncs );
/* make and install the 'IS_REC' filter */
for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
assert(IsRecFuncs[ type ] == 0);
IsRecFuncs[ type ] = AlwaysNo;
}
for ( type = FIRST_RECORD_TNUM; type <= LAST_RECORD_TNUM; type++ ) {
IsRecFuncs[ type ] = AlwaysYes;
}
for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM; type++ ) {
IsRecFuncs[ type ] = IsRecObject;
}
/* make and install the 'ELM_REC' operations */
for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
assert(ElmRecFuncs[ type ] == 0);
ElmRecFuncs[ type ] = ElmRecError;
}
for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM; type++ ) {
ElmRecFuncs[ type ] = ElmRecObject;
}
/* make and install the 'ISB_REC' operation */
for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
assert(IsbRecFuncs[ type ] == 0);
IsbRecFuncs[ type ] = IsbRecError;
}
for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM; type++ ) {
IsbRecFuncs[ type ] = IsbRecObject;
}
/* make and install the 'ASS_REC' operation */
for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
assert(AssRecFuncs[ type ] == 0);
AssRecFuncs[ type ] = AssRecError;
}
for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM; type++ ) {
AssRecFuncs[ type ] = AssRecObject;
}
/* make and install the 'UNB_REC' operation */
for ( type = FIRST_REAL_TNUM; type <= LAST_REAL_TNUM; type++ ) {
assert(UnbRecFuncs[ type ] == 0);
UnbRecFuncs[ type ] = UnbRecError;
}
for ( type = FIRST_EXTERNAL_TNUM; type <= LAST_EXTERNAL_TNUM; type++ ) {
UnbRecFuncs[ type ] = UnbRecObject;
}
/* return success */
return 0;
}
/****************************************************************************
**
*F InitKernel( <module> ) . . . . . . . . initialise kernel data structures
*/
static Int InitKernel (
StructInitInfo * module )
{
Int EqObject (Obj,Obj);
/* install the marking functions for macfloatean values */
InfoBags[ T_MACFLOAT ].name = "macfloat";
InitMarkFuncBags( T_MACFLOAT, MarkNoSubBags );
MakeBagTypePublic( T_MACFLOAT );
/* init functions */
InitHdlrFuncsFromTable( GVarFuncs );
/* install the type function */
ImportGVarFromLibrary( "TYPE_MACFLOAT", &TYPE_MACFLOAT );
TypeObjFuncs[ T_MACFLOAT ] = TypeMacfloat;
/* install the saving functions */
SaveObjFuncs[ T_MACFLOAT ] = SaveMacfloat;
/* install the loading functions */
LoadObjFuncs[ T_MACFLOAT ] = LoadMacfloat;
/* install the printer for macfloatean values */
PrintObjFuncs[ T_MACFLOAT ] = PrintMacfloat;
/* install the comparison functions */
EqFuncs[ T_MACFLOAT ][ T_MACFLOAT ] = EqMacfloat;
LtFuncs[ T_MACFLOAT ][ T_MACFLOAT ] = LtMacfloat;
/* allow method selection to protest against comparisons of float and int */
{
int t;
for (t = T_INT; t <= T_CYC; t++)
EqFuncs[T_MACFLOAT][t] = EqFuncs[t][T_MACFLOAT] = EqObject;
}
/* install the unary arithmetic methods */
ZeroFuncs[ T_MACFLOAT ] = ZeroMacfloat;
ZeroMutFuncs[ T_MACFLOAT ] = ZeroMacfloat;
AInvMutFuncs[ T_MACFLOAT ] = AInvMacfloat;
OneFuncs [ T_MACFLOAT ] = OneMacfloat;
OneMutFuncs [ T_MACFLOAT ] = OneMacfloat;
InvFuncs [ T_MACFLOAT ] = InvMacfloat;
/* install binary arithmetic methods */
ProdFuncs[ T_MACFLOAT ][ T_MACFLOAT ] = ProdMacfloat;
PowFuncs [ T_MACFLOAT ][ T_MACFLOAT ] = PowMacfloat;
SumFuncs[ T_MACFLOAT ][ T_MACFLOAT ] = SumMacfloat;
DiffFuncs [ T_MACFLOAT ][ T_MACFLOAT ] = DiffMacfloat;
QuoFuncs [ T_MACFLOAT ][ T_MACFLOAT ] = QuoMacfloat;
LQuoFuncs [ T_MACFLOAT ][ T_MACFLOAT ] = LQuoMacfloat;
ModFuncs [ T_MACFLOAT ][ T_MACFLOAT ] = ModMacfloat;
SumFuncs [ T_INT ][ T_MACFLOAT ] = SumIntMacfloat;
/* Probably support mixed ops with small ints in the kernel as well
on any reasonable system, all small ints should have macfloat equivalents
Anything else, like mixed ops with rationals, we can leave to the library
at least for a while */
/* return success */
return 0;
}
static Int InitKernel ( StructInitInfo * module )
{
InitHdlrFuncsFromTable( GVarFuncs );
InitP1Kernel();
return 0;
}
