Exemple #1
0
/* VMArenaDescribe -- describe the VMArena
 */
static Res VMArenaDescribe(Arena arena, mps_lib_FILE *stream)
{
  Res res;
  VMArena vmArena;

  if (!TESTT(Arena, arena)) return ResFAIL;
  if (stream == NULL) return ResFAIL;
  vmArena = Arena2VMArena(arena);
  if (!TESTT(VMArena, vmArena)) return ResFAIL;

  /* Describe the superclass fields first via next-method call */
  /* ...but the next method is ArenaTrivDescribe, so don't call it;
   * see impl.c.arena#describe.triv.dont-upcall.
   *
  super = ARENA_SUPERCLASS(VMArenaClass);
  res = super->describe(arena, stream);
  if (res != ResOK) return res;
   *
  */

  res = WriteF(stream,
               "  spareSize:     $U\n", (WriteFU)vmArena->spareSize,
               NULL);
  if(res != ResOK)
    return res;

  /* (incomplete: some fields are not Described) */

  return ResOK;
}
Exemple #2
0
static Compare shieldQueueEntryCompare(void *left, void *right, void *closure)
{
  Seg segA = left, segB = right;

  /* These checks are not critical in a hot build, but slow down cool
     builds quite a bit, so just check the signatures. */
  AVER(TESTT(Seg, segA));
  AVER(TESTT(Seg, segB));
  UNUSED(closure);

  return shieldAddrCompare(SegBase(segA), SegBase(segB));
}
Exemple #3
0
Res SplayTreeDescribe(SplayTree splay, mps_lib_FILE *stream, Count depth,
                      TreeDescribeFunction nodeDescribe)
{
  Res res;

  if (!TESTT(SplayTree, splay))
    return ResFAIL;
  if (stream == NULL)
    return ResFAIL;
  if (nodeDescribe == NULL)
    return ResFAIL;

  res = WriteF(stream, depth,
               "Splay $P {\n", (WriteFP)splay,
               "  compare $F\n", (WriteFF)splay->compare,
               "  nodeKey $F\n", (WriteFF)splay->nodeKey,
               "  updateNode $F\n", (WriteFF)splay->updateNode,
               NULL);
  if (res != ResOK)
    return res;

  if (SplayTreeRoot(splay) != TreeEMPTY) {
    res = WriteF(stream, depth, "  tree ", NULL);
    if (res != ResOK)
      return res;
    res = SplayNodeDescribe(SplayTreeRoot(splay), stream, nodeDescribe);
    if (res != ResOK)
      return res;
  }

  res = WriteF(stream, depth, "\n} Splay $P\n", (WriteFP)splay, NULL);
  return res;
}
Exemple #4
0
void mps_fmt_destroy(mps_fmt_t format)
{
  Arena arena;

  AVER(TESTT(Format, format));
  arena = FormatArena(format);

  ArenaEnter(arena);

  FormatDestroy(format);

  ArenaLeave(arena);
}
Exemple #5
0
Res ChunkNodeDescribe(Tree node, mps_lib_FILE *stream)
{
  Chunk chunk;

  if (!TreeCheck(node))
    return ResFAIL;
  if (stream == NULL)
    return ResFAIL;
  chunk = ChunkOfTree(node);
  if (!TESTT(Chunk, chunk))
    return ResFAIL;

  return WriteF(stream, 0, "[$P,$P)", (WriteFP)chunk->base,
                (WriteFP)chunk->limit, NULL);
}
Exemple #6
0
void mps_pool_check_free_space(mps_pool_t mps_pool)
{
  Pool pool = (Pool)mps_pool;
  Arena arena;
  
  /* TESTT not AVERT, see <design/interface-c#.check.space */
  AVER(TESTT(Pool, pool));
  arena = PoolArena(pool);

  ArenaEnter(arena);

  AVERT(Pool, pool);
  DebugPoolCheckFreeSpace(pool);

  ArenaLeave(arena);
}
Exemple #7
0
void mps_pool_check_fenceposts(mps_pool_t mps_pool)
{
  Pool pool = (Pool)mps_pool;
  Arena arena;
  
  /* TESTT not AVERT, see <design/interface-c/#check.space */
  AVER(TESTT(Pool, pool));
  arena = PoolArena(pool);

  ArenaEnter(arena);

  AVERT(Pool, pool);
  DebugPoolCheckFences(pool);

  ArenaLeave(arena);
}
Exemple #8
0
static Res ArenaTrivDescribe(Arena arena, mps_lib_FILE *stream)
{
  if (!TESTT(Arena, arena)) return ResFAIL;
  if (stream == NULL) return ResFAIL;

  /* .describe.triv.never-called-from-subclass-method:
   * This Triv method seems to assume that it will never get called
   * from a subclass-method invoking ARENA_SUPERCLASS()->describe.
   * It assumes that it only gets called if the describe method has
   * not been subclassed.  (That's the only reason for printing the
   * "No class-specific description available" message).
   * This is bogus, but that's the status quo.  RHSK 2007-04-27.
   */
  /* .describe.triv.dont-upcall: Therefore (for now) the last 
   * subclass describe method should avoid invoking 
   * ARENA_SUPERCLASS()->describe.  RHSK 2007-04-27.
   */
  return WriteF(stream,
    "  No class-specific description available.\n", NULL);
}
Exemple #9
0
void test_modular_traits(){

        typedef CGAL::Residue Residue;
        typedef CGAL::Modular_traits<TESTT> MT;
        typedef typename MT::Residue_type Residue_type;
        typedef typename MT::Modular_image Modular_image;
        typedef typename MT::Modular_image_representative Modular_image_representative;
        typedef typename MT::Is_modularizable Is_modularizable;
        typedef typename MT::NT NT;
        
        assert(
            !(::boost::is_same<CGAL::Null_functor,Modular_image>::value));
        assert(
            !(::boost::is_same<CGAL::Null_functor,Modular_image_representative>::value));
        assert(
            (::boost::is_same<CGAL::Tag_true,Is_modularizable>::value));
        assert(
            (::boost::is_same<TESTT,NT>::value));
        
        Residue::set_current_prime(7);
        Modular_image modular_image;
        assert(modular_image(TESTT(10)+TESTT(10)) == Residue_type(-1)); 
        assert(modular_image(TESTT(2) *TESTT(10)) == Residue_type(-1)); 
        assert(modular_image(TESTT(20)) == Residue_type(-1)); 
        assert(modular_image(TESTT(20)) == Residue_type(6));   
        assert(modular_image(TESTT(21)) == Residue_type(0));   
        assert(modular_image(TESTT(22)) == Residue_type(1));
        assert(modular_image(TESTT(777777722)) == Residue_type(1));

        Modular_image_representative modular_image_representative;
        assert(modular_image_representative(modular_image(TESTT(20)))
            == TESTT(-1)); 
}