Changeset babfe48 in git

Timestamp:

Aug 22, 2012, 1:43:54 PM (11 years ago)

Author:

Alexander Dreyer <alexander.dreyer@…>

Branches:

(u'spielwiese', 'e7cc1ebecb61be8b9ca6c18016352af89940b21a')

Children:

d8f7a6c10289bac4ed97867b659faac3f58a532d

Parents:

180efc06f46eb5c71b54411dc6be57f125ad2ca0

git-author:

Alexander Dreyer <alexander.dreyer@itwm.fraunhofer.de>2012-08-22 13:43:54+02:00

git-committer:

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

Message:

Handling noninitialized and shared(ll[i])=rhs

add: replace operation for simple access of list elements

File:

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

Singular/countedref.cc

@@ -33 +33 @@
 
 
+template <class PtrType, bool NeverNull = false, class CountType = short>
+class CountedRefPtr {
+  typedef CountedRefPtr self;
+
+public:
+  typedef PtrType ptr_type;
+  typedef CountType count_type;
+
+  CountedRefPtr(ptr_type ptr): m_ptr(ptr) { reclaim(); }
+  CountedRefPtr(const self& rhs): m_ptr(rhs.m_ptr) { reclaim(); }
+
+  self& operator=(ptr_type ptr) {
+    kill();
+    m_ptr = ptr;
+    reclaim();
+    return *this;
+  }
+  self& operator=(const self& rhs) { return operator=(rhs.m_ptr); }
+
+  bool operator==(const self& rhs) const { return m_ptr == rhs.m_ptr; }
+  bool operator==(ptr_type ptr) const { return m_ptr == ptr; }
+
+  operator bool() const { return NeverNull || m_ptr; }
+  operator ptr_type() { return m_ptr; }
+  ptr_type operator->() { return *this; }
+
+  count_type count() const { return m_ptr->ref; }
+
+private:
+  void kill() { if (release()) CountedRefPtr_kill(m_ptr); }
+  
+  void reclaim() { if(*this) ++m_ptr->ref; }
+  count_type release() { return (*this? --m_ptr->ref: 0); }
+  ptr_type m_ptr;
+};
+
+
 class CountedRefEnv {
   typedef CountedRefEnv self;
 
 public:
-
+  typedef CountedRefPtr<idhdl*> root_type;
   static idhdl* locals() {
     static idhdl myroot = NULL;
@@ -52 +89 @@
 
     idhdl* root = locals();
+    short ref = ++(*root)->ref;
+
     assume((*root)->get(name, 0) == NULL); 
-    short ref = (*root)->ref;
-    *root = (*root)->set(name, 0, typ, FALSE);
-    (*root)->ref = ++ref;;
-
+    (*root) = (*root)->set(name, 0, typ, FALSE);
+    assume((*root) != NULL);
     IDDATA(*root) = (char*) data;
+    (*root)->ref = ref;
 
     return *root;
@@ -65 +103 @@
 
     idhdl* root = locals();
-    short ref = (*root)->ref;
+    short ref = --((*root)->ref);
     killhdl2(handle, root, currRing);
-    (*root)->ref = --ref;
-    if(ref > 0) { return;}
-
-    killhdl2(*root, &IDROOT, currRing);
-    (*root) = NULL;
+    (*root)->ref = ref;
+
+    if(ref <= 0) {
+      killhdl2(*root, &IDROOT, currRing);
+      (*root) = NULL;
+    }
  }
 };
+
+
+inline void CountedRefPtr_kill(ring r) { rKill(r); }
 
 
@@ -176 +218 @@
   self& operator=(const self& rhs) { return operator=(rhs.m_data); }
   self& operator=(leftv rhs) {
-    m_data->CleanUp();
-    m_data->Copy(rhs);
+    assume(m_data->rtyp == IDHDL);
+    kill();
+    m_data->e = rhs->e;
+    IDTYP((idhdl)m_data->data) =  rhs->Typ();
+    IDDATA((idhdl)m_data->data) = (char*) rhs->CopyD();
+    rhs->e = NULL;
+    
     return *this;
   }
@@ -195 +242 @@
 public:
   /// Construct reference for Singular object
-  explicit CountedRefData(leftv data, idhdl* ctx = &IDROOT):
-    base(), m_data(data), m_context(ctx) { context(); }
+  explicit CountedRefData(leftv data, BOOLEAN global = TRUE):
+    base(), m_data(data), m_ring(parent(data)), m_global(global) { }
 
   /// Construct deep copy
   CountedRefData(const self& rhs):
-    base(), m_data(rhs.m_data), m_context(rhs.m_context) { }
+    base(), m_data(rhs.m_data), m_ring(rhs.m_ring), m_global(rhs.m_global) { }
   
   /// Destruct
@@ -208 +255 @@
   self& operator=(const self& rhs) {
     m_data = rhs.m_data;
-    m_context = rhs.m_context;
+    m_global = rhs.m_global;
+    m_ring = rhs.m_ring;
     return *this;
   }
  
   /// Replace with other Singular data
-  void set(leftv rhs, idhdl* ctx = &IDROOT) {
+  void set(leftv rhs, BOOLEAN global = TRUE) {
     m_data = rhs;
-    m_context = ctx;
-    context();
+    m_global = global;
+    m_ring = parent(rhs);
   }
 
@@ -232 +280 @@
 private:
   /// Check whether identifier became invalid
-  /// @note Sergio Leone memorial function
+  /// @note Assume that local identifiers are available
   BOOLEAN broken() {
-    if( (m_context == CountedRefEnv::locals()) || (m_context == &currRing->idroot))
-      return FALSE;                  // the good, 
-
-    if (m_data->RingDependend())     // the bad,
-      return complain("Referenced identifier not available in current ring");
-
-    return (brokenid(m_context) &&   // and the ugly (case)
-            ((m_context == &basePack->idroot) || brokenid())) &&
-      complain("Referenced identifier not found in current context");
-  }
-
-  /// Determine corresponding context
-  /// @note for ring-dependent object we always store @c currRing's root as marker 
-  void context() { if (m_data->RingDependend()) m_context = &currRing->idroot; }
-
-  /// 
+    if (m_ring) {
+      if (m_ring != currRing) 
+        return complain("Referenced identifier not from current ring");    
+      return m_global && brokenid(currRing->idroot) &&
+        complain("Referenced identifier not available in ring anymore");  
+    }
+    return m_global &&
+      brokenid(currPack->idroot) &&
+      ((currPack == basePack) || brokenid(basePack->idroot)) &&
+      complain("Referenced identifier not available in current context");
+  }
+
+  /// Raise error message and return @c TRUE
   BOOLEAN complain(const char* text) {
     Werror(text);
     return TRUE;
   }
-  BOOLEAN brokenid(idhdl* root = &basePack->idroot) {
-    idhdl handle = (idhdl) m_data->data;
-    for(idhdl current = *root; current != NULL; current = IDNEXT(current))
-      if (current == handle) return FALSE;
-    return TRUE;
-  }
-
+
+  /// Check a given context for our identifier
+  BOOLEAN brokenid(idhdl context) {
+    return (context == NULL) || 
+      ((context != (idhdl) m_data->data) && brokenid(IDNEXT(context)));
+  }
+
+  /// Store ring for ring-dependent objects
+  static ring parent(leftv rhs) { 
+    return (rhs->RingDependend()? currRing: NULL); 
+  }
 
   /// Singular object
@@ -266 +315 @@
 
   /// Store namespace for ring-dependent objects
-  idhdl* m_context;
+  CountedRefPtr<ring> m_ring;
+
+  /// Marks whether we have to check 
+  bool m_global;
 };
 
@@ -448 +500 @@
   return FALSE;
 }
-                                                                     
+
+BOOLEAN countedref_CheckInit(leftv res, leftv arg)
+{
+  if (arg->Data() != NULL) return FALSE;
+  res->rtyp = NONE;
+  Werror("Noninitialized access");
+  return TRUE;
+}
+                                                                 
 /// blackbox support - unary operations
 BOOLEAN countedref_Op1(int op, leftv res, leftv head)
 {
-  if (head->Data() == NULL) return FALSE;
   if(op == TYPEOF_CMD)
     return blackboxDefaultOp1(op, res, head);
 
+  if (countedref_CheckInit(res, head)) return TRUE;
+
+  if(op == head->Typ()) {
+    res->rtyp = op;
+    return iiAssign(res, head);
+  }
+
   return CountedRef::cast(head).dereference(head) || 
-    iiExprArith1(res, head, (op == DEF_CMD? head->Typ(): op));
+    iiExprArith1(res, head, op == DEF_CMD? head->Typ(): op);
 }
 
@@ -463 +529 @@
 BOOLEAN countedref_Op2(int op, leftv res, leftv head, leftv arg)
 {
-  if (head->Data() == NULL) return FALSE;
-  return CountedRef::cast(head).dereference(head) || CountedRef::resolve(arg) ||
+  return countedref_CheckInit(res, head) ||
+    CountedRef::cast(head).dereference(head) || CountedRef::resolve(arg) ||
     iiExprArith2(res, head, op, arg);
 }
@@ -471 +537 @@
 BOOLEAN countedref_Op3(int op, leftv res, leftv head, leftv arg1, leftv arg2)
 {
-  if (head->Data() == NULL) return FALSE;
-  return  CountedRef::cast(head).dereference(head) || 
+  return countedref_CheckInit(res, head) ||
+    CountedRef::cast(head).dereference(head) || 
     CountedRef::resolve(arg1) || CountedRef::resolve(arg2) ||
     iiExprArith3(res, op, head, arg1, arg2);
@@ -478 +544 @@
 
 
-/// blackbox support - n-ary operations
-BOOLEAN countedref_OpM(int op, leftv res, leftv args)
-{
-  if (args->Data() == NULL) return FALSE;
-
-  if(op == SYSTEM_CMD) {
-    if (args->next) {
-      leftv next = args->next;
-      args->next = NULL;
-      CountedRef obj = CountedRef::cast(args);
-      char* name = (next->Typ() == STRING_CMD? 
-                    (char*) next->Data(): (char*)next->Name());
-      if (strcmp(name, "count") == 0) return obj.count(res);
-      if (strcmp(name, "hash") == 0) return obj.hash(res);
-      if (strcmp(name, "same") == 0) 
-        return (next->next == NULL) ||  obj.same(res, next->next);
-      if ((strcmp(name, "like") == 0) || (strcmp(name, "likewise") == 0))
-        return (next->next == NULL) ||  obj.likewise(res, next->next);
-      if (strcmp(name, "name") == 0) return obj.name(res);
-      if ((strcmp(name, "type") == 0) || (strcmp(name, "typeof") == 0))
-        return obj.type(res);
-      return TRUE;
-    }
-    return TRUE;
-  }
-  return CountedRef::cast(args).dereference(args) || iiExprArithM(res, args, op);
-}
 
 /// blackbox support - destruction
@@ -519 +558 @@
 public:
   /// Construct new reference from Singular data  
-  CountedRefShared(leftv arg):  base(new data_type(wrap(arg), CountedRefEnv::locals())) { }
+  CountedRefShared(leftv arg):  base(new data_type(wrap(arg), FALSE)) { }
 
 private:
@@ -539 +578 @@
   /// Replace data that reference is pointing to
   self& operator=(leftv rhs) {
-    m_data->set(wrap(rhs), CountedRefEnv::locals());
+    m_data->set(rhs, FALSE);
     return *this;
   }
@@ -571 +610 @@
 
 
+/// blackbox support - n-ary operations
+BOOLEAN countedref_OpM(int op, leftv res, leftv args)
+{
+  if (args->Data() == NULL) return FALSE;
+
+  if(op == SYSTEM_CMD) {
+    if (args->next) {
+      leftv next = args->next;
+      args->next = NULL;
+      CountedRef obj = CountedRef::cast(args);
+      char* name = (next->Typ() == STRING_CMD? 
+                    (char*) next->Data(): (char*)next->Name());
+      next = next->next;
+      if (next) {
+        if (strcmp(name, "same") == 0) return obj.same(res, next);
+        if (strncmp(name, "like", 4) == 0) return obj.likewise(res, next);
+      }
+      if (strncmp(name, "count", 5) == 0) return obj.count(res);
+      if (strcmp(name, "hash") == 0) return obj.hash(res);
+      if (strcmp(name, "name") == 0) return obj.name(res);
+      if (strncmp(name, "type", 4) == 0) return obj.type(res);
+    }
+    return TRUE;
+  }
+  return CountedRef::cast(args).dereference(args) || iiExprArithM(res, args, op);
+}
 /// blackbox support - assign element
 BOOLEAN countedref_AssignShared(leftv result, leftv arg)
@@ -581 +646 @@
   }
   
-  /// Case: new shared data
+  /// Case: new reference to already shared data
   if (result->Typ() == arg->Typ()) 
     return CountedRefShared::cast(arg).outcast(result);
 
+  /// Case: new shared data
   return CountedRefShared(arg).outcast(result);
 }