src/fflib/lgmesh3.cpp:1016: error: NULL_DEREFERENCE
  pointer `Vh` last assigned on line 1012 could be null and is dereferenced at line 1016, column 20.
Showing all 116 steps of the trace


src/fflib/lgmesh3.cpp:1006:1: start of procedure operator()
1004.   
1005.   template<class K,class v_fes>   
1006. > AnyType E_set_fev3<K,v_fes>::operator()(Stack s)  const
1007.   {  
1008.     StackOfPtr2Free * sptr = WhereStackOfPtr2Free(s);     

src/fflib/lgmesh3.cpp:1008:3: Skipping WhereStackOfPtr2Free(): function or method not found
1006.   AnyType E_set_fev3<K,v_fes>::operator()(Stack s)  const
1007.   {  
1008.     StackOfPtr2Free * sptr = WhereStackOfPtr2Free(s);     
          ^
1009.     MeshPoint *mps=MeshPointStack(s), mp=*mps;   
1010.     FEbase<K,v_fes> ** pp=GetAny< FEbase<K,v_fes> **>((*ppfe)(s));

src/fflib/lgmesh3.cpp:1009:3: 
1007.   {  
1008.     StackOfPtr2Free * sptr = WhereStackOfPtr2Free(s);     
1009. >   MeshPoint *mps=MeshPointStack(s), mp=*mps;   
1010.     FEbase<K,v_fes> ** pp=GetAny< FEbase<K,v_fes> **>((*ppfe)(s));
1011.     FEbase<K,v_fes> & fe(**pp);

src/femlib/MeshPoint.hpp:471:1: start of procedure Fem2D::MeshPointStack()
  469.   
  470.   ostream & operator << ( ostream &,const  MeshPoint & )  ;    
  471. > inline static MeshPoint* MeshPointStack(Stack s) {void * p= static_cast<void **>(s)[MeshPointStackOffset];throwassert(p); return static_cast<MeshPoint*>( p);}
  472.   inline static void MeshPointStack(Stack s,MeshPoint* mp) {*static_cast<MeshPoint**>(static_cast<void *>(s)) = mp;}
  473.   #ifdef NEWFFSTACK

src/femlib/MeshPoint.hpp:471:51: 
  469.   
  470.   ostream & operator << ( ostream &,const  MeshPoint & )  ;    
  471. > inline static MeshPoint* MeshPointStack(Stack s) {void * p= static_cast<void **>(s)[MeshPointStackOffset];throwassert(p); return static_cast<MeshPoint*>( p);}
  472.   inline static void MeshPointStack(Stack s,MeshPoint* mp) {*static_cast<MeshPoint**>(static_cast<void *>(s)) = mp;}
  473.   #ifdef NEWFFSTACK

src/femlib/MeshPoint.hpp:471:123: 
  469.   
  470.   ostream & operator << ( ostream &,const  MeshPoint & )  ;    
  471. > inline static MeshPoint* MeshPointStack(Stack s) {void * p= static_cast<void **>(s)[MeshPointStackOffset];throwassert(p); return static_cast<MeshPoint*>( p);}
  472.   inline static void MeshPointStack(Stack s,MeshPoint* mp) {*static_cast<MeshPoint**>(static_cast<void *>(s)) = mp;}
  473.   #ifdef NEWFFSTACK

src/femlib/MeshPoint.hpp:471:158: return from a call to Fem2D::MeshPointStack
  469.   
  470.   ostream & operator << ( ostream &,const  MeshPoint & )  ;    
  471.   inline static MeshPoint* MeshPointStack(Stack s) {void * p= static_cast<void **>(s)[MeshPointStackOffset];throwassert(p); return static_cast<MeshPoint*>( p);}
                                                                                                                                                                      ^
  472.   inline static void MeshPointStack(Stack s,MeshPoint* mp) {*static_cast<MeshPoint**>(static_cast<void *>(s)) = mp;}
  473.   #ifdef NEWFFSTACK

src/fflib/lgmesh3.cpp:1009:3: 
1007.   {  
1008.     StackOfPtr2Free * sptr = WhereStackOfPtr2Free(s);     
1009. >   MeshPoint *mps=MeshPointStack(s), mp=*mps;   
1010.     FEbase<K,v_fes> ** pp=GetAny< FEbase<K,v_fes> **>((*ppfe)(s));
1011.     FEbase<K,v_fes> & fe(**pp);

src/femlib/MeshPoint.hpp:373:7: start of procedure MeshPoint
  371.     // --------  
  372.   };
  373.   class MeshPoint : public MeshPointBase { public:
               ^
  374.     MeshPointBase other;
  375.     void unset() {  MeshPointBase::unset(); other.unset();}

src/femlib/MeshPoint.hpp:15:7: start of procedure MeshPointBase
    13.   const long notaregion=LONG_MIN;
    14.   const double doublenotset = -123e100;
    15.   class MeshPointBase { public:
                ^
    16.     
    17.     R3 P;

src/femlib/R3.hpp:38:7: start of procedure R3
      36.   #include "R2.hpp" 
      37.   
      38.   class R3  {
                  ^
      39.   
      40.   public:  

src/femlib/R3.hpp:38:7: return from a call to Fem2D::R3_R3
      36.   #include "R2.hpp" 
      37.   
      38.   class R3  {
                  ^
      39.   
      40.   public:  

src/femlib/MeshPoint.hpp:15:7: 
    13.   const long notaregion=LONG_MIN;
    14.   const double doublenotset = -123e100;
    15. > class MeshPointBase { public:
    16.     
    17.     R3 P;

src/femlib/R3.hpp:38:7: start of procedure R3
      36.   #include "R2.hpp" 
      37.   
      38.   class R3  {
                  ^
      39.   
      40.   public:  

src/femlib/R3.hpp:38:7: return from a call to Fem2D::R3_R3
      36.   #include "R2.hpp" 
      37.   
      38.   class R3  {
                  ^
      39.   
      40.   public:  

src/femlib/MeshPoint.hpp:15:7: 
    13.   const long notaregion=LONG_MIN;
    14.   const double doublenotset = -123e100;
    15. > class MeshPointBase { public:
    16.     
    17.     R3 P;

src/femlib/MeshPoint.hpp:19:3: start of procedure 
      17.     R3 P;
      18.     R3 PHat;
      19.     union {
              ^
      20.     const Mesh * Th;  
      21.     const Mesh3 * Th3;  

src/femlib/MeshPoint.hpp:19:3: return from a call to Fem2D::MeshPointBase::anonymous_union_._.._femlib_MeshPoint.hpp:19:3_
      17.     R3 P;
      18.     R3 PHat;
      19.     union {
              ^
      20.     const Mesh * Th;  
      21.     const Mesh3 * Th3;  

src/femlib/MeshPoint.hpp:15:7: 
    13.   const long notaregion=LONG_MIN;
    14.   const double doublenotset = -123e100;
    15. > class MeshPointBase { public:
    16.     
    17.     R3 P;

src/femlib/MeshPoint.hpp:23:3: start of procedure 
      21.     const Mesh3 * Th3;  
      22.     };
      23.     union{
              ^
      24.     const Triangle * T;
      25.     const Tet * T3;

src/femlib/MeshPoint.hpp:23:3: return from a call to Fem2D::MeshPointBase::anonymous_union_._.._femlib_MeshPoint.hpp:23:3_
      21.     const Mesh3 * Th3;  
      22.     };
      23.     union{
              ^
      24.     const Triangle * T;
      25.     const Tet * T3;

src/femlib/MeshPoint.hpp:15:7: 
    13.   const long notaregion=LONG_MIN;
    14.   const double doublenotset = -123e100;
    15. > class MeshPointBase { public:
    16.     
    17.     R3 P;

src/femlib/R3.hpp:38:7: start of procedure R3
      36.   #include "R2.hpp" 
      37.   
      38.   class R3  {
                  ^
      39.   
      40.   public:  

src/femlib/R3.hpp:38:7: return from a call to Fem2D::R3_R3
      36.   #include "R2.hpp" 
      37.   
      38.   class R3  {
                  ^
      39.   
      40.   public:  

src/femlib/MeshPoint.hpp:15:7: return from a call to Fem2D::MeshPointBase_MeshPointBase
    13.   const long notaregion=LONG_MIN;
    14.   const double doublenotset = -123e100;
    15.   class MeshPointBase { public:
                ^
    16.     
    17.     R3 P;

src/femlib/MeshPoint.hpp:373:7: 
  371.     // --------  
  372.   };
  373. > class MeshPoint : public MeshPointBase { public:
  374.     MeshPointBase other;
  375.     void unset() {  MeshPointBase::unset(); other.unset();}

src/femlib/MeshPoint.hpp:15:7: start of procedure MeshPointBase
    13.   const long notaregion=LONG_MIN;
    14.   const double doublenotset = -123e100;
    15.   class MeshPointBase { public:
                ^
    16.     
    17.     R3 P;

src/femlib/R3.hpp:38:7: start of procedure R3
      36.   #include "R2.hpp" 
      37.   
      38.   class R3  {
                  ^
      39.   
      40.   public:  

src/femlib/R3.hpp:38:7: return from a call to Fem2D::R3_R3
      36.   #include "R2.hpp" 
      37.   
      38.   class R3  {
                  ^
      39.   
      40.   public:  

src/femlib/MeshPoint.hpp:15:7: 
    13.   const long notaregion=LONG_MIN;
    14.   const double doublenotset = -123e100;
    15. > class MeshPointBase { public:
    16.     
    17.     R3 P;

src/femlib/R3.hpp:38:7: start of procedure R3
      36.   #include "R2.hpp" 
      37.   
      38.   class R3  {
                  ^
      39.   
      40.   public:  

src/femlib/R3.hpp:38:7: return from a call to Fem2D::R3_R3
      36.   #include "R2.hpp" 
      37.   
      38.   class R3  {
                  ^
      39.   
      40.   public:  

src/femlib/MeshPoint.hpp:15:7: 
    13.   const long notaregion=LONG_MIN;
    14.   const double doublenotset = -123e100;
    15. > class MeshPointBase { public:
    16.     
    17.     R3 P;

src/femlib/MeshPoint.hpp:19:3: start of procedure 
      17.     R3 P;
      18.     R3 PHat;
      19.     union {
              ^
      20.     const Mesh * Th;  
      21.     const Mesh3 * Th3;  

src/femlib/MeshPoint.hpp:19:3: return from a call to Fem2D::MeshPointBase::anonymous_union_._.._femlib_MeshPoint.hpp:19:3_
      17.     R3 P;
      18.     R3 PHat;
      19.     union {
              ^
      20.     const Mesh * Th;  
      21.     const Mesh3 * Th3;  

src/femlib/MeshPoint.hpp:15:7: 
    13.   const long notaregion=LONG_MIN;
    14.   const double doublenotset = -123e100;
    15. > class MeshPointBase { public:
    16.     
    17.     R3 P;

src/femlib/MeshPoint.hpp:23:3: start of procedure 
      21.     const Mesh3 * Th3;  
      22.     };
      23.     union{
              ^
      24.     const Triangle * T;
      25.     const Tet * T3;

src/femlib/MeshPoint.hpp:23:3: return from a call to Fem2D::MeshPointBase::anonymous_union_._.._femlib_MeshPoint.hpp:23:3_
      21.     const Mesh3 * Th3;  
      22.     };
      23.     union{
              ^
      24.     const Triangle * T;
      25.     const Tet * T3;

src/femlib/MeshPoint.hpp:15:7: 
    13.   const long notaregion=LONG_MIN;
    14.   const double doublenotset = -123e100;
    15. > class MeshPointBase { public:
    16.     
    17.     R3 P;

src/femlib/R3.hpp:38:7: start of procedure R3
      36.   #include "R2.hpp" 
      37.   
      38.   class R3  {
                  ^
      39.   
      40.   public:  

src/femlib/R3.hpp:38:7: return from a call to Fem2D::R3_R3
      36.   #include "R2.hpp" 
      37.   
      38.   class R3  {
                  ^
      39.   
      40.   public:  

src/femlib/MeshPoint.hpp:15:7: return from a call to Fem2D::MeshPointBase_MeshPointBase
    13.   const long notaregion=LONG_MIN;
    14.   const double doublenotset = -123e100;
    15.   class MeshPointBase { public:
                ^
    16.     
    17.     R3 P;

src/femlib/MeshPoint.hpp:373:7: return from a call to Fem2D::MeshPoint_MeshPoint
  371.     // --------  
  372.   };
  373.   class MeshPoint : public MeshPointBase { public:
               ^
  374.     MeshPointBase other;
  375.     void unset() {  MeshPointBase::unset(); other.unset();}

src/fflib/lgmesh3.cpp:1010:3: Skipping operator(): function or method not found
1008.     StackOfPtr2Free * sptr = WhereStackOfPtr2Free(s);     
1009.     MeshPoint *mps=MeshPointStack(s), mp=*mps;   
1010.     FEbase<K,v_fes> ** pp=GetAny< FEbase<K,v_fes> **>((*ppfe)(s));
          ^
1011.     FEbase<K,v_fes> & fe(**pp);
1012.     const  FESpace & Vh(*fe.newVh());

src/fflib/AnyType.hpp:190:23: start of procedure GetAny<FEbase<double,_v_fes3>_**>()
  188.   
  189.   
  190.    template<typename T> inline  const T& GetAny(const AnyTypeWithOutCheck & x)
                               ^
  191.   { 
  192.    CheckSize<T,sizeof(T)<= sizeof(AnyData) >();

src/fflib/AnyType.hpp:192:2: Skipping CheckSize: function or method not found
  190.    template<typename T> inline  const T& GetAny(const AnyTypeWithOutCheck & x)
  191.   { 
  192.    CheckSize<T,sizeof(T)<= sizeof(AnyData) >();
          ^
  193.    return *static_cast<const T*>(static_cast<const void*>(&x));
  194.   }

src/fflib/AnyType.hpp:193:2: 
  191.   { 
  192.    CheckSize<T,sizeof(T)<= sizeof(AnyData) >();
  193. >  return *static_cast<const T*>(static_cast<const void*>(&x));
  194.   }
  195.   

src/fflib/AnyType.hpp:194:1: return from a call to GetAny<FEbase<double,_v_fes3>_**>
  192.    CheckSize<T,sizeof(T)<= sizeof(AnyData) >();
  193.    return *static_cast<const T*>(static_cast<const void*>(&x));
  194. > }
  195.   
  196.    template<> inline const double& GetAny<double>(const AnyTypeWithOutCheck & x)

src/fflib/lgmesh3.cpp:1011:3: 
1009.     MeshPoint *mps=MeshPointStack(s), mp=*mps;   
1010.     FEbase<K,v_fes> ** pp=GetAny< FEbase<K,v_fes> **>((*ppfe)(s));
1011. >   FEbase<K,v_fes> & fe(**pp);
1012.     const  FESpace & Vh(*fe.newVh());
1013.    // KN<K> gg(Vh.MaximalNbOfDF()); 

src/fflib/lgmesh3.cpp:1012:3: 
1010.     FEbase<K,v_fes> ** pp=GetAny< FEbase<K,v_fes> **>((*ppfe)(s));
1011.     FEbase<K,v_fes> & fe(**pp);
1012. >   const  FESpace & Vh(*fe.newVh());
1013.    // KN<K> gg(Vh.MaximalNbOfDF()); 
1014.     

src/fflib/lgfem.hpp:384:3: start of procedure newVh
  382.       }
  383.       
  384.     FESpace * newVh() { 
           ^
  385.       throwassert(pVh  );
  386.       const pfes pp= *pVh;

src/fflib/lgfem.hpp:386:5: 
  384.     FESpace * newVh() { 
  385.       throwassert(pVh  );
  386. >     const pfes pp= *pVh;
  387.       // cout << pVh << " " << *pVh << endl;
  388.       return *pp;

src/fflib/lgfem.hpp:388:5: 
  386.       const pfes pp= *pVh;
  387.       // cout << pVh << " " << *pVh << endl;
  388. >     return *pp;
  389.     }  
  390.     

src/fflib/lgfem.hpp:211:3: start of procedure operator_Fem2D::GFESpace<Fem2D::Mesh3>_*
    209.     
    210.     
    211.     operator FESpace3 * ()  { 
             ^
    212.       throwassert( d==3);
    213.       if  ( !pVh || *ppTh !=  &pVh->Th )

src/fflib/lgfem.hpp:213:11: 
    211.     operator FESpace3 * ()  { 
    212.       throwassert( d==3);
    213. >     if  ( !pVh || *ppTh !=  &pVh->Th )
    214.         pVh=CountPointer<FESpace3>(update(),true);
    215.       return  pVh   ;} 

src/femlib/RefCounter.hpp:99:2: start of procedure operator!
      97.    bool operator==(const  CountPointer & n) const {return  n.c ==c;}
      98.    bool operator!=(const  CountPointer & n) const {return  n.c !=c;}
      99.    bool operator!() const { return !c;}
              ^
      100.    void operator=(const  CountPointer & n) {
      101.     if(*this != n) { destroyPtr(c); 

src/femlib/RefCounter.hpp:99:35: Condition is true
      97.    bool operator==(const  CountPointer & n) const {return  n.c ==c;}
      98.    bool operator!=(const  CountPointer & n) const {return  n.c !=c;}
      99.    bool operator!() const { return !c;}
                                               ^
      100.    void operator=(const  CountPointer & n) {
      101.     if(*this != n) { destroyPtr(c); 

src/femlib/RefCounter.hpp:99:34: 
      97.    bool operator==(const  CountPointer & n) const {return  n.c ==c;}
      98.    bool operator!=(const  CountPointer & n) const {return  n.c !=c;}
      99. >  bool operator!() const { return !c;}
      100.    void operator=(const  CountPointer & n) {
      101.     if(*this != n) { destroyPtr(c); 

src/femlib/RefCounter.hpp:99:27: 
      97.    bool operator==(const  CountPointer & n) const {return  n.c ==c;}
      98.    bool operator!=(const  CountPointer & n) const {return  n.c !=c;}
      99. >  bool operator!() const { return !c;}
      100.    void operator=(const  CountPointer & n) {
      101.     if(*this != n) { destroyPtr(c); 

src/femlib/RefCounter.hpp:99:37: return from a call to CountPointer<Fem2D::GFESpace<Fem2D::Mesh3>>_operator!
      97.    bool operator==(const  CountPointer & n) const {return  n.c ==c;}
      98.    bool operator!=(const  CountPointer & n) const {return  n.c !=c;}
      99.    bool operator!() const { return !c;}
                                                 ^
      100.    void operator=(const  CountPointer & n) {
      101.     if(*this != n) { destroyPtr(c); 

src/fflib/lgfem.hpp:213:11: Taking false branch
    211.     operator FESpace3 * ()  { 
    212.       throwassert( d==3);
    213.       if  ( !pVh || *ppTh !=  &pVh->Th )
                     ^
    214.         pVh=CountPointer<FESpace3>(update(),true);
    215.       return  pVh   ;} 

src/fflib/lgfem.hpp:213:19: 
    211.     operator FESpace3 * ()  { 
    212.       throwassert( d==3);
    213. >     if  ( !pVh || *ppTh !=  &pVh->Th )
    214.         pVh=CountPointer<FESpace3>(update(),true);
    215.       return  pVh   ;} 

src/femlib/RefCounter.hpp:96:3: start of procedure operator->
      94.    operator   T & () const  {return *c;}
      95.     T& operator*() const {return *c;}
      96.     T* operator->() const {return c;}
              ^
      97.    bool operator==(const  CountPointer & n) const {return  n.c ==c;}
      98.    bool operator!=(const  CountPointer & n) const {return  n.c !=c;}

src/femlib/RefCounter.hpp:96:26: 
      94.    operator   T & () const  {return *c;}
      95.     T& operator*() const {return *c;}
      96. >   T* operator->() const {return c;}
      97.    bool operator==(const  CountPointer & n) const {return  n.c ==c;}
      98.    bool operator!=(const  CountPointer & n) const {return  n.c !=c;}

src/femlib/RefCounter.hpp:96:35: return from a call to CountPointer<Fem2D::GFESpace<Fem2D::Mesh3>>_operator->
      94.    operator   T & () const  {return *c;}
      95.     T& operator*() const {return *c;}
      96.     T* operator->() const {return c;}
                                              ^
      97.    bool operator==(const  CountPointer & n) const {return  n.c ==c;}
      98.    bool operator!=(const  CountPointer & n) const {return  n.c !=c;}

src/fflib/lgfem.hpp:213:19: Taking true branch
    211.     operator FESpace3 * ()  { 
    212.       throwassert( d==3);
    213.       if  ( !pVh || *ppTh !=  &pVh->Th )
                             ^
    214.         pVh=CountPointer<FESpace3>(update(),true);
    215.       return  pVh   ;} 

src/fflib/lgfem.hpp:214:7: 
    212.       throwassert( d==3);
    213.       if  ( !pVh || *ppTh !=  &pVh->Th )
    214. >       pVh=CountPointer<FESpace3>(update(),true);
    215.       return  pVh   ;} 
    216.     FESpace3 * update() ;

src/fflib/lgfem.hpp:558:1: start of procedure update
      556.   
      557.   
      558. > inline FESpace3 * v_fes3::update() {     
      559.     assert(d==3);
      560.     if(!*ppTh) return 0;

src/fflib/lgfem.hpp:560:7: Taking false branch
      558.   inline FESpace3 * v_fes3::update() {     
      559.     assert(d==3);
      560.     if(!*ppTh) return 0;
                   ^
      561.     if (nbcperiodic ) {
      562.       assert(periodic);

src/fflib/lgfem.hpp:561:7: Taking false branch
      559.     assert(d==3);
      560.     if(!*ppTh) return 0;
      561.     if (nbcperiodic ) {
                   ^
      562.       assert(periodic);
      563.       //const Mesh3 &Th(**ppTh);

src/fflib/lgfem.hpp:571:8: 
      569.         }
      570.        else 
      571. >        return  buildupdate();
      572.   }
      573.   

src/fflib/lgfem.hpp:228:3: start of procedure buildupdate
        226.     bool buildperiodic(Stack stack, KN<int> & ndfe)  ;
        227.     virtual  FESpace3 * buildupdate( KN<int> & ndfe) {  return 0;}
        228.     virtual  FESpace3 * buildupdate() {return 0;};
                 ^
        229.     
        230.   };  

src/fflib/lgfem.hpp:228:38: 
        226.     bool buildperiodic(Stack stack, KN<int> & ndfe)  ;
        227.     virtual  FESpace3 * buildupdate( KN<int> & ndfe) {  return 0;}
        228. >   virtual  FESpace3 * buildupdate() {return 0;};
        229.     
        230.   };  

src/fflib/lgfem.hpp:228:47: return from a call to v_fes3_buildupdate
        226.     bool buildperiodic(Stack stack, KN<int> & ndfe)  ;
        227.     virtual  FESpace3 * buildupdate( KN<int> & ndfe) {  return 0;}
        228.     virtual  FESpace3 * buildupdate() {return 0;};
                                                             ^
        229.     
        230.   };  

src/fflib/lgfem.hpp:572:1: return from a call to v_fes3_update
      570.        else 
      571.          return  buildupdate();
      572. > }
      573.   
      574.   template<class A,class B>  A Build(B b) {  return A(b);}

src/femlib/RefCounter.hpp:87:2: start of procedure CountPointer
      85.    public: 
      86.    CountPointer() : c(0) {}
      87.    CountPointer( T * a,bool mmaster=false) :c(a) { if(!mmaster) add(c);} 
             ^
      88.    CountPointer(  T & a) :c(&a) { add(c);}
      89.    CountPointer(const CountPointer & a) :c(a.c) { add(c);}

src/femlib/RefCounter.hpp:87:67: 
      85.    public: 
      86.    CountPointer() : c(0) {}
      87. >  CountPointer( T * a,bool mmaster=false) :c(a) { if(!mmaster) add(c);} 
      88.    CountPointer(  T & a) :c(&a) { add(c);}
      89.    CountPointer(const CountPointer & a) :c(a.c) { add(c);}

src/femlib/RefCounter.hpp:45:7: start of procedure baseCountPointer
        43.   // ruse pour utiliser le prive c RefCounter de 
        44.   //  pas de syntaxe pour des friends template 
        45.   class baseCountPointer { protected:
                    ^
        46.    void  add(const  RefCounter * c)  const; 
        47.    void  destroyPtr(const RefCounter *  c)  const;

src/femlib/RefCounter.hpp:45:7: return from a call to baseCountPointer_baseCountPointer
        43.   // ruse pour utiliser le prive c RefCounter de 
        44.   //  pas de syntaxe pour des friends template 
        45.   class baseCountPointer { protected:
                    ^
        46.    void  add(const  RefCounter * c)  const; 
        47.    void  destroyPtr(const RefCounter *  c)  const;

src/femlib/RefCounter.hpp:87:43: 
      85.    public: 
      86.    CountPointer() : c(0) {}
      87. >  CountPointer( T * a,bool mmaster=false) :c(a) { if(!mmaster) add(c);} 
      88.    CountPointer(  T & a) :c(&a) { add(c);}
      89.    CountPointer(const CountPointer & a) :c(a.c) { add(c);}

src/femlib/RefCounter.hpp:87:54: Taking false branch
      85.    public: 
      86.    CountPointer() : c(0) {}
      87.    CountPointer( T * a,bool mmaster=false) :c(a) { if(!mmaster) add(c);} 
                                                                 ^
      88.    CountPointer(  T & a) :c(&a) { add(c);}
      89.    CountPointer(const CountPointer & a) :c(a.c) { add(c);}

src/femlib/RefCounter.hpp:87:50: 
      85.    public: 
      86.    CountPointer() : c(0) {}
      87. >  CountPointer( T * a,bool mmaster=false) :c(a) { if(!mmaster) add(c);} 
      88.    CountPointer(  T & a) :c(&a) { add(c);}
      89.    CountPointer(const CountPointer & a) :c(a.c) { add(c);}

src/femlib/RefCounter.hpp:87:70: return from a call to CountPointer<Fem2D::GFESpace<Fem2D::Mesh3>>_CountPointer
      85.    public: 
      86.    CountPointer() : c(0) {}
      87.    CountPointer( T * a,bool mmaster=false) :c(a) { if(!mmaster) add(c);} 
                                                                                 ^
      88.    CountPointer(  T & a) :c(&a) { add(c);}
      89.    CountPointer(const CountPointer & a) :c(a.c) { add(c);}

src/femlib/RefCounter.hpp:100:2: start of procedure operator=
      98.    bool operator!=(const  CountPointer & n) const {return  n.c !=c;}
      99.    bool operator!() const { return !c;}
      100.    void operator=(const  CountPointer & n) {
              ^
      101.     if(*this != n) { destroyPtr(c); 
      102.                   c=n.c;

src/femlib/RefCounter.hpp:101:6: 
      99.    bool operator!() const { return !c;}
      100.    void operator=(const  CountPointer & n) {
      101. >   if(*this != n) { destroyPtr(c); 
      102.                   c=n.c;
      103.                   add(c);               

src/femlib/RefCounter.hpp:98:2: start of procedure operator!=
        96.     T* operator->() const {return c;}
        97.    bool operator==(const  CountPointer & n) const {return  n.c ==c;}
        98.    bool operator!=(const  CountPointer & n) const {return  n.c !=c;}
                ^
        99.    bool operator!() const { return !c;}
        100.    void operator=(const  CountPointer & n) {

src/femlib/RefCounter.hpp:98:58: Condition is true
        96.     T* operator->() const {return c;}
        97.    bool operator==(const  CountPointer & n) const {return  n.c ==c;}
        98.    bool operator!=(const  CountPointer & n) const {return  n.c !=c;}
                                                                        ^
        99.    bool operator!() const { return !c;}
        100.    void operator=(const  CountPointer & n) {

src/femlib/RefCounter.hpp:98:50: 
        96.     T* operator->() const {return c;}
        97.    bool operator==(const  CountPointer & n) const {return  n.c ==c;}
        98. >  bool operator!=(const  CountPointer & n) const {return  n.c !=c;}
        99.    bool operator!() const { return !c;}
        100.    void operator=(const  CountPointer & n) {

src/femlib/RefCounter.hpp:98:66: return from a call to CountPointer<Fem2D::GFESpace<Fem2D::Mesh3>>_operator!=
        96.     T* operator->() const {return c;}
        97.    bool operator==(const  CountPointer & n) const {return  n.c ==c;}
        98.    bool operator!=(const  CountPointer & n) const {return  n.c !=c;}
                                                                                ^
        99.    bool operator!() const { return !c;}
        100.    void operator=(const  CountPointer & n) {

src/femlib/RefCounter.hpp:101:6: Taking true branch
      99.    bool operator!() const { return !c;}
      100.    void operator=(const  CountPointer & n) {
      101.     if(*this != n) { destroyPtr(c); 
                  ^
      102.                   c=n.c;
      103.                   add(c);               

src/femlib/RefCounter.hpp:101:20: 
      99.    bool operator!() const { return !c;}
      100.    void operator=(const  CountPointer & n) {
      101. >   if(*this != n) { destroyPtr(c); 
      102.                   c=n.c;
      103.                   add(c);               

src/femlib/RefCounter.hpp:79:1: start of procedure destroyPtr
        77.   inline void baseCountPointer::add(const RefCounter * c)  const 
        78.      { if (c) c->count++;}    
        79. > inline void baseCountPointer::destroyPtr(const RefCounter *   c)  const 
        80.      { if (c) c->destroy();}    
        81.    

src/femlib/RefCounter.hpp:80:10: Taking true branch
        78.      { if (c) c->count++;}    
        79.   inline void baseCountPointer::destroyPtr(const RefCounter *   c)  const 
        80.      { if (c) c->destroy();}    
                       ^
        81.    
        82.   template<class T>

src/femlib/RefCounter.hpp:80:13: 
        78.      { if (c) c->count++;}    
        79.   inline void baseCountPointer::destroyPtr(const RefCounter *   c)  const 
        80. >    { if (c) c->destroy();}    
        81.    
        82.   template<class T>

src/femlib/RefCounter.hpp:58:3: start of procedure destroy
          56.     RefCounter() : count(0) {}
          57.     public:
          58.     int destroy() const { 
                  ^
          59.         if(this!=tnull) {throwassert(count>=0);
          60.           if ( count--==0) {

src/femlib/RefCounter.hpp:59:10: Taking true branch
          57.     public:
          58.     int destroy() const { 
          59.         if(this!=tnull) {throwassert(count>=0);
                         ^
          60.           if ( count--==0) {
          61.   	            SHOWVERB( cout << "True  destruction of " << this <<  endl);

src/femlib/RefCounter.hpp:60:14: Taking false branch
          58.     int destroy() const { 
          59.         if(this!=tnull) {throwassert(count>=0);
          60.           if ( count--==0) {
                             ^
          61.   	            SHOWVERB( cout << "True  destruction of " << this <<  endl);
          62.                delete this;

src/femlib/RefCounter.hpp:65:15: 
          63.                return true;} 
          64.           else{ SHOWVERB(cout << " no destruction count=" << count+1 << " " << this <<  endl);
          65. >               return false;}}
          66.      else return false;} 
          67.      void increment() const {count++;SHOWVERB( cout << "increment  of " << this << " "<< count <<  endl);}

src/femlib/RefCounter.hpp:66:22: return from a call to RefCounter_destroy
          64.           else{ SHOWVERB(cout << " no destruction count=" << count+1 << " " << this <<  endl);
          65.                 return false;}}
          66.      else return false;} 
                                     ^
          67.      void increment() const {count++;SHOWVERB( cout << "increment  of " << this << " "<< count <<  endl);}
          68.       void decrement() const {destroy();}// count--;SHOWVERB( cout << "decrement  of " << this << " "<< count <<  endl);ffassert(count>=0);}

src/femlib/RefCounter.hpp:80:6: 
        78.      { if (c) c->count++;}    
        79.   inline void baseCountPointer::destroyPtr(const RefCounter *   c)  const 
        80. >    { if (c) c->destroy();}    
        81.    
        82.   template<class T>

src/femlib/RefCounter.hpp:80:26: return from a call to baseCountPointer_destroyPtr
        78.      { if (c) c->count++;}    
        79.   inline void baseCountPointer::destroyPtr(const RefCounter *   c)  const 
        80.      { if (c) c->destroy();}    
                                       ^
        81.    
        82.   template<class T>

src/femlib/RefCounter.hpp:102:17: 
      100.    void operator=(const  CountPointer & n) {
      101.     if(*this != n) { destroyPtr(c); 
      102. >                 c=n.c;
      103.                   add(c);               
      104.                 }}

src/femlib/RefCounter.hpp:103:17: 
      101.     if(*this != n) { destroyPtr(c); 
      102.                   c=n.c;
      103. >                 add(c);               
      104.                 }}
      105.                              

src/femlib/RefCounter.hpp:77:1: start of procedure add
        75.   };
        76.   
        77. > inline void baseCountPointer::add(const RefCounter * c)  const 
        78.      { if (c) c->count++;}    
        79.   inline void baseCountPointer::destroyPtr(const RefCounter *   c)  const 

src/femlib/RefCounter.hpp:78:10: Taking false branch
        76.   
        77.   inline void baseCountPointer::add(const RefCounter * c)  const 
        78.      { if (c) c->count++;}    
                       ^
        79.   inline void baseCountPointer::destroyPtr(const RefCounter *   c)  const 
        80.      { if (c) c->destroy();}    

src/femlib/RefCounter.hpp:78:6: 
        76.   
        77.   inline void baseCountPointer::add(const RefCounter * c)  const 
        78. >    { if (c) c->count++;}    
        79.   inline void baseCountPointer::destroyPtr(const RefCounter *   c)  const 
        80.      { if (c) c->destroy();}    

src/femlib/RefCounter.hpp:78:24: return from a call to baseCountPointer_add
        76.   
        77.   inline void baseCountPointer::add(const RefCounter * c)  const 
        78.      { if (c) c->count++;}    
                                     ^
        79.   inline void baseCountPointer::destroyPtr(const RefCounter *   c)  const 
        80.      { if (c) c->destroy();}    

src/femlib/RefCounter.hpp:101:3: 
      99.    bool operator!() const { return !c;}
      100.    void operator=(const  CountPointer & n) {
      101. >   if(*this != n) { destroyPtr(c); 
      102.                   c=n.c;
      103.                   add(c);               

src/femlib/RefCounter.hpp:104:16: return from a call to CountPointer<Fem2D::GFESpace<Fem2D::Mesh3>>_operator=
      102.                   c=n.c;
      103.                   add(c);               
      104.                 }}
                            ^
      105.                              
      106.    void operator=( T * t) {

src/fflib/lgfem.hpp:215:5: 
    213.       if  ( !pVh || *ppTh !=  &pVh->Th )
    214.         pVh=CountPointer<FESpace3>(update(),true);
    215. >     return  pVh   ;} 
    216.     FESpace3 * update() ;
    217.     

src/femlib/RefCounter.hpp:93:2: start of procedure operator_Fem2D::GFESpace<Fem2D::Mesh3>_*
      91.    //void destroy() const { destroyPtr(c);}
      92.    void destroy()  { destroyPtr(c);c=0;}
      93.    operator  T * ()   const { return c;}
             ^
      94.    operator   T & () const  {return *c;}
      95.     T& operator*() const {return *c;}

src/femlib/RefCounter.hpp:93:29: 
      91.    //void destroy() const { destroyPtr(c);}
      92.    void destroy()  { destroyPtr(c);c=0;}
      93. >  operator  T * ()   const { return c;}
      94.    operator   T & () const  {return *c;}
      95.     T& operator*() const {return *c;}

src/femlib/RefCounter.hpp:93:38: return from a call to CountPointer<Fem2D::GFESpace<Fem2D::Mesh3>>_operator_Fem2D::GFESpace<Fem2D::Mesh3>_*
      91.    //void destroy() const { destroyPtr(c);}
      92.    void destroy()  { destroyPtr(c);c=0;}
      93.    operator  T * ()   const { return c;}
                                                 ^
      94.    operator   T & () const  {return *c;}
      95.     T& operator*() const {return *c;}

src/fflib/lgfem.hpp:215:20: return from a call to v_fes3_operator_Fem2D::GFESpace<Fem2D::Mesh3>_*
    213.       if  ( !pVh || *ppTh !=  &pVh->Th )
    214.         pVh=CountPointer<FESpace3>(update(),true);
    215.       return  pVh   ;} 
                              ^
    216.     FESpace3 * update() ;
    217.     

src/fflib/lgfem.hpp:389:3: return from a call to FEbase<double,v_fes3>_newVh
  387.       // cout << pVh << " " << *pVh << endl;
  388.       return *pp;
  389.     }  
           ^
  390.     
  391.     operator  FESpace &() { throwassert(Vh); return *Vh;}

src/fflib/lgmesh3.cpp:1016:3: 
1014.     
1015.     
1016. >   const  Mesh & Th(Vh.Th);
1017.     const int dim=Vh.N;
1018.     K ** copt=0;