Changeset 2cdc84 in git

Timestamp:

Aug 31, 2012, 11:33:33 AM (12 years ago)

Author:

Alexander Dreyer <alexander.dreyer@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

9373f05657970e6e7e18aac67a18d1245fb6bb4e

Parents:

b8346741b9c72d735f018ce57120e6782a5d4d2d

git-author:

Alexander Dreyer <alexander.dreyer@itwm.fraunhofer.de>2012-08-31 11:33:33+02:00

git-committer:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2012-09-05 15:52:17+02:00

Message:

fix: better distingish between LeftvDeep and LeftvShallow

File:

• Singular/countedref.cc (modified) (12 diffs)

Singular/countedref.cc

@@ -12 +12 @@
 **/
 //*****************************************************************************
-
 
 
@@ -143 +142 @@
 
 public:
-  static idhdl idify(leftv head, idhdl* root) {
+  static leftv idify(leftv head, idhdl* root) {
+    idhdl handle = newid(head, root);
+    leftv res = (leftv)omAlloc0(sizeof(*res));
+    res->data =(void*) handle;
+    res->rtyp = IDHDL;
+    return res;
+  }
+
+  static idhdl newid(leftv head, idhdl* root) {
+
     static unsigned int counter = 0;
     char* name = (char*) omAlloc0(512);
@@ -175 +183 @@
 inline void CountedRefPtr_kill(ring r) { rKill(r); }
 
-
-class LeftvShallow {
+class LeftvHelper {
+public:
+  template <class Type>
+  static Type* cpy(Type* result, Type* data)  {
+    return (Type*)memcpy(result, data, sizeof(Type));
+  }
+  template <class Type>
+  static Type* cpy(Type* data)  {
+    return cpy((Type*)omAlloc0(sizeof(Type)), data);
+  }
+  template <class Type>
+  static Type* recursivecpy(Type* data)  {
+    if (data == NULL) return data;
+    Type* result = cpy(data);
+    result->next = recursivecpy(data->next);
+    return result;
+  }
+  template <class Type>
+  static Type* shallowcpy(Type* result, Type* data)  {
+    cpy(result, data)->e = recursivecpy(data->e);
+    return result;
+  }
+  template <class Type>
+  static Type* shallowcpy(Type* data)  {
+    return shallowcpy((Type*) omAlloc0(sizeof(Type)), data);
+  }
+  template <class Type>
+  static void recursivekill(Type* current) {
+    if(current == NULL) return;
+    recursivekill(current->next);
+    omFree(current);
+  }
+  static leftv allocate() { return (leftv)omAlloc0(sizeof(sleftv)); }
+
+};
+
+class LeftvShallow:
+  public LeftvHelper {
   typedef LeftvShallow self;
   
 public:
   LeftvShallow(): m_data(allocate()) { }
-  LeftvShallow(leftv data): 
-    m_data(allocate()) { init(data); }
-
-  LeftvShallow(const self& rhs):
-    m_data(allocate()) {
-    copy(m_data, rhs.m_data);
-  }
+  LeftvShallow(leftv data): m_data(shallowcpy(data)) { }
+  LeftvShallow(const self& rhs):  m_data(shallowcpy(rhs.m_data)) { }
 
   ~LeftvShallow() {  
-    kill(m_data->e);
+    recursivekill(m_data->e);
     omFree(m_data);
   }
   self& operator=(leftv rhs) {
-    kill(m_data->e);
-    return init(rhs);
+    recursivekill(m_data->e);
+    shallowcpy(m_data, rhs);
+    return *this;
   }
 
   self& operator=(const self& rhs) { return (*this) = rhs.m_data; }
-
-
-
 
   /// Access to object
@@ -208 +245 @@
 
 protected:
-  static leftv allocate() { return (leftv)omAlloc0(sizeof(sleftv)); }
-
-  self& init(leftv data) {
-    memcpy(m_data, data, sizeof(sleftv));
-    data->e = NULL;
-    m_data->next = NULL;
-    return *this;
-  }
-
-  static void copy(leftv result, leftv data)  {
-    memcpy(result, data, sizeof(sleftv));
-    copy(result->e, data->e);
-  }
-
- static void copy(Subexpr& current, Subexpr rhs)  {
-    if (rhs == NULL) return;
-    current = (Subexpr)memcpy(omAlloc0Bin(sSubexpr_bin), rhs, sizeof(*rhs));
-    copy(current->next, rhs->next);
-  }
-
-  static void kill(Subexpr current) {
-    if(current == NULL) return;
-    kill(current->next);
-    omFree(current);
-  }
-
-protected:
   leftv m_data;
 };
 
 
-class LeftvDeep:
-  protected LeftvShallow {
+class LeftvDeep: public LeftvHelper {
   typedef LeftvDeep self;
-  typedef LeftvShallow base;
-
+
+  /// @name Do not permit copying
+  //@{
   self& operator=(const self&);
-public:
-  LeftvDeep(): base() {}
-  LeftvDeep(leftv data): base(data) {  if(!isid()) m_data->data=data->CopyD(); }
-
-  LeftvDeep(leftv data,int,int): base() {  m_data->Copy(data);  }
-
-  LeftvDeep(const self& rhs): base(rhs) {
-    if(m_data->rtyp != IDHDL)
-      m_data->Copy(rhs.m_data);
-  }
+  LeftvDeep(const self&);
+  //@}
+
+public:
+  LeftvDeep(): m_data(allocate()) {}
+  LeftvDeep(leftv data): m_data(cpy(data)) { 
+    data->e = NULL;   // occupy subexpression 
+    if(!isid()) m_data->data=data->CopyD(); 
+  }
+
+  LeftvDeep(leftv data,int,int): m_data(allocate()) {  m_data->Copy(data);  }
 
   ~LeftvDeep() { m_data->CleanUp(); }
-  operator const base&() { return static_cast<const base&>(*this); }
+  operator LeftvShallow() { return m_data;}
 
   bool like(const self& rhs) const { return m_data->data == rhs.m_data->data; }
@@ -289 +300 @@
     result->CleanUp();
 
-    copy(result, m_data);
+    shallowcpy(result, m_data);
     result->next = next;
     return FALSE;
   }
+
+  BOOLEAN retrieve(leftv res) {
+    if (res->data == m_data->data)  {
+      if(m_data->e != res->e) recursivekill(m_data->e);
+      cpy(m_data, res);
+      res->Init();
+      return TRUE;
+    }
+    return FALSE;
+  }
+
+
 
   BOOLEAN isid() const { return m_data->rtyp==IDHDL;}
   BOOLEAN ringed() { return m_data->RingDependend(); }
   BOOLEAN unassigned() const { return m_data->Typ()==0; }
+
+  leftv idify(idhdl* root) {
+    leftv res = (isid()? m_data: CountedRefEnv::idify(m_data, root));
+    ++(((idhdl)res->data)->ref);
+    return res;
+  }
+
+
+  void clearid(idhdl* root) {
+    assume(isid());
+    if (--((idhdl)m_data->data)->ref <= 0)  // clear only if we own
+      CountedRefEnv::clearid((idhdl)m_data->data, root);
+  }
+
+private:
+  leftv m_data;
 };
 
@@ -311 +350 @@
   /// Subscripted object
   CountedRefData(leftv wrapped, CountedRefPtr<self*> back):
-    base(), m_data(wrapped), m_ring(back->m_ring), m_back(back) {
-
-    assume(wrapped->rtyp == IDHDL);
-    ++((idhdl)m_data.access()->data)->ref;
-  }
-
-  /// Disallow assignment
+    base(), m_data(wrapped), m_ring(back->m_ring), m_back(back) {  }
+
+  /// Disallow copying to avoid inconsistence
+  //@{
   self& operator=(const self&);
+  CountedRefData(const self&);
+  //@}
 public:
   /// Construct shared memory empty Singular object
@@ -331 +369 @@
     base(), m_data(data, global,0), m_ring(parent(data)), m_back() { }
 
-  /// Construct deep copy
-  CountedRefData(const self& rhs):
-    base(), m_data(rhs.m_data), m_ring(rhs.m_ring), m_back() { }
-  
   /// Destruct
-  ~CountedRefData() { 
-    if (m_back && (--((idhdl)m_data.access()->data)->ref <= 0))  // clear only if we own
-      CountedRefEnv::clearid((idhdl)m_data.access()->data, root());     
-  }
-
+  ~CountedRefData() {  if (m_back)  m_data.clearid(root()); }
+
+  /// Generate 
   CountedRefPtr<self*> subscripted() {
-    if (m_back)
-      return new self(operator*().operator->(), m_back);
-
-    return new self(init(CountedRefEnv::idify(m_data.access(), root())), this);
+    return new self(m_data.idify(root()), 
+                    m_back? m_back: CountedRefPtr<self*>(this));
   }
 
@@ -361 +391 @@
   LeftvShallow operator*() const { return (broken()? LeftvShallow(): (const LeftvShallow&)m_data); }
 
-
+  /// Determine active ring when ring dependency changes
   BOOLEAN rering() {
     if (m_ring ^ m_data.ringed()) m_ring = (m_ring? NULL: currRing);
@@ -386 +416 @@
   }
 
+  /// Reassign actual object
   BOOLEAN assign(leftv result, leftv arg) {
     if (!m_data.isid()) {
@@ -393 +424 @@
     return get(result) || iiAssign(result, arg) || rering();
   }
-
-  BOOLEAN retrieve(leftv res) {
-    if (res->data == m_data.access()->data)  {
-      memcpy(m_data.access(), res, sizeof(sleftv));
-      res->Init();
-      return TRUE;
-    }
-    return FALSE;
-  }
-
+  /// Recover additional information (e.g. subexpression) from likewise object
+  BOOLEAN retrieve(leftv res) { return m_data.retrieve(res); }
+
+  /// Check whether data is all-zero 
   BOOLEAN unassigned() const { return m_data.unassigned(); }
+
 private:
-
   /// Raise error message and return @c TRUE
   BOOLEAN complain(const char* text) const  {
@@ -412 +437 @@
   }
 
-
-
   /// Store ring for ring-dependent objects
   static ring parent(leftv rhs) { 
     return (rhs->RingDependend()? currRing: NULL); 
-  }
-
- static leftv init(idhdl handle) {
-    assume(handle);
-    leftv res = (leftv)omAlloc0(sizeof(*res));
-    res->data =(void*) handle;
-    res->rtyp = IDHDL;
-    return res;
   }
 
@@ -574 +589 @@
     return (arg->next != NULL) && resolve(arg->next);
   }
-  //  int Typ() const {return m_data->Typ(); }
+
 protected:
   /// Construct integer value