Changeset b83467 in git for Singular/countedref.cc

Timestamp:

Aug 31, 2012, 12:50:14 AM (12 years ago)

Author:

Alexander Dreyer <alexander.dreyer@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

2cdc84e758384927d435934f4ed945fbbdf5cedf

Parents:

a5e907a16ec70a7bfd4c506efb3f1a7b48693387

git-author:

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

git-committer:

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

Message:

Nested subexpressions via shared

File:

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

Singular/countedref.cc

@@ -202 +202 @@
 
 
-  BOOLEAN get(leftv result) {
-    leftv next = result->next;
-    result->next = NULL;
-    result->CleanUp();
-
-    copy(result, m_data);
-    result->next = next;
-    return FALSE;
-  }
 
   /// Access to object
@@ -249 +240 @@
 
 class LeftvDeep:
-  public LeftvShallow {
+  protected LeftvShallow {
   typedef LeftvDeep self;
   typedef LeftvShallow base;
 
+  self& operator=(const self&);
 public:
   LeftvDeep(): base() {}
-  LeftvDeep(leftv data): base(data) {
-    if(m_data->rtyp != IDHDL) {
-      m_data->data = data->CopyD();
-    }
-  }
+  LeftvDeep(leftv data): base(data) {  if(!isid()) m_data->data=data->CopyD(); }
 
   LeftvDeep(leftv data,int,int): base() {  m_data->Copy(data);  }
@@ -269 +257 @@
 
   ~LeftvDeep() { m_data->CleanUp(); }
-
-  self& operator=(const self& rhs) { return operator=(rhs.m_data); }
+  operator const base&() { return static_cast<const base&>(*this); }
+
+  bool like(const self& rhs) const { return m_data->data == rhs.m_data->data; }
+
   self& operator=(leftv rhs) {
-    m_data->e = rhs->e;
-    rhs->e=NULL;
-    if(m_data->rtyp == IDHDL) {
+    if(isid()) {
+      m_data->e = rhs->e;
+      rhs->e = NULL;
       IDTYP((idhdl)m_data->data) =  rhs->Typ();
       IDDATA((idhdl)m_data->data) = (char*) rhs->CopyD();
@@ -280 +270 @@
     else {
       m_data->CleanUp();
-      m_data->rtyp = rhs->Typ();
-      m_data->data =  rhs->CopyD();
+      m_data->Copy(rhs);
     }
-
     return *this;
   }
-  int Typ() const {return m_data->Typ(); }
-   leftv access() { return m_data; }
+
+  leftv access() { return m_data; }
+
+
+  /// Check a given context for our identifier
+  BOOLEAN brokenid(idhdl context) const {
+    assume(isid());
+    return (context == NULL) || 
+      ((context != (idhdl) m_data->data) && brokenid(IDNEXT(context)));
+  }
+  BOOLEAN get(leftv result) {
+    leftv next = result->next;
+    result->next = NULL;
+    result->CleanUp();
+
+    copy(result, m_data);
+    result->next = next;
+    return FALSE;
+  }
+
+  BOOLEAN isid() const { return m_data->rtyp==IDHDL;}
+  BOOLEAN ringed() { return m_data->RingDependend(); }
+  BOOLEAN unassigned() const { return m_data->Typ()==0; }
 };
 
@@ -301 +310 @@
 
   /// Subscripted object
-  CountedRefData(idhdl handle, CountedRefPtr<self*> back):
-    base(), m_data(init(handle)), m_ring(back->Ring()), m_back(back) { }
-
+  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
+  self& operator=(const self&);
 public:
   /// Construct shared memory empty Singular object
@@ -322 +337 @@
   /// Destruct
   ~CountedRefData() { 
-    if (m_back) CountedRefEnv::clearid((idhdl)m_data.access()->data, root());
-   }
+    if (m_back && (--((idhdl)m_data.access()->data)->ref <= 0))  // clear only if we own
+      CountedRefEnv::clearid((idhdl)m_data.access()->data, root());     
+  }
 
   CountedRefPtr<self*> subscripted() {
-    return new self(CountedRefEnv::idify(m_data.access(), root()), this);
-  }
-
-  /// Replace data
-  self& operator=(const self& rhs) {
-    m_data = rhs.m_data;
-    m_ring = rhs.m_ring;
+    if (m_back)
+      return new self(operator*().operator->(), m_back);
+
+    return new self(init(CountedRefEnv::idify(m_data.access(), root())), this);
+  }
+
+  /// Replace with other Singular data
+  self& operator=(leftv rhs) {
+    m_data = rhs;
+    m_ring = parent(rhs);
     return *this;
-  }
-
-  /// Replace with other Singular data
-  void set(leftv rhs) {
-    if (m_data->rtyp==IDHDL)
-      m_data = rhs;
-   else
-     m_data->Copy(rhs);
-
-    m_ring = parent(rhs);
   }
 
@@ -350 +359 @@
 
   /// Extract (shallow) copy of stored data
-  LeftvShallow operator*() const { return (broken()? LeftvShallow(): LeftvShallow(m_data)); }
+  LeftvShallow operator*() const { return (broken()? LeftvShallow(): (const LeftvShallow&)m_data); }
 
 
   BOOLEAN rering() {
-    if (m_ring ^ m_data->RingDependend()) m_ring = (m_ring? NULL: currRing);
+    if (m_ring ^ m_data.ringed()) m_ring = (m_ring? NULL: currRing);
     return (m_back && m_back->rering());
   }
@@ -367 +376 @@
         return complain("Referenced identifier not from current ring");    
 
-      return (m_data->rtyp == IDHDL)  && brokenid(currRing->idroot) &&
+      return m_data.isid()  && m_data.brokenid(currRing->idroot) &&
         complain("Referenced identifier not available in ring anymore");  
     }
-
-   if (m_data->rtyp != IDHDL) return FALSE;
-   return brokenid(IDROOT) &&
-     ((currPack == basePack) || brokenid(basePack->idroot)) &&
+    
+    if (!m_data.isid()) return FALSE;
+    return  m_data.brokenid(IDROOT) &&
+     ((currPack == basePack) ||  m_data.brokenid(basePack->idroot)) &&
      complain("Referenced identifier not available in current context");
   }
 
   BOOLEAN assign(leftv result, leftv arg) {
-    if (m_data->rtyp!=IDHDL) {
-      set(arg);
+    if (!m_data.isid()) {
+      (*this) = arg;
       return FALSE;
     }
     return get(result) || iiAssign(result, arg) || rering();
-  }
-
-  /// @note If we have a callback, our identifier was temporary, so remove it
-  void clear() {  
-    if (m_back) CountedRefEnv::clearid((idhdl)m_data.access()->data, root());
   }
 
@@ -399 +403 @@
   }
 
-  CountedRefPtr<ring, true> Ring() { return m_ring; }
-  int Typ() const {return m_data->Typ(); }
+  BOOLEAN unassigned() const { return m_data.unassigned(); }
 private:
 
@@ -409 +412 @@
   }
 
-  /// Check a given context for our identifier
-  BOOLEAN brokenid(idhdl context) const {
-    return (context == NULL) || 
-      ((context != (idhdl) m_data->data) && brokenid(IDNEXT(context)));
-  }
+
 
   /// Store ring for ring-dependent objects
@@ -439 +438 @@
 };
 
+/// Supporting smart pointer @c CountedRefPtr
+inline void CountedRefPtr_kill(CountedRefData* data) { delete data; }
+
+
 /// blackbox support - initialization
 /// @note deals as marker for compatible references, too.
@@ -446 +449 @@
 }
 
-
-
-inline void CountedRefPtr_kill(CountedRefData* data) { delete data; }
 
 class CountedRef {
@@ -469 +469 @@
 
   /// Construct new reference from Singular data  
-  CountedRef(leftv arg):  m_data(new data_type(arg)) { }
+  explicit CountedRef(leftv arg):  m_data(new data_type(arg)) { }
 
 protected:
@@ -485 +485 @@
   }
 
-  /// Replace data that reference is pointing to
-  self& operator=(leftv rhs) {
-    m_data->set(rhs);
-    return *this;
-  }
-
   BOOLEAN assign(leftv result, leftv arg) { 
     return m_data->assign(result,arg);
   }
   BOOLEAN rering() { return m_data->rering(); }
+
   /// Extract (shallow) copy of stored data
   LeftvShallow operator*() { return m_data->operator*(); }
@@ -560 +555 @@
   /// Check whther argument is not defined yet
   BOOLEAN undefined(leftv res) { return construct(res, operator*()->Typ() == NONE); }
-
+  BOOLEAN unassigned() const { return  m_data->unassigned(); }
   /// Recover the actual object from raw Singular data
   static self cast(void* data) {
@@ -579 +574 @@
     return (arg->next != NULL) && resolve(arg->next);
   }
-  int Typ() const {return m_data->Typ(); }
+  //  int Typ() const {return m_data->Typ(); }
 protected:
   /// Construct integer value
@@ -708 +703 @@
 public:
   CountedRefShared():  base(new data_type) { }
-  CountedRefShared(leftv arg):  base(new data_type(arg, FALSE,0)) { }
+  explicit CountedRefShared(leftv arg):  base(new data_type(arg, FALSE,0)) { }
 
   /// Construct copy
@@ -719 +714 @@
   }
 
-  /// Replace data that reference is pointing to
-  self& operator=(leftv rhs) {
-    return static_cast<self&>(base::operator=(rhs));
-  }
-
   static self cast(leftv arg) { return base::cast(arg); }
   static self cast(void* arg) { return base::cast(arg); }
 
-  self subscripted() {
-    return self(m_data->subscripted());//new CountedRefDataIndexed(m_data->idify(), m_data);
-  }
+  /// Temporarily wrap with identifier for '[' and '.' operation
+  self subscripted() { return self(m_data->subscripted()); }
 
   BOOLEAN retrieve(leftv res, int typ) { 
@@ -749 +738 @@
 
     int typ = head->Typ();
-    return indexed.dereference(head) || CountedRef::resolve(arg) || 
+    return indexed.dereference(head) || CountedRefShared::resolve(arg) || 
       iiExprArith2(res, head, op, arg) || indexed.retrieve(res, typ);
   }
@@ -793 +782 @@
 {
   /// Case: replace assignment behind reference
-  if ((result->Data() != NULL)  && (CountedRefShared::cast(result).Typ() !=0 )) {
+  if ((result->Data() != NULL)  && !CountedRefShared::cast(result).unassigned()) {
     if (CountedRefShared::resolve(arg)) return TRUE;
     return CountedRefShared::cast(result).assign(result, arg);
@@ -805 +794 @@
     return CountedRefShared::cast(arg).outcast(result);
   }  
-  if(CountedRefShared::cast(result).Typ() == 0) {
+  if(CountedRefShared::cast(result).unassigned()) {
    // CountedRefShared::cast(result) = arg;
    return CountedRefShared::cast(result).assign(result, arg);