Quelle bool.c Sprache: C

/****************************************************************************
**
**  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.0-or-later
**
**  This file contains the functions for the boolean package.
**
**  Note that boolean objects actually contain no data. The three of them
**  are distinguished by their addresses, kept in the C globals False,
**  True and Fail.
*/

#include "bool.h"

#include "ariths.h"
#include "calls.h"
#include "gvars.h"
#include "io.h"
#include "modules.h"
#include "opers.h"

/****************************************************************************
**
*V  True  . . . . . . . . . . . . . . . . . . . . . . . . . . . .  true value
**
**   'True' is the value 'true'.
*/
Obj True;

/****************************************************************************
**
*V  False . . . . . . . . . . . . . . . . . . . . . . . . . . . . false value
**
**  'False' is the value 'false'.
*/
Obj False;

/****************************************************************************
**
*V  Fail  . . . . . . . . . . . . . . . . . . . . . . . . . . . .  fail value
**
**  'Fail' is the value 'fail'.
*/
Obj Fail;

/****************************************************************************
**
*V  Undefined  . . . . . . . . . . . . . . . . . . . . . . . undefined value
**
**  'Undefined' is a special object that is used in lieu of (Obj) 0 in places
**  where the kernel cannot handle a null reference easily. This object is
**  never exposed to GAP code and only used within the kernel.
*/
Obj Undefined;

/****************************************************************************
**
*F  TypeBool( <bool> )  . . . . . . . . . . . . . . . type of a boolean value
**
**  'TypeBool' returns the type of boolean values.
**
**  'TypeBool' is the function in 'TypeObjFuncs' for boolean values.
*/
static Obj TYPE_BOOL;

static Obj TypeBool(Obj val)
{
    return TYPE_BOOL;
}

/****************************************************************************
**
*F  PrintBool( <val> ) . . . . . . . . . . . . . . . .  print a boolean value
**
**  'PrintBool' prints the boolean value <val>.
*/
static void PrintBool(Obj val)
{
    if (val == True) {
        Pr("true", 0, 0);
    }
    else if (val == False) {
        Pr("false", 0, 0);
    }
    else if (val == Fail) {
        Pr("fail", 0, 0);
    }
    else {
        Pr("<>", 0, 0);
    }
}

/****************************************************************************
**
*F  EqBool( <boolL>, <boolR> )  . . . . . . . . .  test if <boolL> =  <boolR>
**
**  'EqBool' returns '1' if the two boolean values <boolL> and <boolR> are
**  equal, and '0' otherwise.
*/
static Int EqBool(Obj boolL, Obj boolR)
{
    return boolL == boolR;
}

/****************************************************************************
**
*F  LtBool( <boolL>, <boolR> )  . . . . . . . . .  test if <boolL> <  <boolR>
**
**  The ordering of Booleans is true < false < fail.
*/
static Int LtBool(Obj boolL, Obj boolR)
{
    if (boolL == True)
        return boolR != True;
    if (boolL == False)
        return boolR == Fail;
    return 0;
}

/****************************************************************************
**
*F  IsBoolFilt( <self>, <obj> ) . . . . . . . . . .  test for a boolean value
**
**  'IsBoolFilt' implements the internal filter 'IsBool'.
**
**  'IsBool( <obj> )'
**
**  'IsBool'  returns  'true'  if  <obj>  is   a boolean  value  and  'false'
**  otherwise.
*/
static Obj IsBoolFilt;

static Obj FiltIS_BOOL(Obj self, Obj obj)
{
    // return 'true' if <obj> is a boolean and 'false' otherwise
    if ( TNUM_OBJ(obj) == T_BOOL ) {
        return True;
    }
    else if ( TNUM_OBJ(obj) < FIRST_EXTERNAL_TNUM ) {
        return False;
    }
    else {
        return DoFilter( self, obj );
    }
}

/****************************************************************************
**
*F  ReturnTrue1( <val1> ) . . . . . . . . . . . . . . . . . .  return  'True'
**
**  'ReturnTrue?'  simply return  'True'  independent of  the values of   the
**  arguments.
**
**  Those  functions are  useful for  dispatcher  tables if the types already
**  determine the outcome.
*/
static Obj ReturnTrue1(Obj self, Obj val1)
{
    return True;
}

/****************************************************************************
**
*F  ReturnTrue2( <val1>, <val2> ) . . . . . . . . . . . . . .  return  'True'
*/
static Obj ReturnTrue2(Obj self, Obj val1, Obj val2)
{
    return True;
}

/****************************************************************************
**
*F  ReturnTrue3( <val1>, <val2>, <val3> ) . . . . . . . . . .  return  'True'
*/
static Obj ReturnTrue3(Obj self, Obj val1, Obj val2, Obj val3)
{
    return True;
}

/****************************************************************************
**
*F  ReturnFalse1( <val1> )  . . . . . . . . . . . . . . . . .  return 'False'
**
**  'ReturnFalse?' likewise return 'False'.
*/
static Obj ReturnFalse1(Obj self, Obj val1)
{
    return False;
}

/****************************************************************************
**
*F  ReturnFalse2( <val1>, <val2> )  . . . . . . . . . . . . .  return 'False'
*/
static Obj ReturnFalse2(Obj self, Obj val1, Obj val2)
{
    return False;
}

/****************************************************************************
**
*F  ReturnFalse3( <val1>, <val2>, <val3> )  . . . . . . . . .  return 'False'
*/
static Obj ReturnFalse3(Obj self, Obj val1, Obj val2, Obj val3)
{
    return False;
}

/****************************************************************************
**
*F  ReturnFail1( <val1> ) . . . . . . . . . . . . . . . . . .  return  'Fail'
**
**  'ReturnFail?' likewise return 'Fail'.
*/
static Obj ReturnFail1(Obj self, Obj val1)
{
    return Fail;
}

/****************************************************************************
**
*F  ReturnFail2( <val1>, <val2> ) . . . . . . . . . . . . . .  return  'Fail'
*/
static Obj ReturnFail2(Obj self, Obj val1, Obj val2)
{
    return Fail;
}

/****************************************************************************
**
*F  ReturnFail3( <val1>, <val2>, <val3> ) . . . . . . . . . .  return  'Fail'
*/
static Obj ReturnFail3(Obj self, Obj val1, Obj val2, Obj val3)
{
    return Fail;
}

/****************************************************************************
**
*F  SaveBool( <bool> ) . . . . . . . . . . . . . . . . . . . . save a Boolean
**
**  Actually, there is nothing to do
*/
#ifdef GAP_ENABLE_SAVELOAD
static void SaveBool(Obj obj)
{
}
#endif

/****************************************************************************
**
*F  LoadBool( <bool> ) . . . . . . . . . . . . . . . . . . . . save a Boolean
**
**  Actually, there is nothing to do
*/
#ifdef GAP_ENABLE_SAVELOAD
static void LoadBool(Obj obj)
{
}
#endif

/****************************************************************************
**
*F * * * * * * * * * * * * * initialize module * * * * * * * * * * * * * * *
*/

/****************************************************************************
**
*V  BagNames  . . . . . . . . . . . . . . . . . . . . . . . list of bag names
*/
static StructBagNames BagNames[] = {
  { T_BOOL, "boolean or fail" },
  { -1,     "" }
};

/****************************************************************************
**
*V  GVarFilts . . . . . . . . . . . . . . . . . . . list of filters to export
*/
static StructGVarFilt GVarFilts [] = {

    GVAR_FILT(IS_BOOL, "obj", &IsBoolFilt),
    { 0, 0, 0, 0, 0 }

};

/****************************************************************************
**
*F  InitKernel( <module> )  . . . . . . . . initialise kernel data structures
*/
static Int InitKernel (
    StructInitInfo *    module )
{
    // set the bag type names (for error messages and debugging)
    InitBagNamesFromTable( BagNames );

    // install the marking functions for boolean values
    InitMarkFuncBags( T_BOOL, MarkNoSubBags );

    // init filters and functions
    InitHdlrFiltsFromTable( GVarFilts );

    // make and install the 'RETURN_TRUE' function
    InitHandlerFunc( ReturnTrue1, "src/bool.c:ReturnTrue1" );
    InitHandlerFunc( ReturnTrue2, "src/bool.c:ReturnTrue2" );
    InitHandlerFunc( ReturnTrue3, "src/bool.c:ReturnTrue3" );

    // make and install the 'RETURN_FALSE' function
    InitHandlerFunc( ReturnFalse1, "src/bool.c:ReturnFalse1" );
    InitHandlerFunc( ReturnFalse2, "src/bool.c:ReturnFalse2" );
    InitHandlerFunc( ReturnFalse3, "src/bool.c:ReturnFalse3" );

    // make and install the 'RETURN_FAIL' function
    InitHandlerFunc( ReturnFail1, "src/bool.c:ReturnFail1" );
    InitHandlerFunc( ReturnFail2, "src/bool.c:ReturnFail2" );
    InitHandlerFunc( ReturnFail3, "src/bool.c:ReturnFail3" );

    // install the type function
    ImportGVarFromLibrary( "TYPE_BOOL", &TYPE_BOOL );
    TypeObjFuncs[ T_BOOL ] = TypeBool;

    // register boolean bags with the garbage collector
    InitGlobalBag( &True,  "src/bool.c:TRUE"  );
    InitGlobalBag( &False, "src/bool.c:FALSE" );
    InitGlobalBag( &Fail,  "src/bool.c:FAIL"  );
    InitGlobalBag( &Undefined,  "src/bool.c:UNDEFINED"  );

#ifdef GAP_ENABLE_SAVELOAD
    // install the saving functions
    SaveObjFuncs[ T_BOOL ] = SaveBool;

    // install the loading functions
    LoadObjFuncs[ T_BOOL ] = LoadBool;
#endif

    // install the printer for boolean values
    PrintObjFuncs[ T_BOOL ] = PrintBool;

    // install the comparison functions
    EqFuncs[ T_BOOL ][ T_BOOL ] = EqBool;
    LtFuncs[ T_BOOL ][ T_BOOL ] = LtBool;

#ifdef HPCGAP
    MakeBagTypePublic(T_BOOL);
#endif
    return 0;
}

/****************************************************************************
**
*F  InitLibrary( <module> ) . . . . . . .  initialise library data structures
*/
static Int InitLibrary (
    StructInitInfo *    module )
{
    Obj             tmp;

    // init filters and functions
    InitGVarFiltsFromTable( GVarFilts );

    // bags are registered in 'InitKernel'
    True  = NewBag(T_BOOL, 0);
    False = NewBag(T_BOOL, 0);
    Fail  = NewBag(T_BOOL, 0);

    // `fail' is a variable not a language construct
    AssReadOnlyGVar( GVarName( "fail" ), Fail );

    // Undefined is an internal value
    Undefined = NewBag(T_BOOL, 0);

    // make and install the 'RETURN_TRUE' function
    tmp = NewFunctionC("RETURN_TRUE", -1, "arg", ReturnTrue1);
    SET_HDLR_FUNC( tmp, 1, ReturnTrue1);
    SET_HDLR_FUNC( tmp, 2, ReturnTrue2);
    SET_HDLR_FUNC( tmp, 3, ReturnTrue3);
    AssReadOnlyGVar( GVarName("RETURN_TRUE"), tmp );

    // make and install the 'RETURN_FALSE' function
    tmp = NewFunctionC("RETURN_FALSE", -1, "arg", ReturnFalse1);
    SET_HDLR_FUNC( tmp, 1, ReturnFalse1);
    SET_HDLR_FUNC( tmp, 2, ReturnFalse2);
    SET_HDLR_FUNC( tmp, 3, ReturnFalse3);
    AssReadOnlyGVar( GVarName( "RETURN_FALSE" ), tmp );

    // make and install the 'RETURN_FAIL' function
    tmp = NewFunctionC("RETURN_FAIL", -1, "arg", ReturnFail1);
    SET_HDLR_FUNC( tmp, 1, ReturnFail1);
    SET_HDLR_FUNC( tmp, 2, ReturnFail2);
    SET_HDLR_FUNC( tmp, 3, ReturnFail3);
    AssReadOnlyGVar( GVarName( "RETURN_FAIL" ), tmp );

    return 0;
}

/****************************************************************************
**
*F  InitInfoBool()  . . . . . . . . . . . . . . . . . table of init functions
*/
static StructInitInfo module = {
    // init struct using C99 designated initializers; for a full list of
    // fields, please refer to the definition of StructInitInfo
    .type = MODULE_BUILTIN,
    .name = "bool",
    .initKernel = InitKernel,
    .initLibrary = InitLibrary,
};

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

quality100%

¤ Dauer der Verarbeitung: 0.28 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.