code review 882043: change channel read to clear

src/pkg/runtime/chan.c

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 #include "runtime.h"
 #include "type.h"
 
 static  int32   debug   = 0;
 
 enum
@@ skipping 282 matching lines @@
 loop:
         if(c->dataqsiz > 0)
                 goto asynch;
 
         if(c->closed & Wclosed)
                 goto closed;
 
         sg = dequeue(&c->sendq, c);
         if(sg != nil) {
                 c->elemalg->copy(c->elemsize, ep, sg->elem);
+                c->elemalg->copy(c->elemsize, sg->elem, nil);
 
                 gp = sg->g;
                 gp->param = sg;
                 unlock(c);
                 ready(gp);
 
                 if(pres != nil)
                         *pres = true;
                 return;
         }
@@ skipping 11 matching lines @@
         enqueue(&c->recvq, sg);
         unlock(c);
         gosched();
 
         lock(c);
         sg = g->param;
         if(sg == nil)
                 goto loop;
 
         c->elemalg->copy(c->elemsize, ep, sg->elem);
+        c->elemalg->copy(c->elemsize, sg->elem, nil);
         freesg(c, sg);
         unlock(c);
         return;
 
 asynch:
         if(c->qcount <= 0) {
                 if(c->closed & Wclosed)
                         goto closed;
 
                 if(pres != nil) {
                         unlock(c);
                         c->elemalg->copy(c->elemsize, ep, nil);
                         *pres = false;
                         return;
                 }
                 sg = allocsg(c);
                 g->status = Gwaiting;
                 enqueue(&c->recvq, sg);
                 unlock(c);
                 gosched();
 
                 lock(c);
                 goto asynch;
         }
         c->elemalg->copy(c->elemsize, ep, c->recvdataq->elem);
+        c->elemalg->copy(c->elemsize, c->recvdataq->elem, nil);
         c->recvdataq = c->recvdataq->link;
         c->qcount--;
         sg = dequeue(&c->sendq, c);
         if(sg != nil) {
                 gp = sg->g;
                 freesg(c, sg);
                 unlock(c);
                 ready(gp);
                 if(pres != nil)
                         *pres = true;
@@ skipping 402 matching lines @@
         if(c->dataqsiz > 0) {
 //              prints("shouldnt happen\n");
                 goto loop;
         }
 
         if(debug)
                 printf("wait-return: sel=%p c=%p cas=%p send=%d o=%d\n",
                         sel, c, cas, cas->send, o);
 
         if(!cas->send) {
-                if(cas->u.elemp != nil)
+                if(cas->u.elemp != nil) {
                         c->elemalg->copy(c->elemsize, cas->u.elemp, sg->elem);
+                        c->elemalg->copy(c->elemsize, sg->elem, nil);
+                }
         }
 
         freesg(c, sg);
         goto retc;
 
 asyncrecv:
         // can receive from buffer
-        if(cas->u.elemp != nil)
+        if(cas->u.elemp != nil) {
                 c->elemalg->copy(c->elemsize, cas->u.elemp, c->recvdataq->elem);
+                c->elemalg->copy(c->elemsize, c->recvdataq->elem, nil);
+        }
         c->recvdataq = c->recvdataq->link;
         c->qcount--;
         sg = dequeue(&c->sendq, c);
         if(sg != nil) {
                 gp = sg->g;
                 freesg(c, sg);
                 ready(gp);
         }
         goto retc;
 
 asyncsend:
         // can send to buffer
         if(cas->u.elem != nil)
                 c->elemalg->copy(c->elemsize, c->senddataq->elem, cas->u.elem);
         c->senddataq = c->senddataq->link;
         c->qcount++;
         sg = dequeue(&c->recvq, c);
         if(sg != nil) {
                 gp = sg->g;
                 freesg(c, sg);
                 ready(gp);
         }
         goto retc;
 
 syncrecv:
         // can receive from sleeping sender (sg)
         if(debug)
                 printf("syncrecv: sel=%p c=%p o=%d\n", sel, c, o);
-        if(cas->u.elemp != nil)
+        if(cas->u.elemp != nil) {
                 c->elemalg->copy(c->elemsize, cas->u.elemp, sg->elem);
+                c->elemalg->copy(c->elemsize, sg->elem, nil);
+        }
         gp = sg->g;
         gp->param = sg;
         ready(gp);
         goto retc;
 
 rclose:
         // read at end of closed channel
         if(cas->u.elemp != nil)
                 c->elemalg->copy(c->elemsize, cas->u.elemp, nil);
         c->closed |= Rclosed;
@@ skipping 207 matching lines @@
 static uint32
 fastrand2(void)
 {
         static uint32 x = 0x49f6428aUL;
 
         x += x;
         if(x & 0x80000000L)
                 x ^= 0xfafd871bUL;
         return x;
 }