I don't know if this is pertinent, but I was just wondering, in the file stream.d, the copyFrom(Stream s, uint count) method does not seem to utilize the count parameter and doesnt seem to function correctly. Am I right in this assumption? Here is the code.

 // copies specified number of bytes from given stream into
  // this one, may throw ReadError or WriteError on failure
  void copyFrom(Stream s, uint count)
  {
    ubyte[] buf;
    buf.length = s.size();
    s.readExact(buf, buf.length);
    writeExact(buf, buf.length);
  }



Shouldn't it be something like

 // copies specified number of bytes from given stream into
  // this one, may throw ReadError or WriteError on failure
  void copyFrom(Stream s, uint count)
  {
    ubyte[] buf;
    buf.length = count;
    s.readExact(buf, buf.length);
    writeExact(buf, buf.length);
  }

I wanted to test this but that leaves me to my next question. If we make personal changes to the D source code, how do we make it so next time we run the compiler, these changes go inter effect?

Sorry if this was already a noted bug.

It indeed looks like a bug, im not surprised.

>how do we make it so next time we run
>the compiler, these changes go inter effect?

Youll need to rebuild phobos ( each time a new compiler comes out ) , see
dmd/src/win32.mak .

I wish someone would teach Walter how to delegate ... maybe he doubts our abilities.

Charlie

In article <caqv7i$24a9$1@digitaldaemon.com>, Rick S. says...
>
>I don't know if this is pertinent, but I was just wondering, in the file stream.d, the copyFrom(Stream s, uint count) method does not seem to utilize the count parameter and doesnt seem to function correctly. Am I right in this assumption? Here is the code.
>
> // copies specified number of bytes from given stream into
>  // this one, may throw ReadError or WriteError on failure
>  void copyFrom(Stream s, uint count)
>  {
>    ubyte[] buf;
>    buf.length = s.size();
>    s.readExact(buf, buf.length);
>    writeExact(buf, buf.length);
>  }
>
>
>
>Shouldn't it be something like
>
> // copies specified number of bytes from given stream into
>  // this one, may throw ReadError or WriteError on failure
>  void copyFrom(Stream s, uint count)
>  {
>    ubyte[] buf;
>    buf.length = count;
>    s.readExact(buf, buf.length);
>    writeExact(buf, buf.length);
>  }
>
>I wanted to test this but that leaves me to my next question. If we make personal changes to the D source code, how do we make it so next time we run the compiler, these changes go inter effect?
>
>Sorry if this was already a noted bug.
>
>

Rick S. wrote:

> I don't know if this is pertinent, but I was just wondering, in the file stream.d, the copyFrom(Stream s, uint count) method does not seem to utilize the count parameter and doesnt seem to function correctly. Am I right in this assumption? Here is the code.
> 
>  // copies specified number of bytes from given stream into
>   // this one, may throw ReadError or WriteError on failure
>   void copyFrom(Stream s, uint count)
>   {
>     ubyte[] buf;
>     buf.length = s.size();
>     s.readExact(buf, buf.length);
>     writeExact(buf, buf.length);
>   }
> 
> 
> 
> Shouldn't it be something like
> 
>  // copies specified number of bytes from given stream into
>   // this one, may throw ReadError or WriteError on failure
>   void copyFrom(Stream s, uint count)
>   {
>     ubyte[] buf;
>     buf.length = count;
>     s.readExact(buf, buf.length);
>     writeExact(buf, buf.length);
>   }

Good catch. It's too bad it always allocates a new buffer, too. All that
garbage... sigh. An optional buffer input might be nice:
   void copyFrom(Stream s, uint count, ubyte[] buf = null)
   {
     if (buf.length == 0)
       buf.length = count;
     do
     {
       uint bufcount = count > buf.length ? buf.length : count;
       s.readExact(buf, bufcount);
       writeExact(buf, bufcount);
       count -= buf.length;
     }  while (count > 0)
   }

> I wanted to test this but that leaves me to my next question. If we make personal changes to the D source code, how do we make it so next time we run the compiler, these changes go inter effect?
> 
> Sorry if this was already a noted bug.

Try sending Walter some email. Since the code fragment is small he might just pop it in himself once he sees it here.

It's been discussed before, but what about getting a bug tracker and source code management for Phobos.  I would be happy to host Phobos at dsource.org.

http://projects.edgewall.com/trac/

The above link is a product that I am attempting to rig up to dsource so you can have Subversion browsing, Changesets, Wiki, Ticket Tracker, and Roadmap, all integrated.  (a good example: http://projects.edgewall.com/trac/ticket/461 - they put the patch in a comment, not as an attachment, but whatever)

Walter would have write-access to Subversion, and all of us yahoos can submit patches as attachments to tickets.  Walter can patch the source, resolve the tickets, and include the code in the next build.  He could even delegate, as Charlie said, to someone worthy (i.e. not me).

At some point, Linus had to get some good lieutenants.  I know we're pre-1.0, but Walter's pounding out a compiler, language spec website, standard library, and listening to us whine about a whole lot of stuff in the NG.  Maybe this is a good starting point to offloading some of Walter's plate.

Or he could stay status-quo with his Outlook Express folders.  It's up to Walter.  Either way, we still get to use DMD and Phobos, and that's pretty cool.

BA





Charlie wrote:
> It indeed looks like a bug, im not surprised.
> 
> 
>>how do we make it so next time we run
>>the compiler, these changes go inter effect?
> 
> 
> Youll need to rebuild phobos ( each time a new compiler comes out ) , see
> dmd/src/win32.mak .
> 
> I wish someone would teach Walter how to delegate ... maybe he doubts our
> abilities.
> 
> Charlie
> 
> In article <caqv7i$24a9$1@digitaldaemon.com>, Rick S. says...
> 
>>I don't know if this is pertinent, but I was just wondering, in the file
>>stream.d, the copyFrom(Stream s, uint count) method does not seem to utilize
>>the count parameter and doesnt seem to function correctly. Am I right in
>>this assumption? Here is the code.
>>
>>// copies specified number of bytes from given stream into
>> // this one, may throw ReadError or WriteError on failure
>> void copyFrom(Stream s, uint count)
>> {
>>   ubyte[] buf;
>>   buf.length = s.size();
>>   s.readExact(buf, buf.length);
>>   writeExact(buf, buf.length);
>> }
>>
>>
>>
>>Shouldn't it be something like
>>
>>// copies specified number of bytes from given stream into
>> // this one, may throw ReadError or WriteError on failure
>> void copyFrom(Stream s, uint count)
>> {
>>   ubyte[] buf;
>>   buf.length = count;
>>   s.readExact(buf, buf.length);
>>   writeExact(buf, buf.length);
>> }
>>
>>I wanted to test this but that leaves me to my next question. If we make
>>personal changes to the D source code, how do we make it so next time we run
>>the compiler, these changes go inter effect?
>>
>>Sorry if this was already a noted bug.
>>
>>
> 
> 
>